src/SMESHGUI/SMESHGUI.cxx

   1 // Copyright (C) 2007-2013  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //  File   : SMESHGUI.cxx
  23 //  Author : Nicolas REJNERI, Open CASCADE S.A.S.
  24
  25 #include <Standard_math.hxx>  // E.A. must be included before Python.h to fix compilation on windows
  26 #ifdef HAVE_FINITE
  27 #undef HAVE_FINITE            // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
  28 #endif
  29 #include "Python.h"
  30
  31 //  SMESH includes
  32 #include "SMESHGUI.h"
  33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
  34 #include "SMESHGUI_AddMeshElementDlg.h"
  35 #include "SMESHGUI_AddQuadraticElementDlg.h"
  36 #include "SMESHGUI_BuildCompoundDlg.h"
  37 #include "SMESHGUI_ClippingDlg.h"
  38 #include "SMESHGUI_ComputeDlg.h"
  39 #include "SMESHGUI_ConvToQuadOp.h"
  40 #include "SMESHGUI_CopyMeshDlg.h"
  41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
  42 #include "SMESHGUI_DeleteGroupDlg.h"
  43 #include "SMESHGUI_Displayer.h"
  44 #include "SMESHGUI_DuplicateNodesDlg.h"
  45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
  46 #include "SMESHGUI_ExtrusionDlg.h"
  47 #include "SMESHGUI_FileInfoDlg.h"
  48 #include "SMESHGUI_FileValidator.h"
  49 #include "SMESHGUI_FilterDlg.h"
  50 #include "SMESHGUI_FilterLibraryDlg.h"
  51 #include "SMESHGUI_FindElemByPointDlg.h"
  52 #include "SMESHGUI_GroupDlg.h"
  53 #include "SMESHGUI_GroupOnShapeDlg.h"
  54 #include "SMESHGUI_GroupOpDlg.h"
  55 #include "SMESHGUI_Hypotheses.h"
  56 #include "SMESHGUI_Make2DFrom3DOp.h"
  57 #include "SMESHGUI_MakeNodeAtPointDlg.h"
  58 #include "SMESHGUI_Measurements.h"
  59 #include "SMESHGUI_MergeDlg.h"
  60 #include "SMESHGUI_MeshInfo.h"
  61 #include "SMESHGUI_MeshOp.h"
  62 #include "SMESHGUI_MeshOrderOp.h"
  63 #include "SMESHGUI_MeshPatternDlg.h"
  64 #include "SMESHGUI_MultiEditDlg.h"
  65 #include "SMESHGUI_NodesDlg.h"
  66 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
  67 #include "SMESHGUI_PropertiesDlg.h"
  68 #include "SMESHGUI_RemoveElementsDlg.h"
  69 #include "SMESHGUI_RemoveNodesDlg.h"
  70 #include "SMESHGUI_RenumberingDlg.h"
  71 #include "SMESHGUI_ReorientFacesDlg.h"
  72 #include "SMESHGUI_RevolutionDlg.h"
  73 #include "SMESHGUI_RotationDlg.h"
  74 #include "SMESHGUI_ScaleDlg.h"
  75 #include "SMESHGUI_Selection.h"
  76 #include "SMESHGUI_SewingDlg.h"
  77 #include "SMESHGUI_SingleEditDlg.h"
  78 #include "SMESHGUI_SmoothingDlg.h"
  79 #include "SMESHGUI_SymmetryDlg.h"
  80 #include "SMESHGUI_TranslationDlg.h"
  81 #include "SMESHGUI_TransparencyDlg.h"
  82
  83 #include "SMESHGUI_FilterUtils.h"
  84 #include "SMESHGUI_GroupUtils.h"
  85 #include "SMESHGUI_HypothesesUtils.h"
  86 #include "SMESHGUI_MeshUtils.h"
  87 #include "SMESHGUI_PatternUtils.h"
  88 #include "SMESHGUI_Utils.h"
  89 #include "SMESHGUI_VTKUtils.h"
  90
  91 #include <SMESH_version.h>
  92
  93 #include "SMESH_ControlsDef.hxx"
  94 #include <SMESH_Actor.h>
  95 #include <SMESH_ActorUtils.h>
  96 #include <SMESH_Client.hxx>
  97 #include <SMESH_ScalarBarActor.h>
  98 #include <SMESH_TypeFilter.hxx>
  99
 100 // SALOME GUI includes
 101 #include <SalomeApp_Application.h>
 102 #include <SalomeApp_CheckFileDlg.h>
 103 #include <SalomeApp_DataObject.h>
 104 #include <SalomeApp_Study.h>
 105 #include <SalomeApp_Tools.h>
 106
 107 #include <LightApp_DataOwner.h>
 108 #include <LightApp_NameDlg.h>
 109 #include <LightApp_Preferences.h>
 110 #include <LightApp_SelectionMgr.h>
 111 #include <LightApp_UpdateFlags.h>
 112
 113 #include <SVTK_ViewManager.h>
 114 #include <SVTK_ViewModel.h>
 115 #include <SVTK_ViewWindow.h>
 116
 117 #include <VTKViewer_Algorithm.h>
 118
 119 #include <SUIT_Desktop.h>
 120 #include <SUIT_FileDlg.h>
 121 #include <SUIT_MessageBox.h>
 122 #include <SUIT_OverrideCursor.h>
 123 #include <SUIT_ResourceMgr.h>
 124 #include <SUIT_Session.h>
 125
 126 #include <QtxPopupMgr.h>
 127 #include <QtxFontEdit.h>
 128
 129 #include <SALOME_ListIO.hxx>
 130 #include <SALOME_ListIteratorOfListIO.hxx>
 131
 132 #ifndef DISABLE_PLOT2DVIEWER
 133 #include <SPlot2d_ViewModel.h>
 134 #include <SPlot2d_Histogram.h>
 135 #endif
 136
 137 // IDL includes
 138 #include <SALOMEconfig.h>
 139 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
 140 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
 141 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
 142
 143 // Qt includes
 144 // #define       INCLUDE_MENUITEM_DEF // VSR commented ????????
 145 #include <QApplication>
 146 #include <QMenu>
 147 #include <QTextStream>
 148
 149 // BOOST includes
 150 #include <boost/shared_ptr.hpp>
 151
 152 // VTK includes
 153 #include <vtkCallbackCommand.h>
 154 #include <vtkCamera.h>
 155 #include <vtkLookupTable.h>
 156 #include <vtkPlane.h>
 157 #include <vtkRenderer.h>
 158
 159 // SALOME KERNEL includes
 160 #include <SALOMEDSClient_ClientFactory.hxx>
 161 #include <SALOMEDSClient_IParameters.hxx>
 162 #include <SALOMEDSClient_SComponent.hxx>
 163 #include <SALOMEDSClient_StudyBuilder.hxx>
 164 #include <SALOMEDS_Study.hxx>
 165
 166 // OCCT includes
 167 #include <Standard_ErrorHandler.hxx>
 168 #include <NCollection_DataMap.hxx>
 169
 170 #include <Basics_Utils.hxx>
 171
 172 //To disable automatic genericobj management, the following line should be commented.
 173 //Otherwise, it should be uncommented.
 174 //Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
 175 #define WITHGENERICOBJ
 176
 177 // Below macro, when uncommented, switches on simplified (more performant) algorithm
 178 // of auto-color picking up
 179 #define SIMPLE_AUTOCOLOR
 180
 181 //namespace{
 182   // Declarations
 183   //=============================================================
 184   void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
 185                             int theCommandID);
 186
 187   void ExportMeshToFile(int theCommandID);
 188
 189   void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
 190
 191   void SetDisplayEntity(int theCommandID);
 192
 193   void Control( int theCommandID );
 194
 195
 196   // Definitions
 197   //=============================================================
 198   void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
 199                              int theCommandID )
 200   {
 201     QStringList filter;
 202     std::string myExtension;
 203
 204     if ( theCommandID == 113 ) {
 205       filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
 206       filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
 207     }
 208     else if ( theCommandID == 112 ) {
 209       filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
 210     }
 211     else if ( theCommandID == 111 ) {
 212       filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
 213     }
 214     else if ( theCommandID == 115 ) {
 215       filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
 216     }
 217     else if ( theCommandID == 116 ) {
 218       filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
 219     }
 220     else if ( theCommandID == 117 ) {
 221       filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
 222       filter.append( QObject::tr( "All files (*)" ) );
 223     }
 224     else if ( theCommandID == 118 ) {
 225       filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)"  );
 226       filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
 227     }
 228
 229     QString anInitialPath = "";
 230     if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
 231       anInitialPath = QDir::currentPath();
 232
 233     QStringList filenames;
 234     bool toCreateGroups = true;
 235
 236     // if ( theCommandID == 118 ) { // GMF
 237     //   SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
 238     //     ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
 239     //   fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
 240     //   fd->setNameFilters( filter );
 241     //   fd->SetChecked( true );
 242     //   if ( fd->exec() )
 243     //     filenames << fd->selectedFile();
 244     //   toCreateGroups = fd->IsChecked();
 245
 246     //   delete fd;
 247     // }
 248     // else
 249     {
 250       filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
 251                                                   anInitialPath,
 252                                                   filter,
 253                                                   QObject::tr( "SMESH_IMPORT_MESH" ) );
 254     }
 255     if ( filenames.count() > 0 ) {
 256       SUIT_OverrideCursor wc;
 257       _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
 258
 259       QStringList errors;
 260       QStringList anEntryList;
 261       bool isEmpty = false;
 262       for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
 263         QString filename = *it;
 264         SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
 265         try {
 266           switch ( theCommandID ) {
 267           case 111:
 268             {
 269               // DAT format (currently unsupported)
 270               errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 271                              arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
 272               break;
 273             }
 274           case 112:
 275             {
 276               // UNV format
 277               aMeshes->length( 1 );
 278               aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toLatin1().constData() );
 279               if ( aMeshes[0]->_is_nil() )
 280                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 281                                arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
 282               break;
 283             }
 284           case 113:
 285             {
 286               // MED format
 287               SMESH::DriverMED_ReadStatus res;
 288               aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toLatin1().constData(), res );
 289               if ( res != SMESH::DRS_OK ) {
 290                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 291                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
 292               }
 293               break;
 294             }
 295           case 115:
 296             {
 297               // STL format
 298               aMeshes->length( 1 );
 299               aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toLatin1().constData() );
 300               if ( aMeshes[0]->_is_nil() ) {
 301                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 302                                arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
 303               }
 304               break;
 305             }
 306           case 116:
 307             {
 308               // CGNS format
 309               SMESH::DriverMED_ReadStatus res;
 310               aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toLatin1().constData(), res );
 311               if ( res != SMESH::DRS_OK ) {
 312                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 313                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
 314               }
 315               break;
 316             }
 317           case 117:
 318             {
 319               // SAUV format
 320               SMESH::DriverMED_ReadStatus res;
 321               aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toLatin1().constData(), res );
 322               if ( res != SMESH::DRS_OK ) {
 323                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 324                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
 325               }
 326               break;
 327             }
 328           case 118:
 329             {
 330               // GMF format
 331               SMESH::ComputeError_var res;
 332               aMeshes->length( 1 );
 333               aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toLatin1().constData(),
 334                                                                   toCreateGroups,
 335                                                                   res.out() );
 336               if ( res->code != SMESH::DRS_OK ) {
 337                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 338                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
 339                 if ( strlen( res->comment.in() ) > 0 ) {
 340                   errors.back() += ": ";
 341                   errors.back() += res->comment.in();
 342                 }
 343               }
 344               break;
 345             }
 346           }
 347         }
 348         catch ( const SALOME::SALOME_Exception& S_ex ) {
 349           errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 350                          arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
 351         }
 352
 353         for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
 354           _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
 355           if ( aMeshSO ) {
 356             _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
 357             _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
 358             aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
 359             if ( theCommandID == 112 ) // mesh names aren't taken from the file for UNV import
 360               SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
 361
 362             anEntryList.append( aMeshSO->GetID().c_str() );
 363
 364             // obj has been published in study. Its refcount has been incremented.
 365             // It is safe to decrement its refcount
 366             // so that it will be destroyed when the entry in study will be removed
 367             aMeshes[i]->UnRegister();
 368           }
 369           else {
 370             isEmpty = true;
 371           }
 372         }
 373       }
 374
 375       // update Object browser
 376       SMESHGUI::GetSMESHGUI()->updateObjBrowser();
 377
 378       // browse to the published meshes
 379       if( LightApp_Application* anApp =
 380           dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
 381         anApp->browseObjects( anEntryList );
 382
 383       // show Error message box if there were errors
 384       if ( errors.count() > 0 ) {
 385         SUIT_MessageBox::critical( SMESHGUI::desktop(),
 386                                    QObject::tr( "SMESH_ERROR" ),
 387                                    QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
 388       }
 389
 390       // show warning message box, if some imported mesh is empty
 391       if ( isEmpty ) {
 392           SUIT_MessageBox::warning( SMESHGUI::desktop(),
 393                                     QObject::tr( "SMESH_WRN_WARNING" ),
 394                                     QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
 395       }
 396     }
 397   }
 398
 399   //================================================================================
 400   /*!
 401    * \brief Export selected meshes or groups into a file
 402    */
 403   //================================================================================
 404
 405   void ExportMeshToFile( int theCommandID )
 406   {
 407     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
 408     SALOME_ListIO selected;
 409     if( aSel )
 410       aSel->selectedObjects( selected );
 411
 412     const bool isMED = ( theCommandID == 122 || theCommandID == 125 );
 413     const bool isDAT = ( theCommandID == 121 || theCommandID == 124 );
 414     const bool isUNV = ( theCommandID == 123 || theCommandID == 126 );
 415     const bool isSTL = ( theCommandID == 140 || theCommandID == 141 );
 416     const bool isCGNS= ( theCommandID == 142 || theCommandID == 143 );
 417     const bool isSAUV= ( theCommandID == 144 || theCommandID == 145 );
 418     const bool isGMF = ( theCommandID == 146 || theCommandID == 147 );
 419
 420     // actually, the following condition can't be met (added for insurance)
 421     if( selected.Extent() == 0 ||
 422         ( selected.Extent() > 1 && !isMED && !isSTL ))
 423       return;
 424
 425     // get mesh object from selection and check duplication of their names
 426     bool hasDuplicatedMeshNames = false;
 427     QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
 428     QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
 429     SALOME_ListIteratorOfListIO It( selected );
 430     for( ; It.More(); It.Next() )
 431     {
 432       Handle(SALOME_InteractiveObject) anIObject = It.Value();
 433       SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
 434       if ( aMeshItem->_is_nil() ) {
 435         SUIT_MessageBox::warning( SMESHGUI::desktop(),
 436                                   QObject::tr( "SMESH_WRN_WARNING" ),
 437                                   QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
 438         return;
 439       }
 440
 441       QString aMeshName = anIObject->getName();
 442
 443       // check for name duplications
 444       if ( !hasDuplicatedMeshNames )
 445         for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 446           if( aMeshName == (*aMeshIter).second ) {
 447             hasDuplicatedMeshNames = true;
 448             break;
 449           }
 450         }
 451
 452       aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
 453     }
 454
 455     if( hasDuplicatedMeshNames && isMED ) {
 456       int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 457                                           QObject::tr("SMESH_WRN_WARNING"),
 458                                           QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
 459                                           QObject::tr("SMESH_BUT_YES"),
 460                                           QObject::tr("SMESH_BUT_NO"), 0, 1);
 461       if (aRet != 0)
 462         return;
 463     }
 464
 465     aMeshIter = aMeshList.begin();
 466     SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
 467     SMESH::SMESH_Mesh_var            aMesh = aMeshOrGroup->GetMesh();
 468     QString                      aMeshName = (*aMeshIter).second;
 469
 470     if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
 471     {
 472       // check for equal group names within each mesh
 473       for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 474         SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
 475         if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
 476           int aRet = SUIT_MessageBox::warning
 477             (SMESHGUI::desktop(),
 478              QObject::tr("SMESH_WRN_WARNING"),
 479              QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
 480              QObject::tr("SMESH_BUT_YES"),
 481              QObject::tr("SMESH_BUT_NO"), 0, 1);
 482           if (aRet != 0)
 483             return;
 484         }
 485       }
 486     }
 487
 488     // Warn the user about presence of not supported elements
 489     QString format;
 490     std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
 491     if ( isDAT )
 492     {
 493       format = "DAT";
 494       notSupportedElemTypes.push_back( SMESH::Entity_0D );
 495       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 496     }
 497     else if ( isUNV )
 498     {
 499       format = "UNV";
 500       notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
 501       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
 502       notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
 503       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
 504       notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
 505       notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
 506       notSupportedElemTypes.push_back( SMESH::Entity_0D );
 507       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 508     }
 509     else if ( isSTL )
 510     {
 511       format = "STL";
 512       notSupportedElemTypes.push_back( SMESH::Entity_Edge );
 513       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
 514       notSupportedElemTypes.push_back( SMESH::Entity_0D );
 515       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 516     }
 517     else if ( isCGNS )
 518     {
 519       format = "CGNS";
 520       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 521       notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
 522     }
 523     else if ( isSAUV )
 524     {
 525       format = "SAUV";
 526       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 527       notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
 528       notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
 529       notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
 530       notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
 531       notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
 532       notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
 533     }
 534     else if ( isGMF )
 535     {
 536       format = "GMF";
 537       notSupportedElemTypes.push_back( SMESH::Entity_0D );
 538       notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
 539       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
 540       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
 541       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
 542       notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
 543       notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
 544       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
 545       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 546     }
 547     if ( ! notSupportedElemTypes.empty() )
 548     {
 549       SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
 550       for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
 551         if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
 552           presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
 553     }
 554     if ( !presentNotSupported.empty() )
 555     {
 556       QString typeNames;
 557       const char* typeMsg[SMESH::Entity_Last] = {
 558         "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
 559         "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
 560         "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
 561         "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
 562         "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
 563         "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
 564         "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
 565         "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
 566       };
 567       QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
 568       for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
 569         typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
 570         if ( iType != presentNotSupported.size() - 1 )
 571           typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
 572       }
 573       int aRet = SUIT_MessageBox::warning
 574         (SMESHGUI::desktop(),
 575          QObject::tr("SMESH_WRN_WARNING"),
 576          QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
 577          QObject::tr("SMESH_BUT_YES"),
 578          QObject::tr("SMESH_BUT_NO"), 0, 1);
 579       if (aRet != 0)
 580         return;
 581     }
 582
 583     // Get parameters of export operation
 584
 585     QString            aFilename;
 586     SMESH::MED_VERSION aFormat;
 587     // Init the parameters with the default values
 588     bool aIsASCII_STL   = true;
 589     bool toCreateGroups = false;
 590     SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 591     if ( resMgr )
 592       toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
 593     bool toOverwrite = true;
 594     bool toFindOutDim = true;
 595
 596     QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
 597     QString anInitialPath = "";
 598     if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
 599       anInitialPath = QDir::currentPath();
 600
 601     // Get a file name to write in and additional otions
 602     if ( isUNV || isDAT || isGMF ) // Export w/o options
 603     {
 604       if ( isUNV )
 605         aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
 606       else if ( isDAT )
 607         aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
 608       else if ( isGMF )
 609         aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
 610           ";;" +  QObject::tr( "GMF_BINARY_FILES_FILTER" )  + " (*.meshb)";
 611      if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
 612       aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
 613                                             anInitialPath + QString("/") + aMeshName,
 614                                             aFilter, aTitle, false);
 615     }
 616     else if ( isCGNS )// Export to CGNS
 617     {
 618       SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
 619       fd->setWindowTitle( aTitle );
 620       fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
 621       if ( !anInitialPath.isEmpty() )
 622         fd->setDirectory( anInitialPath );
 623       fd->selectFile(aMeshName);
 624       SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
 625       fd->setValidator( fv );
 626
 627       if ( fd->exec() )
 628         aFilename = fd->selectedFile();
 629       toOverwrite = fv->isOverwrite();
 630
 631       delete fd;
 632     }
 633     else if ( isSTL ) // Export to STL
 634     {
 635       QMap<QString, int> aFilterMap;
 636       aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
 637       aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" )   + " (*.stl)", 0 );
 638
 639       QStringList filters;
 640       QMap<QString, int>::const_iterator it = aFilterMap.begin();
 641       for ( ; it != aFilterMap.end(); ++it )
 642         filters.push_back( it.key() );
 643
 644       SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
 645       fd->setWindowTitle( aTitle );
 646       fd->setNameFilters( filters );
 647       fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
 648       if ( !anInitialPath.isEmpty() )
 649         fd->setDirectory( anInitialPath );
 650       fd->selectFile(aMeshName);
 651       bool is_ok = false;
 652       while (!is_ok) {
 653         if ( fd->exec() )
 654           aFilename = fd->selectedFile();
 655         aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
 656         is_ok = true;
 657       }
 658       delete fd;
 659     }
 660     else if ( isMED || isSAUV ) // Export to MED or SAUV
 661     {
 662       QMap<QString, SMESH::MED_VERSION> aFilterMap;
 663       //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
 664       if ( isMED ) {
 665         QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
 666         //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
 667         aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
 668       }
 669       else { // isSAUV
 670         aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
 671         aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
 672         aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
 673       }
 674
 675       QStringList filters;
 676       QString aDefaultFilter;
 677       QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
 678       for ( ; it != aFilterMap.end(); ++it ) {
 679         filters.push_back( it.key() );
 680         if (it.value() == SMESH::MED_V2_2)
 681           aDefaultFilter = it.key();
 682       }
 683       QStringList checkBoxes;
 684       checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
 685
 686       SalomeApp_CheckFileDlg* fd =
 687         new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
 688       fd->setWindowTitle( aTitle );
 689       fd->setNameFilters( filters );
 690       fd->selectNameFilter(aDefaultFilter);
 691       fd->SetChecked(0,toCreateGroups);
 692       fd->SetChecked(1,toFindOutDim);
 693       if ( !anInitialPath.isEmpty() )
 694         fd->setDirectory( anInitialPath );
 695       fd->selectFile(aMeshName);
 696
 697       SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
 698       fd->setValidator( fv );
 699
 700       bool is_ok = false;
 701       while (!is_ok) {
 702         if ( fd->exec() )
 703           aFilename = fd->selectedFile();
 704         else {
 705           aFilename = QString::null;
 706           break;
 707         }
 708         aFormat = aFilterMap[fd->selectedNameFilter()];
 709         toOverwrite = fv->isOverwrite();
 710         is_ok = true;
 711         if ( !aFilename.isEmpty() ) {
 712           // med-2.1 does not support poly elements
 713           if ( aFormat==SMESH::MED_V2_1 )
 714             for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 715               SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
 716               SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
 717               if ( nbElems[ SMESH::Entity_Polygon   ] + nbElems[ SMESH::Entity_Quad_Polygon   ] +
 718                    nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
 719               {
 720                 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 721                                                     QObject::tr("SMESH_WRN_WARNING"),
 722                                                     QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
 723                                                     QObject::tr("SMESH_BUT_YES"),
 724                                                     QObject::tr("SMESH_BUT_NO"), 0, 1);
 725                 if (aRet != 0) {
 726                   is_ok = false;
 727                   break;
 728                 }
 729               }
 730             }
 731           if( !toOverwrite ) {
 732             // can't append to an existing using other format
 733             SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
 734             bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toLatin1().constData(), aVersion );
 735             if( !isVersionOk || aVersion != aFormat ) {
 736               int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 737                                                   QObject::tr("SMESH_WRN_WARNING"),
 738                                                   QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
 739                                                   QObject::tr("SMESH_BUT_YES"),
 740                                                   QObject::tr("SMESH_BUT_NO"), 0, 1);
 741               if (aRet == 0)
 742                 toOverwrite = true;
 743               else
 744                 is_ok = false;
 745             }
 746
 747             QStringList aMeshNamesCollisionList;
 748             SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toLatin1().constData() );
 749             for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
 750               QString anExistingMeshName( aMeshNames[ i ] );
 751               for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 752                 QString anExportMeshName = (*aMeshIter).second;
 753                 if( anExportMeshName == anExistingMeshName ) {
 754                   aMeshNamesCollisionList.append( anExportMeshName );
 755                   break;
 756                 }
 757               }
 758             }
 759             if( !aMeshNamesCollisionList.isEmpty() ) {
 760               QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
 761               int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 762                                                   QObject::tr("SMESH_WRN_WARNING"),
 763                                                   QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
 764                                                   QObject::tr("SMESH_BUT_YES"),
 765                                                   QObject::tr("SMESH_BUT_NO"),
 766                                                   QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
 767               if (aRet == 0)
 768                 toOverwrite = true;
 769               else if (aRet == 2)
 770                 is_ok = false;
 771             }
 772           }
 773         }
 774       }
 775       toCreateGroups = fd->IsChecked(0);
 776       toFindOutDim   = fd->IsChecked(1);
 777       delete fd;
 778     }
 779     else
 780     {
 781       return;
 782     }
 783
 784     // Perform export
 785
 786     if ( !aFilename.isEmpty() ) {
 787       // Check whether the file already exists and delete it if yes
 788       QFile aFile( aFilename );
 789       if ( aFile.exists() && toOverwrite )
 790         aFile.remove();
 791       SUIT_OverrideCursor wc;
 792
 793       try {
 794         // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
 795 //         bool Renumber = false;
 796 //         // PAL 14172  : Check of we have to renumber or not from the preferences before export
 797 //         if (resMgr)
 798 //           Renumber= resMgr->booleanValue("renumbering");
 799 //         if (Renumber){
 800 //           SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
 801 //           aMeshEditor->RenumberNodes();
 802 //           aMeshEditor->RenumberElements();
 803 //           if ( SMESHGUI::automaticUpdate() )
 804 //             SMESH::UpdateView();
 805 //         }
 806         if ( isMED )
 807         {
 808           aMeshIter = aMeshList.begin();
 809           for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
 810           {
 811             SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
 812             SMESH::SMESH_Mesh_var        aMeshItem = aMeshOrGroup->GetMesh();
 813             if ( aMeshOrGroup->_is_equivalent( aMeshItem ))
 814               aMeshItem->ExportToMEDX( aFilename.toLatin1().data(), toCreateGroups,
 815                                        aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
 816             else
 817               aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups,
 818                                           aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
 819           }
 820         }
 821         else if ( isSAUV )
 822         {
 823           for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
 824           {
 825             SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
 826             if( !aMeshItem->_is_nil() )
 827               aMeshItem->ExportSAUV( aFilename.toLatin1().data(), toCreateGroups );
 828           }
 829         }
 830         else if ( isDAT )
 831         {
 832           if ( aMeshOrGroup->_is_equivalent( aMesh ))
 833             aMesh->ExportDAT( aFilename.toLatin1().data() );
 834           else
 835             aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toLatin1().data() );
 836         }
 837         else if ( isUNV )
 838         {
 839           if ( aMeshOrGroup->_is_equivalent( aMesh ))
 840             aMesh->ExportUNV( aFilename.toLatin1().data() );
 841           else
 842             aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toLatin1().data() );
 843         }
 844         else if ( isSTL )
 845         {
 846           if ( aMeshOrGroup->_is_equivalent( aMesh ))
 847             aMesh->ExportSTL( aFilename.toLatin1().data(), aIsASCII_STL );
 848           else
 849             aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toLatin1().data(), aIsASCII_STL );
 850         }
 851         else if ( isCGNS )
 852         {
 853           aMeshIter = aMeshList.begin();
 854           for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
 855           {
 856             SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
 857             SMESH::SMESH_Mesh_var        aMeshItem = aMeshOrGroup->GetMesh();
 858             aMeshItem->ExportCGNS( aMeshOrGroup,
 859                                    aFilename.toLatin1().data(),
 860                                    toOverwrite && aMeshIndex == 0 );
 861           }
 862         }
 863         else if ( isGMF )
 864         {
 865           toCreateGroups = true;
 866           aMesh->ExportGMF( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups );
 867         }
 868       }
 869       catch (const SALOME::SALOME_Exception& S_ex){
 870         wc.suspend();
 871         SUIT_MessageBox::warning(SMESHGUI::desktop(),
 872                                  QObject::tr("SMESH_WRN_WARNING"),
 873                                  QObject::tr("SMESH_EXPORT_FAILED"));
 874         wc.resume();
 875       }
 876     }
 877   }
 878
 879   inline void InverseEntityMode(unsigned int& theOutputMode,
 880                                 unsigned int theMode)
 881   {
 882     bool anIsNotPresent = ~theOutputMode & theMode;
 883     if(anIsNotPresent)
 884       theOutputMode |= theMode;
 885     else
 886       theOutputMode &= ~theMode;
 887   }
 888
 889   void SetDisplayEntity(int theCommandID){
 890     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
 891     SALOME_ListIO selected;
 892     if( aSel )
 893       aSel->selectedObjects( selected );
 894
 895     if(selected.Extent() >= 1){
 896       SALOME_ListIteratorOfListIO It( selected );
 897       for( ; It.More(); It.Next()){
 898         Handle(SALOME_InteractiveObject) IObject = It.Value();
 899         if(IObject->hasEntry()){
 900           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
 901             unsigned int aMode = anActor->GetEntityMode();
 902             switch(theCommandID){
 903             case 222:
 904               InverseEntityMode(aMode,SMESH_Actor::eBallElem);
 905               break;
 906             case 216:
 907               InverseEntityMode(aMode,SMESH_Actor::e0DElements);
 908               break;
 909             case 217:
 910               InverseEntityMode(aMode,SMESH_Actor::eEdges);
 911               break;
 912             case 218:
 913               InverseEntityMode(aMode,SMESH_Actor::eFaces);
 914               break;
 915             case 219:
 916               InverseEntityMode(aMode,SMESH_Actor::eVolumes);
 917               break;
 918             case 220:
 919               aMode = SMESH_Actor::eAllEntity;
 920               break;
 921             }
 922             if(aMode)
 923               anActor->SetEntityMode(aMode);
 924           }
 925         }
 926       }
 927     }
 928   }
 929
 930   void AutoColor(){
 931     SALOME_ListIO selected;
 932     SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
 933     if( !app )
 934       return;
 935
 936     LightApp_SelectionMgr* aSel = app->selectionMgr();
 937     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
 938     if( !aSel || !appStudy )
 939       return;
 940
 941     aSel->selectedObjects( selected );
 942     if( selected.IsEmpty() )
 943       return;
 944
 945     Handle(SALOME_InteractiveObject) anIObject = selected.First();
 946
 947     _PTR(Study) aStudy = appStudy->studyDS();
 948     _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
 949     SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
 950     if( aMainObject->_is_nil() )
 951       return;
 952
 953     aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
 954
 955     QList<SALOMEDS::Color> aReservedColors;
 956
 957     SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
 958     for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
 959     {
 960       SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
 961       //SALOMEDS::Color aColor = aGroupObject->GetColor();
 962
 963 #ifdef SIMPLE_AUTOCOLOR   // simplified algorithm for auto-colors
 964       SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
 965 #else                     // old algorithm  for auto-colors
 966       SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
 967       aReservedColors.append( aColor );
 968 #endif                    // SIMPLE_AUTOCOLOR
 969
 970       _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
 971       if (aGroupSObject) {
 972         QColor c;
 973         int delta;
 974         if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
 975           switch ( aGroupObject->GetType ()) {
 976           case SMESH::NODE:
 977             anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
 978           case SMESH::EDGE:
 979             anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
 980           case SMESH::ELEM0D:
 981             anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
 982           case SMESH::BALL:
 983             anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
 984           case SMESH::VOLUME:
 985             SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
 986             anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
 987           case SMESH::FACE:
 988           default:
 989             SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
 990             anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
 991           }
 992         }
 993       }
 994     }
 995
 996     SMESH::RepaintCurrentView();
 997   }
 998
 999   void OverallMeshQuality() {
1000     SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1001     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1002     SALOME_ListIO selected;
1003     if( aSel )
1004       aSel->selectedObjects( selected );
1005
1006     if ( selected.IsEmpty() ) return;
1007     SALOME_ListIteratorOfListIO It( selected );
1008     for ( ; It.More(); It.Next() ) {
1009       SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1010       ctrlDlg->showInfo( It.Value() );
1011       ctrlDlg->show();
1012     }
1013   }
1014
1015   QString functorToString( SMESH::Controls::FunctorPtr f )
1016   {
1017     QString type = QObject::tr( "UNKNOWN_CONTROL" );
1018     if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1019       type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1020     else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1021       type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1022     else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1023       type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1024     else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1025       type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1026     else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1027       type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1028     else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1029       type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1030     else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1031       type = QObject::tr( "WARP_ELEMENTS" );
1032     else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1033       type = QObject::tr( "TAPER_ELEMENTS" );
1034     else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1035       type = QObject::tr( "SKEW_ELEMENTS" );
1036     else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1037       type = QObject::tr( "AREA_ELEMENTS" );
1038     else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1039       type = QObject::tr( "LENGTH_EDGES" );
1040     else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1041       type = QObject::tr( "LENGTH2D_EDGES" );
1042     else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1043       type = QObject::tr( "MULTI_BORDERS" );
1044     else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1045       type = QObject::tr( "MULTI2D_BORDERS" );
1046     else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1047       type = QObject::tr( "FREE_NODES" );
1048     else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1049       type = QObject::tr( "FREE_EDGES" );
1050     else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1051       type = QObject::tr( "FREE_BORDERS" );
1052     else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1053       type = QObject::tr( "FREE_FACES" );
1054     else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1055       type = QObject::tr( "BARE_BORDER_VOLUME" );
1056     else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1057       type = QObject::tr( "BARE_BORDER_FACE" );
1058     else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1059       type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1060     else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1061       type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1062     else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1063       type = QObject::tr( "EQUAL_NODE" );
1064     else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1065       type = QObject::tr( "EQUAL_EDGE" );
1066     else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1067       type = QObject::tr( "EQUAL_FACE" );
1068     else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1069       type = QObject::tr( "EQUAL_VOLUME" );
1070     return type;
1071   }
1072
1073   void SaveDistribution()
1074   {
1075     LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1076     SALOME_ListIO selected;
1077     if ( aSel )
1078       aSel->selectedObjects( selected );
1079
1080     if ( selected.Extent() == 1 ) {
1081       Handle(SALOME_InteractiveObject) anIO = selected.First();
1082       if ( anIO->hasEntry() ) {
1083         SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1084         if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1085           SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1086           SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1087           if ( aScalarBarActor && aFunctor ) {
1088             SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1089             if ( aNumFun ) {
1090               std::vector<int> elements;
1091               SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1092               if ( mesh->_is_nil() ) {
1093                 SMESH::SMESH_IDSource_var idSource =
1094                   SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1095                 if ( !idSource->_is_nil() )
1096                 {
1097                   SMESH::long_array_var ids = idSource->GetIDs();
1098                   elements.resize( ids->length() );
1099                   for ( unsigned i = 0; i < elements.size(); ++i )
1100                     elements[i] = ids[i];
1101                 }
1102               }
1103               int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1104               vtkLookupTable* lookupTable =
1105                 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1106               double * minmax = lookupTable->GetRange();
1107               bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1108               std::vector<int>    nbEvents;
1109               std::vector<double> funValues;
1110               aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
1111               QString anInitialPath = "";
1112               if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1113                 anInitialPath = QDir::currentPath();
1114               QString aMeshName = anIO->getName();
1115               QStringList filter;
1116               filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1117               filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1118               QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1119                 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1120               aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1121                                                      aFilename,
1122                                                      filter,
1123                                                      QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1124                                                      false );
1125               if ( !aFilename.isEmpty() ) {
1126                 QFile f( aFilename );
1127                 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1128                   QTextStream out( &f );
1129                   out << "# Mesh: " << aMeshName << endl;
1130                   out << "# Control: " << functorToString( aFunctor ) << endl;
1131                   out << "#" << endl;
1132                   out.setFieldWidth( 10 );
1133                   for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1134                     out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1135                   f.close();
1136                 }
1137               }
1138             }
1139           }
1140         }
1141       }
1142     }
1143   }
1144
1145   void ShowDistribution() {
1146     LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1147     SALOME_ListIO selected;
1148     if ( aSel )
1149       aSel->selectedObjects( selected );
1150
1151     if ( selected.Extent() == 1 ) {
1152       Handle(SALOME_InteractiveObject) anIO = selected.First();
1153       if ( anIO->hasEntry() ) {
1154         SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1155         if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1156           SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1157           aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1158         }
1159       }
1160     }
1161   }
1162
1163 #ifndef DISABLE_PLOT2DVIEWER
1164  void PlotDistribution() {
1165    SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1166    if( !app )
1167      return;
1168
1169    LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1170    SALOME_ListIO selected;
1171    if ( aSel )
1172      aSel->selectedObjects( selected );
1173
1174    if ( selected.Extent() == 1 ) {
1175      Handle(SALOME_InteractiveObject) anIO = selected.First();
1176      if ( anIO->hasEntry() ) {
1177        //Find Actor by entry before getting Plot2d viewer,
1178        //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1179        SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1180
1181        SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1182
1183        if( !aViewManager )
1184          return;
1185
1186        SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1187        if ( !aView )
1188          return;
1189
1190        Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1191        if ( !aPlot )
1192          return;
1193
1194        if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1195          SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1196          QString functorName = functorToString( anActor->GetFunctor());
1197          QString aHistogramName("%1 : %2");
1198          aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1199          aHistogram->setName(aHistogramName);
1200          aHistogram->setHorTitle(functorName);
1201          aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1202          aPlot->displayObject(aHistogram, true);
1203        }
1204      }
1205    }
1206  }
1207 #endif //DISABLE_PLOT2DVIEWER
1208
1209   void DisableAutoColor(){
1210     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1211     SALOME_ListIO selected;
1212     if( aSel )
1213       aSel->selectedObjects( selected );
1214
1215     if(selected.Extent()){
1216       Handle(SALOME_InteractiveObject) anIObject = selected.First();
1217       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1218       if ( !aMesh->_is_nil() ) {
1219         aMesh->SetAutoColor( false );
1220       }
1221     }
1222   }
1223
1224   void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1225   {
1226     SALOME_ListIO selected;
1227     SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1228     if( !app )
1229       return;
1230
1231     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1232     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1233     if( !aSel || !appStudy )
1234       return;
1235
1236     if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection
1237       if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1238         aModule->EmitSignalDeactivateDialog();
1239         if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1240           (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1241       }
1242       return;
1243     }
1244
1245     _PTR(Study) aStudy = appStudy->studyDS();
1246
1247     aSel->selectedObjects( selected );
1248
1249     if(selected.Extent() >= 1){
1250       switch(theCommandID){
1251       case 1133:{
1252         SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1253         (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1254         return;
1255       }
1256       case 1132: {
1257         double color[3];
1258         QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1259         QColor orientationColor, outlineColor, volumeColor;
1260         int deltaF = 0, deltaV = 0;
1261         int elem0dSize   = 1;
1262         int ballSize     = 1;
1263         int edgeWidth    = 1;
1264         int outlineWidth = 1;
1265         double shrinkCoef = 0.0;
1266         double orientationScale = 0.0;
1267         bool orientation3d = false;
1268         VTK::MarkerType markerType = VTK::MT_NONE;
1269         VTK::MarkerScale markerScale = VTK::MS_NONE;
1270         int markerId = 0;
1271         bool hasNodes = false;
1272         int presentEntities = 0;
1273         bool firstTime  = true;
1274
1275         SALOME_ListIteratorOfListIO It( selected );
1276         for ( ; It.More(); It.Next() ) {
1277           Handle(SALOME_InteractiveObject) IObject = It.Value();
1278           if ( !IObject->hasEntry() ) continue;
1279           SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1280           if ( !anActor || !anActor->GetObject() ) continue;
1281
1282           if ( firstTime ) {
1283             // nodes: color, marker
1284             anActor->GetNodeColor( color[0], color[1], color[2] );
1285             nodeColor.setRgbF( color[0], color[1], color[2] );
1286             markerType  = anActor->GetMarkerType();
1287             markerScale = anActor->GetMarkerScale();
1288             markerId    = anActor->GetMarkerTexture();
1289             // edges: color, width
1290             anActor->GetEdgeColor( color[0], color[1], color[2] );
1291             edgeColor.setRgbF( color[0], color[1], color[2] );
1292             edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1293             // faces: front color, back color (delta)
1294             anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1295             faceColor.setRgbF( color[0], color[1], color[2] );
1296             // faces: front color, back color (delta)
1297             anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1298             volumeColor.setRgbF( color[0], color[1], color[2] );
1299             // 0d elements: color, size
1300             anActor->Get0DColor( color[0], color[1], color[2] );
1301             elem0dColor.setRgbF( color[0], color[1], color[2] );
1302             elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1303             // balls: color, size
1304             anActor->GetBallColor( color[0], color[1], color[2] );
1305             ballColor.setRgbF( color[0], color[1], color[2] );
1306             ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1307             // outlines: color
1308             anActor->GetOutlineColor( color[0], color[1], color[2] );
1309             outlineColor.setRgbF( color[0], color[1], color[2] );
1310             outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1311             // orientation vectors: color, scale, 3d flag
1312             anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1313             orientationColor.setRgbF( color[0], color[1], color[2] );
1314             orientationScale = anActor->GetFacesOrientationScale();
1315             orientation3d = anActor->GetFacesOrientation3DVectors();
1316             // shrink factor
1317             shrinkCoef = anActor->GetShrinkFactor();
1318           }
1319
1320           firstTime = false; // we only take properties from first object (for performance reasons)
1321
1322           if ( !hasNodes )
1323             hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1324           if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1325             presentEntities = presentEntities | SMESH_Actor::eEdges;
1326           if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1327             presentEntities = presentEntities | SMESH_Actor::eFaces;
1328           if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1329             presentEntities = presentEntities | SMESH_Actor::eVolumes;
1330           if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1331             presentEntities = presentEntities | SMESH_Actor::e0DElements;
1332           if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1333             presentEntities = presentEntities | SMESH_Actor::eBallElem;
1334
1335           // as we know that all types of elements are present, we can exit the loop
1336           if ( presentEntities == SMESH_Actor::eAllEntity )
1337             break;
1338         }
1339
1340         SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1341         // nodes: color, marker
1342         dlg.setNodeColor( nodeColor );
1343         if( markerType != VTK::MT_USER )
1344           dlg.setNodeMarker( markerType, markerScale );
1345         else
1346           dlg.setNodeCustomMarker( markerId );
1347         // edges: color, line width
1348         dlg.setEdgeColor( edgeColor );
1349         dlg.setEdgeWidth( edgeWidth );
1350         // faces: front color, back color
1351         dlg.setFaceColor( faceColor, deltaF );
1352         // volumes: normal color, reversed color
1353         dlg.setVolumeColor( volumeColor, deltaV );
1354         // outlines: color, line width
1355         dlg.setOutlineColor( outlineColor );
1356         dlg.setOutlineWidth( outlineWidth );
1357         // 0d elements: color, size
1358         dlg.setElem0dColor( elem0dColor );
1359         dlg.setElem0dSize( elem0dSize );
1360         // balls: color, size
1361         dlg.setBallColor( ballColor );
1362         dlg.setBallSize( ballSize );
1363         // orientation: color, scale, 3d flag
1364         dlg.setOrientationColor( orientationColor );
1365         dlg.setOrientationSize( int( orientationScale * 100. ) );
1366         dlg.setOrientation3d( orientation3d );
1367         // shrink: scale factor
1368         dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1369         // hide unused controls
1370         dlg.showControls( presentEntities, hasNodes );
1371
1372         if ( dlg.exec() ) {
1373           nodeColor        = dlg.nodeColor();
1374           markerType       = dlg.nodeMarkerType();
1375           markerScale      = dlg.nodeMarkerScale();
1376           markerId         = dlg.nodeMarkerId();
1377           edgeColor        = dlg.edgeColor();
1378           edgeWidth        = dlg.edgeWidth();
1379           faceColor        = dlg.faceColor();
1380           deltaF           = dlg.faceColorDelta();
1381           volumeColor      = dlg.volumeColor();
1382           deltaV           = dlg.volumeColorDelta();
1383           outlineColor     = dlg.outlineColor();
1384           outlineWidth     = dlg.outlineWidth();
1385           elem0dColor      = dlg.elem0dColor();
1386           elem0dSize       = dlg.elem0dSize();
1387           ballColor        = dlg.ballColor();
1388           ballSize         = dlg.ballSize();
1389           orientationColor = dlg.orientationColor();
1390           orientationScale = dlg.orientationSize() / 100.;
1391           orientation3d    = dlg.orientation3d();
1392           shrinkCoef       = dlg.shrinkCoef() / 100.;
1393
1394           // store point markers map that might be changed by the user
1395           theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1396
1397           // set properties from dialog box to the presentations
1398           SALOME_ListIteratorOfListIO It( selected );
1399           for ( ; It.More(); It.Next() ) {
1400             Handle(SALOME_InteractiveObject) IObject = It.Value();
1401             if ( !IObject->hasEntry() ) continue;
1402             SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1403             if ( !anActor ) continue;
1404
1405             // nodes: color, marker
1406             anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1407             if ( markerType != VTK::MT_USER ) {
1408               anActor->SetMarkerStd( markerType, markerScale );
1409             }
1410             else {
1411               const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1412               VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1413               if ( iter != markerMap.end() )
1414                 anActor->SetMarkerTexture( markerId, iter->second.second );
1415             }
1416             // volumes: normal color, reversed color (delta)
1417             anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1418             // faces: front color, back color (delta)
1419             anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1420             // edges: color, width
1421             anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1422             anActor->SetLineWidth( edgeWidth );
1423             // outlines: color
1424             anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1425             anActor->SetOutlineWidth( outlineWidth );
1426             // 0D elements: color, size
1427             anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1428             anActor->Set0DSize( elem0dSize );
1429             // balls: color, size
1430             anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1431             anActor->SetBallSize( ballSize );
1432             // orientation: color, scale, 3d flag
1433             anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1434             anActor->SetFacesOrientationScale( orientationScale );
1435             anActor->SetFacesOrientation3DVectors( orientation3d );
1436             // shrink factor
1437             anActor->SetShrinkFactor( shrinkCoef );
1438
1439             // for groups, set also proper color
1440             SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1441             if ( !aGroupObject->_is_nil() ) {
1442               SMESH::ElementType anElementType = aGroupObject->GetType();
1443               QColor aColor;
1444               switch( anElementType ) {
1445               case SMESH::NODE:
1446                 aColor = nodeColor; break;
1447               case SMESH::EDGE:
1448                 aColor = edgeColor; break;
1449               case SMESH::FACE:
1450                 aColor = faceColor; break;
1451               case SMESH::VOLUME:
1452                 aColor = volumeColor; break;
1453               case SMESH::ELEM0D:
1454                 aColor = elem0dColor; break;
1455               case SMESH::BALL:
1456                 aColor = ballColor; break;
1457               default: break;
1458               }
1459
1460               if ( aColor.isValid() ) {
1461                 SALOMEDS::Color aGroupColor;
1462                 aGroupColor.R = aColor.redF();
1463                 aGroupColor.G = aColor.greenF();
1464                 aGroupColor.B = aColor.blueF();
1465                 aGroupObject->SetColor( aGroupColor );
1466               }
1467             } // if ( !aGroupObject->_is_nil() )
1468           } // for ( ; It.More(); It.Next() )
1469           SMESH::RepaintCurrentView();
1470         } // if ( dlg.exec() )
1471         return;
1472       } // case 1132:
1473       } // switch(theCommandID)
1474       SALOME_ListIteratorOfListIO It( selected );
1475       for( ; It.More(); It.Next()){
1476         Handle(SALOME_InteractiveObject) IObject = It.Value();
1477         if(IObject->hasEntry()){
1478           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1479             switch(theCommandID){
1480             case 211:
1481               anActor->SetRepresentation(SMESH_Actor::eEdge);
1482               break;
1483             case 212:
1484               anActor->SetRepresentation(SMESH_Actor::eSurface);
1485               break;
1486             case 213:
1487               if(anActor->IsShrunk())
1488                 anActor->UnShrink();
1489               else
1490                 anActor->SetShrink();
1491               break;
1492             case 215:
1493               anActor->SetRepresentation(SMESH_Actor::ePoint);
1494               break;
1495             case 231:
1496               if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1497                 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1498               break;
1499             case 232:
1500               if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1501                 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1502               break;
1503             }
1504           }
1505         }
1506       }
1507       SMESH::RepaintCurrentView();
1508     }
1509   }
1510
1511   void Control( int theCommandID )
1512   {
1513     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1514     SALOME_ListIO selected;
1515     if( aSel )
1516       aSel->selectedObjects( selected );
1517
1518     if( !selected.IsEmpty() ){
1519       Handle(SALOME_InteractiveObject) anIO = selected.First();
1520       if(!anIO.IsNull()){
1521         SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1522         if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1523           switch ( theCommandID ){
1524           case 6001:
1525             aControl = SMESH_Actor::eLength;
1526             break;
1527           case 6018:
1528             aControl = SMESH_Actor::eLength2D;
1529             break;
1530           case 6002:
1531             aControl = SMESH_Actor::eFreeEdges;
1532             break;
1533           case 6003:
1534             aControl = SMESH_Actor::eFreeBorders;
1535             break;
1536           case 6004:
1537             aControl = SMESH_Actor::eMultiConnection;
1538             break;
1539           case 6005:
1540             aControl = SMESH_Actor::eFreeNodes;
1541             break;
1542           case 6019:
1543             aControl = SMESH_Actor::eMultiConnection2D;
1544             break;
1545           case 6011:
1546             aControl = SMESH_Actor::eArea;
1547             break;
1548           case 6012:
1549             aControl = SMESH_Actor::eTaper;
1550             break;
1551           case 6013:
1552             aControl = SMESH_Actor::eAspectRatio;
1553             break;
1554           case 6017:
1555             aControl = SMESH_Actor::eAspectRatio3D;
1556             break;
1557           case 6014:
1558             aControl = SMESH_Actor::eMinimumAngle;
1559             break;
1560           case 6015:
1561             aControl = SMESH_Actor::eWarping;
1562             break;
1563           case 6016:
1564             aControl = SMESH_Actor::eSkew;
1565             break;
1566           case 6009:
1567             aControl = SMESH_Actor::eVolume3D;
1568             break;
1569           case 6021:
1570             aControl = SMESH_Actor::eFreeFaces;
1571             break;
1572           case 6022:
1573             aControl = SMESH_Actor::eMaxElementLength2D;
1574             break;
1575           case 6023:
1576             aControl = SMESH_Actor::eMaxElementLength3D;
1577             break;
1578           case 6024:
1579             aControl = SMESH_Actor::eBareBorderVolume;
1580             break;
1581           case 6025:
1582             aControl = SMESH_Actor::eBareBorderFace;
1583             break;
1584           case 6026:
1585             aControl = SMESH_Actor::eOverConstrainedVolume;
1586             break;
1587           case 6027:
1588             aControl = SMESH_Actor::eOverConstrainedFace;
1589             break;
1590           case 6028:
1591             aControl = SMESH_Actor::eCoincidentNodes;
1592             break;
1593           case 6029:
1594             aControl = SMESH_Actor::eCoincidentElems1D;
1595             break;
1596           case 6030:
1597             aControl = SMESH_Actor:: eCoincidentElems2D;
1598             break;
1599           case 6031:
1600             aControl = SMESH_Actor::eCoincidentElems3D;
1601             break;
1602           }
1603
1604           anActor->SetControlMode(aControl);
1605           anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1606           SMESH::RepaintCurrentView();
1607 #ifndef DISABLE_PLOT2DVIEWER
1608           if(anActor->GetPlot2Histogram()) {
1609             SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1610             QString functorName = functorToString( anActor->GetFunctor());
1611             QString aHistogramName("%1 : %2");
1612             aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1613             aHistogram->setName(aHistogramName);
1614             aHistogram->setHorTitle(functorName);
1615             SMESH::ProcessIn2DViewers(anActor);
1616           }
1617 #endif
1618         }
1619       }
1620     }
1621   }
1622
1623
1624   bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1625                    SMESH::MeshObjectType                           theType,
1626                    const QString                            theInTypeName,
1627                    QString &                                theOutTypeName)
1628   {
1629     SMESH_TypeFilter aTypeFilter( theType );
1630     QString entry;
1631     if( !theIO.IsNull() )
1632     {
1633       entry = theIO->getEntry();
1634       LightApp_DataOwner owner( entry );
1635       if ( aTypeFilter.isOk( &owner )) {
1636         theOutTypeName = theInTypeName;
1637         return true;
1638       }
1639     }
1640     return false;
1641   }
1642
1643
1644   QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1645   {
1646     _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1647     _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1648     if (aSObj) {
1649       _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1650       CORBA::String_var anID = aSComp->GetID().c_str();
1651       if (!strcmp(anID.in(),theIO->getEntry()))
1652         return "Component";
1653     }
1654
1655     QString aTypeName;
1656     if (
1657         CheckOIType ( theIO, SMESH::HYPOTHESIS,    "Hypothesis", aTypeName ) ||
1658         CheckOIType ( theIO, SMESH::ALGORITHM,     "Algorithm",  aTypeName ) ||
1659         CheckOIType ( theIO, SMESH::MESH,          "Mesh",       aTypeName ) ||
1660         CheckOIType ( theIO, SMESH::SUBMESH,       "SubMesh",    aTypeName ) ||
1661         CheckOIType ( theIO, SMESH::GROUP,         "Group",      aTypeName )
1662         )
1663       return aTypeName;
1664
1665     return "NoType";
1666   }
1667
1668
1669   QString CheckHomogeneousSelection()
1670   {
1671     //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1672     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1673     SALOME_ListIO selected;
1674     if( aSel )
1675       aSel->selectedObjects( selected );
1676
1677     QString RefType = CheckTypeObject(selected.First());
1678     SALOME_ListIteratorOfListIO It(selected);
1679     for ( ; It.More(); It.Next())
1680       {
1681         Handle(SALOME_InteractiveObject) IObject = It.Value();
1682         QString Type = CheckTypeObject(IObject);
1683         if (Type.compare(RefType) != 0)
1684           return "Heterogeneous Selection";
1685       }
1686
1687     return RefType;
1688   }
1689
1690
1691   void SMESHGUI::OnEditDelete()
1692   {
1693     // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1694     LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1695     SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1696
1697     _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1698     _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1699     _PTR(GenericAttribute) anAttr;
1700     _PTR(AttributeIOR) anIOR;
1701
1702     int objectCount = 0;
1703     QString aNameList;
1704     QString aParentComponent = QString::null;
1705     Handle(SALOME_InteractiveObject) anIO;
1706     for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1707     {
1708       anIO = anIt.Value();
1709       QString cur = anIO->getComponentDataType();
1710       _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1711       if (aSO) {
1712         // check if object is reference
1713         _PTR(SObject) aRefSObj;
1714         aNameList.append("\n    - ");
1715         if ( aSO->ReferencedObject( aRefSObj ) ) {
1716           QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1717           aNameList.append( aRefName );
1718           cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1719         }
1720         else
1721           aNameList.append(anIO->getName());
1722         objectCount++;
1723       }
1724
1725       if( aParentComponent.isNull() )
1726         aParentComponent = cur;
1727       else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1728         aParentComponent = "";
1729     }
1730
1731     if ( objectCount == 0 )
1732       return; // No Valid Objects Selected
1733
1734     if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() )  {
1735       SUIT_MessageBox::warning( SMESHGUI::desktop(),
1736                                 QObject::tr("ERR_ERROR"),
1737                                 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1738       return;
1739     }
1740     // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1741     if (SUIT_MessageBox::warning
1742         (SMESHGUI::desktop(),
1743          QObject::tr("SMESH_WRN_WARNING"),
1744          QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1745          SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1746          SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1747       return;
1748
1749     SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1750
1751     // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1752     // then treat them all starting from the deepest objects (at list back)
1753     std::list< _PTR(SObject) > listSO;
1754     SALOME_ListIteratorOfListIO It(selected);
1755     for( ; It.More(); It.Next()) // loop on selected IO's
1756     {
1757       Handle(SALOME_InteractiveObject) IObject = It.Value();
1758       if(IObject->hasEntry()) {
1759         _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1760
1761         // disable removal of "SMESH" component object
1762         if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1763           anIOR = anAttr;
1764           if ( engineIOR() == anIOR->Value().c_str() )
1765             continue;
1766         }
1767         //Check the referenced object
1768         _PTR(SObject) aRefSObject;
1769         if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1770           aSO = aRefSObject; // Delete main Object instead of reference
1771
1772         listSO.push_back( aSO );
1773         std::list< _PTR(SObject) >::iterator itSO = listSO.begin();
1774         for ( ; itSO != listSO.end(); ++itSO ) {
1775           _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1776           for (it->InitEx(false); it->More(); it->Next())
1777             listSO.push_back( it->Value() );
1778         }
1779       }
1780     }
1781     // Check if none of objects to delete is referred from outside
1782     std::list< _PTR(SObject) >::reverse_iterator ritSO;
1783     for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1784     {
1785       _PTR(SObject) SO = *ritSO;
1786       if ( !SO ) continue;
1787       std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO  );
1788       for (size_t i = 0; i < aReferences.size(); i++) {
1789         _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1790         std::string type = aComponent->ComponentDataType();
1791         if ( type != "SMESH" )
1792         {
1793           SUIT_MessageBox::warning( anApp->desktop(),
1794                                     QObject::tr("WRN_WARNING"),
1795                                     QObject::tr("DEP_OBJECT") );
1796           return; // outside SMESH, there is an object depending on a SMESH object
1797         }
1798       }
1799     }
1800
1801     // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1802     for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1803     {
1804       Handle(SALOME_InteractiveObject) IObject = It.Value();
1805       SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1806       if ( !mesh->_is_nil() )
1807         mesh->Clear();
1808     }
1809
1810     // Treat SO's in the list starting from the back
1811     aStudyBuilder->NewCommand();  // There is a transaction
1812     for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1813     {
1814       _PTR(SObject) SO = *ritSO;
1815       if ( !SO ) continue;
1816       std::string anEntry = SO->GetID();
1817
1818       /** Erase graphical object **/
1819       if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1820         SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1821         // ViewManagerList aViewMenegers = anApp->viewManagers();
1822         // ViewManagerList::const_iterator it = aViewMenegers.begin();
1823         // for( ; it != aViewMenegers.end(); it++) {
1824         //   SUIT_ViewManager* vm = *it;
1825         //   int nbSf = vm ? vm->getViewsCount() : 0;
1826         //   if(vm) {
1827         //     QVector<SUIT_ViewWindow*> aViews = vm->getViews();
1828         //     for(int i = 0; i < nbSf; i++){
1829         //       SUIT_ViewWindow *sf = aViews[i];
1830         //       if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
1831         //         SMESH::RemoveActor(sf,anActor);
1832         //       }
1833         //     }
1834         //   }
1835         // }
1836       }
1837       /** Remove an object from data structures **/
1838       SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1839       SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1840       if ( !aGroup->_is_nil() ) {                          // DELETE GROUP
1841         SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1842         aMesh->RemoveGroup( aGroup );
1843       }
1844       else if ( !aSubMesh->_is_nil() ) {                   // DELETE SUBMESH
1845         SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1846         aMesh->RemoveSubMesh( aSubMesh );
1847
1848         _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1849         if (aMeshSO)
1850           SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1851       }
1852       else {
1853         Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1854           ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1855         QString objType = CheckTypeObject(IObject);
1856         if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1857           SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1858           aStudyBuilder->RemoveObjectWithChildren( SO );
1859         }
1860         else {// default action: remove SObject from the study
1861               // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1862               //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1863               //op->start();
1864           aStudyBuilder->RemoveObjectWithChildren( SO );
1865           //op->finish();
1866         }
1867       }
1868     } /* listSO back loop */
1869
1870     aStudyBuilder->CommitCommand();
1871
1872     /* Clear any previous selection */
1873     SALOME_ListIO l1;
1874     aSel->setSelectedObjects( l1 );
1875
1876     SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1877   }
1878 //} namespace
1879
1880 extern "C" {
1881   SMESHGUI_EXPORT CAM_Module* createModule()
1882   {
1883     return new SMESHGUI();
1884   }
1885
1886   SMESHGUI_EXPORT  char* getModuleVersion() {
1887     return (char*)SMESH_VERSION_STR;
1888   }
1889 }
1890
1891 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1892
1893 //=============================================================================
1894 /*!
1895  *
1896  */
1897 //=============================================================================
1898 SMESHGUI::SMESHGUI() :
1899 SalomeApp_Module( "SMESH" )
1900 {
1901   if ( CORBA::is_nil( myComponentSMESH ) )
1902   {
1903     CORBA::Boolean anIsEmbeddedMode;
1904     myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1905     MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1906
1907     //  0019923: EDF 765 SMESH : default values of hypothesis
1908     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1909     int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1910     myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1911     nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1912     myComponentSMESH->SetDefaultNbSegments( nbSeg );
1913
1914     const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1915     for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1916       if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1917       {
1918         QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1919         myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1920       }
1921   }
1922
1923   myActiveDialogBox = 0;
1924   myFilterLibraryDlg = 0;
1925   myState = -1;
1926   myDisplayer = 0;
1927
1928   myEventCallbackCommand = vtkCallbackCommand::New();
1929   myEventCallbackCommand->Delete();
1930   myEventCallbackCommand->SetClientData( this );
1931   myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1932   myPriority = 0.0;
1933
1934   /* load resources for all available meshers */
1935   SMESH::InitAvailableHypotheses();
1936 }
1937
1938 //=============================================================================
1939 /*!
1940  *
1941  */
1942 //=============================================================================
1943 SMESHGUI::~SMESHGUI()
1944 {
1945 }
1946
1947 //=============================================================================
1948 /*!
1949  *
1950  */
1951 //=============================================================================
1952 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1953 {
1954   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1955   if( anApp )
1956     return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1957   else
1958     return 0;
1959 }
1960
1961 //=============================================================================
1962 /*!
1963  *
1964  */
1965 //=============================================================================
1966 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1967 {
1968   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1969   if ( !resMgr )
1970     return false;
1971
1972   bool autoUpdate  = resMgr->booleanValue( "SMESH", "auto_update",  false );
1973   long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1974   bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
1975   if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
1976   return autoUpdate && !exceeded;
1977 }
1978
1979 //=============================================================================
1980 /*!
1981  *
1982  */
1983 //=============================================================================
1984 bool SMESHGUI::automaticUpdate( SMESH::SMESH_Mesh_ptr theMesh,
1985                                 int* entities, bool* limitExceeded )
1986 {
1987   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1988   if ( !resMgr )
1989     return false;
1990
1991   bool autoUpdate  = resMgr->booleanValue( "SMESH", "auto_update", false );
1992   long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1993   bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
1994
1995   long requestedSize = theMesh->NbElements();
1996
1997   *entities = SMESH_Actor::eAllEntity;
1998
1999   bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2000
2001   if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2002
2003   if ( incrementalLimit ) {
2004     long nbOdElems = theMesh->Nb0DElements();
2005     long nbEdges   = theMesh->NbEdges();
2006     long nbFaces   = theMesh->NbFaces();
2007     long nbVolumes = theMesh->NbVolumes();
2008     long nbBalls   = theMesh->NbBalls();
2009     long total     = 0;
2010
2011     if ( nbOdElems > 0 ) {
2012       if ( total + nbOdElems > updateLimit )
2013         *entities = *entities & ~SMESH_Actor::e0DElements;
2014       else
2015         exceeded = false;
2016     }
2017     total += nbOdElems;
2018
2019     if ( nbEdges > 0 ) {
2020       if ( total + nbEdges > updateLimit )
2021         *entities = *entities & ~SMESH_Actor::eEdges;
2022       else
2023         exceeded = false;
2024     }
2025     total += nbEdges;
2026
2027     if ( nbFaces > 0 ) {
2028       if ( total + nbFaces > updateLimit )
2029         *entities = *entities & ~SMESH_Actor::eFaces;
2030       else
2031         exceeded = false;
2032     }
2033     total += nbFaces;
2034
2035     if ( nbVolumes > 0 ) {
2036       if ( total + nbVolumes > updateLimit )
2037         *entities = *entities & ~SMESH_Actor::eVolumes;
2038       else
2039         exceeded = false;
2040     }
2041     total += nbVolumes;
2042
2043     if ( nbBalls > 0 ) {
2044       if ( total + nbBalls > updateLimit )
2045         *entities = *entities & ~SMESH_Actor::eBallElem;
2046       else
2047         exceeded = false;
2048     }
2049     total += nbBalls;
2050   }
2051
2052   return autoUpdate && !exceeded;
2053 }
2054
2055 //=============================================================================
2056 /*!
2057  *
2058  */
2059 //=============================================================================
2060 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2061 {
2062   return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2063 }
2064
2065 //=============================================================================
2066 /*!
2067  *
2068  */
2069 //=============================================================================
2070 SMESHGUI* SMESHGUI::GetSMESHGUI()
2071 {
2072   SMESHGUI* smeshMod = 0;
2073   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2074   if ( app )
2075   {
2076     CAM_Module* module = app->module( "Mesh" );
2077     smeshMod = dynamic_cast<SMESHGUI*>( module );
2078   }
2079
2080   if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2081   {
2082     SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2083     if ( study )
2084     {
2085       _PTR(Study) aStudy = study->studyDS();
2086       if ( aStudy )
2087         GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2088     }
2089   }
2090
2091   return smeshMod;
2092 }
2093
2094 extern "C"
2095 {
2096   Standard_EXPORT SMESHGUI* GetComponentGUI()
2097   {
2098     return SMESHGUI::GetSMESHGUI();
2099   }
2100 }
2101
2102 //=============================================================================
2103 /*!
2104  *
2105  */
2106 //=============================================================================
2107 void SMESHGUI::SetState(int aState)
2108 {
2109   myState = aState;
2110 }
2111
2112 //=============================================================================
2113 /*!
2114  *
2115  */
2116 //=============================================================================
2117 void SMESHGUI::ResetState()
2118 {
2119   myState = -1;
2120 }
2121
2122 //=============================================================================
2123 /*!
2124  *
2125  */
2126 //=============================================================================
2127 void SMESHGUI::EmitSignalDeactivateDialog()
2128 {
2129   emit SignalDeactivateActiveDialog();
2130 }
2131
2132 //=============================================================================
2133 /*!
2134  *
2135  */
2136 //=============================================================================
2137 void SMESHGUI::EmitSignalStudyFrameChanged()
2138 {
2139   emit SignalStudyFrameChanged();
2140 }
2141
2142 //=============================================================================
2143 /*!
2144  *
2145  */
2146 //=============================================================================
2147 void SMESHGUI::EmitSignalCloseAllDialogs()
2148 {
2149   emit SignalCloseAllDialogs();
2150 }
2151
2152 //=============================================================================
2153 /*!
2154  *
2155  */
2156 //=============================================================================
2157 void SMESHGUI::EmitSignalVisibilityChanged()
2158 {
2159   emit SignalVisibilityChanged();
2160 }
2161
2162 //=============================================================================
2163 /*!
2164  *
2165  */
2166 //=============================================================================
2167 QDialog *SMESHGUI::GetActiveDialogBox()
2168 {
2169   return myActiveDialogBox;
2170 }
2171
2172 //=============================================================================
2173 /*!
2174  *
2175  */
2176 //=============================================================================
2177 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2178 {
2179   myActiveDialogBox = (QDialog *) aDlg;
2180   return;
2181 }
2182
2183 //=============================================================================
2184 /*!
2185  *
2186  */
2187 //=============================================================================
2188 SUIT_Desktop* SMESHGUI::desktop()
2189 {
2190   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2191   if( app )
2192     return app->desktop();
2193   else
2194     return 0;
2195 }
2196
2197 //=============================================================================
2198 /*!
2199  *
2200  */
2201 //=============================================================================
2202 SalomeApp_Study* SMESHGUI::activeStudy()
2203 {
2204   SUIT_Application* app = SUIT_Session::session()->activeApplication();
2205   if( app )
2206     return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2207   else
2208     return NULL;
2209 }
2210
2211 //=============================================================================
2212 /*!
2213  *
2214  */
2215 //=============================================================================
2216 void SMESHGUI::Modified( bool theIsUpdateActions )
2217 {
2218   if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2219     if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2220       appStudy->Modified();
2221       if( theIsUpdateActions )
2222         app->updateActions();
2223     }
2224   }
2225 }
2226
2227 //=============================================================================
2228 /*!
2229  *
2230  */
2231 //=============================================================================
2232 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2233 {
2234   /* Here the position is on the bottom right corner - 10 */
2235   // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2236   aDlg->adjustSize();
2237   SUIT_Desktop *PP = desktop();
2238   x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2239   y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2240   return true;
2241 }
2242
2243 //=============================================================================
2244 /*!
2245  *
2246  */
2247 //=============================================================================
2248 static int isStudyLocked(_PTR(Study) theStudy){
2249   return theStudy->GetProperties()->IsLocked();
2250 }
2251
2252 static bool checkLock(_PTR(Study) theStudy) {
2253   if (isStudyLocked(theStudy)) {
2254     SUIT_MessageBox::warning( SMESHGUI::desktop(),
2255                               QObject::tr("WRN_WARNING"),
2256                               QObject::tr("WRN_STUDY_LOCKED") );
2257     return true;
2258   }
2259   return false;
2260 }
2261
2262 //=======================================================================
2263 //function : CheckActiveStudyLocked
2264 //purpose  :
2265 //=======================================================================
2266
2267 bool SMESHGUI::isActiveStudyLocked()
2268 {
2269   _PTR(Study) aStudy = activeStudy()->studyDS();
2270   return checkLock( aStudy );
2271 }
2272
2273 //=============================================================================
2274 /*!
2275  *
2276  */
2277 //=============================================================================
2278 bool SMESHGUI::OnGUIEvent( int theCommandID )
2279 {
2280   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2281   if( !anApp )
2282     return false;
2283
2284   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2285   SUIT_ResourceMgr* mgr = resourceMgr();
2286   if( !mgr )
2287     return false;
2288
2289   if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2290     GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2291   }
2292
2293   SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2294   SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2295
2296   //QAction* act = action( theCommandID );
2297
2298   switch (theCommandID) {
2299   case 33:                                      // DELETE
2300     if(checkLock(aStudy)) break;
2301     OnEditDelete();
2302     break;
2303
2304   case 116:
2305   case 115:
2306   case 117:
2307   case 118:
2308   case 113:
2309   case 112:
2310   case 111:                                     // IMPORT
2311     {
2312       if(checkLock(aStudy)) break;
2313       ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2314       break;
2315     }
2316
2317   case 150:    //MED FILE INFORMATION
2318     {
2319       SALOME_ListIO selected;
2320       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2321       if( aSel )
2322         aSel->selectedObjects( selected );
2323       if( selected.Extent() )
2324       {
2325         Handle(SALOME_InteractiveObject) anIObject = selected.First();
2326         SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2327         if ( !aMesh->_is_nil() )
2328         {
2329           SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2330           dlg.exec();
2331         }
2332       }
2333       break;
2334     }
2335
2336   case 122:                                     // EXPORT MED
2337   case 121:
2338   case 123:
2339   case 124:
2340   case 125:
2341   case 126:
2342   case 140:
2343   case 141:
2344   case 142:
2345   case 143:
2346   case 144:
2347   case 145:
2348   case 146:
2349   case 147:
2350     {
2351       ::ExportMeshToFile(theCommandID);
2352       break;
2353     }
2354
2355   case 200:                                     // SCALAR BAR
2356     {
2357       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2358       SALOME_ListIO selected;
2359       if( aSel )
2360         aSel->selectedObjects( selected );
2361
2362       if( selected.Extent() ) {
2363         Handle(SALOME_InteractiveObject) anIO = selected.First();
2364         if( anIO->hasEntry() ) {
2365           if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2366             anActor->SetControlMode( SMESH_Actor::eNone );
2367 #ifndef DISABLE_PLOT2DVIEWER
2368             SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2369 #endif
2370           }
2371         }
2372       }
2373       break;
2374     }
2375   case 201:
2376     {
2377       SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2378       break;
2379     }
2380   case 2021:
2381     {
2382       // dump control distribution data to the text file
2383       ::SaveDistribution();
2384       break;
2385     }
2386
2387   case 2022:
2388     {
2389       // show/ distribution
2390       ::ShowDistribution();
2391       break;
2392     }
2393
2394 #ifndef DISABLE_PLOT2DVIEWER
2395   case 2023:
2396     {
2397       // plot distribution
2398       ::PlotDistribution();
2399       break;
2400     }
2401 #endif
2402
2403     // Auto-color
2404   case 1136:
2405     ::AutoColor();
2406   break;
2407
2408   case 1137:
2409     ::DisableAutoColor();
2410   break;
2411
2412   case 1134: // Clipping
2413   case 1133: // Tranparency
2414   case 1132: // Display preferences (colors, shrink size, line width, ...)
2415
2416     // Display Mode
2417   case 215: // Nodes
2418   case 213: // Nodes
2419   case 212: // Nodes
2420   case 211: // Nodes
2421     ::SetDisplayMode(theCommandID, myMarkerMap);
2422   break;
2423
2424   //2D quadratic representation
2425   case 231:
2426   case 232:
2427     ::SetDisplayMode(theCommandID, myMarkerMap);
2428   break;
2429
2430   // Display Entity
2431   case 216: // 0D elements
2432   case 217: // Edges
2433   case 218: // Faces
2434   case 219: // Volumes
2435   case 220: // All Entity
2436   case 222: // Balls
2437     ::SetDisplayEntity(theCommandID);
2438   break;
2439
2440   case 221: // Orientation of faces
2441     {
2442       LightApp_SelectionMgr* mgr = selectionMgr();
2443       SALOME_ListIO selected; mgr->selectedObjects( selected );
2444
2445       SALOME_ListIteratorOfListIO it(selected);
2446       for( ; it.More(); it.Next()) {
2447         Handle(SALOME_InteractiveObject) anIObject = it.Value();
2448         if(anIObject->hasEntry()) {
2449           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2450             anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2451           }
2452         }
2453       }
2454       break;
2455     }
2456
2457   case 214:                                     // UPDATE
2458     {
2459       if(checkLock(aStudy)) break;
2460       SUIT_OverrideCursor wc;
2461       try {
2462 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2463         OCC_CATCH_SIGNALS;
2464 #endif
2465         SMESH::UpdateView();
2466       }
2467       catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2468         SMESH::OnVisuException();
2469       }
2470       catch (...) { // PAL16774 (Crash after display of many groups)
2471         SMESH::OnVisuException();
2472       }
2473
2474       SALOME_ListIO l;
2475       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2476       aSel->selectedObjects( l );
2477       aSel->setSelectedObjects( l );
2478       break;
2479     }
2480
2481   case 300:                                     // ERASE
2482   case 301:                                     // DISPLAY
2483   case 302:                                     // DISPLAY ONLY
2484     {
2485       SMESH::EDisplaing anAction;
2486       switch (theCommandID) {
2487       case 300: anAction = SMESH::eErase; break;
2488       case 301: anAction = SMESH::eDisplay; break;
2489       case 302: anAction = SMESH::eDisplayOnly; break;
2490       }
2491
2492       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2493       SALOME_ListIO sel_objects, to_process;
2494       if (aSel)
2495         aSel->selectedObjects( sel_objects );
2496
2497       if( theCommandID==302 )
2498       {
2499         MESSAGE("anAction = SMESH::eDisplayOnly");
2500         startOperation( myEraseAll );
2501       }
2502
2503       extractContainers( sel_objects, to_process );
2504
2505       try {
2506 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2507         OCC_CATCH_SIGNALS;
2508 #endif
2509         if (vtkwnd) {
2510           SALOME_ListIteratorOfListIO It( to_process );
2511           for ( ; It.More(); It.Next()) {
2512                 MESSAGE("---");
2513             Handle(SALOME_InteractiveObject) IOS = It.Value();
2514             if (IOS->hasEntry()) {
2515                 MESSAGE("---");
2516               if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2517                 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2518                 break; // PAL16774 (Crash after display of many groups)
2519               }
2520               if (anAction == SMESH::eDisplayOnly)
2521               {
2522                 MESSAGE("anAction = SMESH::eDisplayOnly");
2523                 anAction = SMESH::eDisplay;
2524               }
2525             }
2526           }
2527         }
2528
2529         // PAL13338 + PAL15161 -->
2530         if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2531                 MESSAGE("anAction = SMESH::eDisplayOnly");
2532           SMESH::UpdateView();
2533           SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2534         }
2535         // PAL13338 + PAL15161 <--
2536       }
2537       catch (...) { // PAL16774 (Crash after display of many groups)
2538         SMESH::OnVisuException();
2539       }
2540
2541       if (anAction == SMESH::eErase) {
2542         MESSAGE("anAction == SMESH::eErase");
2543         SALOME_ListIO l1;
2544         aSel->setSelectedObjects( l1 );
2545       }
2546       else
2547         aSel->setSelectedObjects( to_process );
2548
2549       break;
2550     }
2551
2552   case 4000:                                    // NODES
2553     {
2554       if(checkLock(aStudy)) break;
2555
2556       if ( vtkwnd ) {
2557         EmitSignalDeactivateDialog();
2558
2559         ( new SMESHGUI_NodesDlg( this ) )->show();
2560       }
2561       else {
2562         SUIT_MessageBox::warning(desktop(),
2563                                  tr("SMESH_WRN_WARNING"),
2564                                  tr("SMESH_WRN_VIEWER_VTK"));
2565       }
2566       break;
2567     }
2568
2569   case 2151:  // FILTER
2570   {
2571     if ( vtkwnd )
2572     {
2573       EmitSignalDeactivateDialog();
2574       ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2575     }
2576     break;
2577   }
2578
2579   case 701: // COMPUTE MESH
2580   case 711: // PRECOMPUTE MESH
2581   case 712: // EVALUATE MESH
2582   case 713: // MESH ORDER
2583   case 702: // Create mesh
2584   case 703: // Create sub-mesh
2585   case 704: // Edit mesh/sub-mesh
2586     startOperation( theCommandID );
2587     break;
2588   case 705: // copy mesh
2589     {
2590       if (checkLock(aStudy)) break;
2591       EmitSignalDeactivateDialog();
2592       ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2593     }
2594     break;
2595   case 710: // Build compound mesh
2596     {
2597       if (checkLock(aStudy)) break;
2598       EmitSignalDeactivateDialog();
2599       ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2600     }
2601     break;
2602
2603   case 407: // DIAGONAL INVERSION
2604   case 408: // Delete diagonal
2605     {
2606       if ( !vtkwnd )
2607       {
2608         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2609                                   tr( "NOT_A_VTK_VIEWER" ) );
2610         break;
2611       }
2612
2613       if ( checkLock( aStudy ) )
2614         break;
2615
2616       /*Standard_Boolean aRes;
2617       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2618       if ( aMesh->_is_nil() )
2619       {
2620         SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2621           tr( "SMESH_BAD_SELECTION" ) );
2622         break;
2623       }
2624       */
2625       EmitSignalDeactivateDialog();
2626       if ( theCommandID == 407 )
2627         ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2628       else
2629         ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2630       break;
2631     }
2632   case 409: // Change orientation
2633   case 410: // Union of triangles
2634   case 411: // Cutting of quadrangles
2635   case 419: // Splitting volumes into tetrahedra
2636     {
2637       if ( !vtkwnd )
2638       {
2639         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2640                                   tr( "NOT_A_VTK_VIEWER" ) );
2641         break;
2642       }
2643
2644       if ( checkLock( aStudy ) )
2645         break;
2646
2647       EmitSignalDeactivateDialog();
2648       SMESHGUI_MultiEditDlg* aDlg = NULL;
2649       if ( theCommandID == 409 )
2650         aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2651       else if ( theCommandID == 410 )
2652         aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2653       else if ( theCommandID == 419 )
2654         aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2655       else
2656         aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2657
2658       aDlg->show();
2659       break;
2660     }
2661   case 412: // Smoothing
2662     {
2663       if(checkLock(aStudy)) break;
2664       if( vtkwnd ) {
2665         EmitSignalDeactivateDialog();
2666         ( new SMESHGUI_SmoothingDlg( this ) )->show();
2667       }
2668       else {
2669         SUIT_MessageBox::warning(desktop(),
2670                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2671       }
2672       break;
2673     }
2674   case 413: // Extrusion
2675     {
2676       if (checkLock(aStudy)) break;
2677       if (vtkwnd) {
2678         EmitSignalDeactivateDialog();
2679         ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2680       } else {
2681         SUIT_MessageBox::warning(desktop(),
2682                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2683       }
2684       break;
2685     }
2686   case 414: // Revolution
2687     {
2688       if(checkLock(aStudy)) break;
2689       if( vtkwnd ) {
2690         EmitSignalDeactivateDialog();
2691         ( new SMESHGUI_RevolutionDlg( this ) )->show();
2692       }
2693       else {
2694         SUIT_MessageBox::warning(desktop(),
2695                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2696       }
2697       break;
2698     }
2699   case 415: // Pattern mapping
2700     {
2701       if ( checkLock( aStudy ) )
2702         break;
2703       if ( vtkwnd )
2704       {
2705         EmitSignalDeactivateDialog();
2706         ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2707       }
2708       else {
2709         SUIT_MessageBox::warning(desktop(),
2710                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2711       }
2712       break;
2713     }
2714   case 416: // Extrusion along a path
2715     {
2716       if (checkLock(aStudy)) break;
2717       if (vtkwnd) {
2718         EmitSignalDeactivateDialog();
2719         ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2720       } else {
2721         SUIT_MessageBox::warning(desktop(),
2722                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2723       }
2724       break;
2725     }
2726   case 417: // Convert mesh to quadratic
2727   case 418: // create 2D mesh from 3D
2728   case 420: // Reorient faces
2729   case 806: // CREATE GEO GROUP
2730     {
2731       startOperation( theCommandID );
2732       break;
2733     }
2734   case 801:                                     // CREATE GROUP
2735     {
2736       if ( !vtkwnd )
2737       {
2738         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2739                                   tr( "NOT_A_VTK_VIEWER" ) );
2740         break;
2741       }
2742
2743       if(checkLock(aStudy)) break;
2744       EmitSignalDeactivateDialog();
2745       SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2746
2747       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2748       SALOME_ListIO selected;
2749       if( aSel )
2750         aSel->selectedObjects( selected );
2751
2752       int nbSel = selected.Extent();
2753       if (nbSel == 1) {
2754         // check if mesh is selected
2755         aMesh = SMESH::GetMeshByIO( selected.First() );
2756       }
2757       SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2758       aDlg->show();
2759       break;
2760     }
2761
2762   case 802:                                     // CONSTRUCT GROUP
2763     {
2764       if ( !vtkwnd )
2765       {
2766         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2767                                   tr( "NOT_A_VTK_VIEWER" ) );
2768         break;
2769       }
2770
2771       if(checkLock(aStudy)) break;
2772       EmitSignalDeactivateDialog();
2773
2774       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2775       SALOME_ListIO selected;
2776       if( aSel )
2777         aSel->selectedObjects( selected );
2778
2779       int nbSel = selected.Extent();
2780       if (nbSel == 1) {
2781         // check if submesh is selected
2782         Handle(SALOME_InteractiveObject) IObject = selected.First();
2783         if (IObject->hasEntry()) {
2784           _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2785           if( aSObj ) {
2786             SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2787             if (!aSubMesh->_is_nil()) {
2788               try {
2789                 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2790                 // get submesh elements list by types
2791                 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2792                 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2793                 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2794                 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2795                 // create group for each type o elements
2796                 QString aName = IObject->getName();
2797                 QStringList anEntryList;
2798                 if (aNodes->length() > 0) {
2799                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2800                   aGroup->Add(aNodes.inout());
2801                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2802                     anEntryList.append( aSObject->GetID().c_str() );
2803                 }
2804                 if (aEdges->length() > 0) {
2805                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2806                   aGroup->Add(aEdges.inout());
2807                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2808                     anEntryList.append( aSObject->GetID().c_str() );
2809                 }
2810                 if (aFaces->length() > 0) {
2811                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2812                   aGroup->Add(aFaces.inout());
2813                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2814                     anEntryList.append( aSObject->GetID().c_str() );
2815                 }
2816                 if (aVolumes->length() > 0) {
2817                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2818                   aGroup->Add(aVolumes.inout());
2819                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2820                     anEntryList.append( aSObject->GetID().c_str() );
2821                 }
2822                 updateObjBrowser();
2823                 anApp->browseObjects( anEntryList );
2824               }
2825               catch(const SALOME::SALOME_Exception & S_ex){
2826                 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2827               }
2828             }
2829           }
2830         }
2831       }
2832       else if(nbSel==0) {
2833         SUIT_MessageBox::warning(desktop(),
2834                                  tr("SMESH_WRN_WARNING"),
2835                                  tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2836       }
2837       break;
2838     }
2839
2840   case 803:                                     // EDIT GROUP
2841     {
2842       if ( !vtkwnd )
2843       {
2844         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2845                                   tr( "NOT_A_VTK_VIEWER" ) );
2846         break;
2847       }
2848
2849       if(checkLock(aStudy)) break;
2850       EmitSignalDeactivateDialog();
2851
2852       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2853       SALOME_ListIO selected;
2854       if( aSel )
2855         aSel->selectedObjects( selected );
2856
2857       SALOME_ListIteratorOfListIO It (selected);
2858       int nbSelectedGroups = 0;
2859       for ( ; It.More(); It.Next() )
2860       {
2861         SMESH::SMESH_GroupBase_var aGroup =
2862           SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2863         if (!aGroup->_is_nil()) {
2864           nbSelectedGroups++;
2865           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2866           aDlg->show();
2867         }
2868       }
2869       if (nbSelectedGroups == 0)
2870         {
2871           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2872           aDlg->show();
2873         }
2874       break;
2875     }
2876
2877   case 804:                                     // Add elements to group
2878     {
2879       if(checkLock(aStudy)) break;
2880       if (myState == 800) {
2881         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2882         if (aDlg) aDlg->onAdd();
2883       }
2884       break;
2885     }
2886
2887   case 805:                                     // Remove elements from group
2888     {
2889       if(checkLock(aStudy)) break;
2890       if (myState == 800) {
2891         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2892         if (aDlg) aDlg->onRemove();
2893       }
2894       break;
2895     }
2896
2897   case 815:                                     // Edit GEOM GROUP as standalone
2898     {
2899       if ( !vtkwnd )
2900       {
2901         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2902                                   tr( "NOT_A_VTK_VIEWER" ) );
2903         break;
2904       }
2905
2906       if(checkLock(aStudy)) break;
2907       EmitSignalDeactivateDialog();
2908
2909       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2910       SALOME_ListIO selected;
2911       if( aSel )
2912         aSel->selectedObjects( selected );
2913
2914       SALOME_ListIteratorOfListIO It (selected);
2915       for ( ; It.More(); It.Next() )
2916       {
2917         SMESH::SMESH_GroupOnGeom_var aGroup =
2918           SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2919         if (!aGroup->_is_nil()) {
2920           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2921           aDlg->show();
2922         }
2923         else
2924         {
2925           SMESH::SMESH_GroupOnFilter_var aGroup =
2926             SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2927           if (!aGroup->_is_nil()) {
2928             SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2929             aDlg->show();
2930           }
2931         }
2932       }
2933       break;
2934     }
2935
2936     case 810: // Union Groups
2937     case 811: // Intersect groups
2938     case 812: // Cut groups
2939     {
2940       if ( !vtkwnd )
2941       {
2942         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2943                                   tr( "NOT_A_VTK_VIEWER" ) );
2944         break;
2945       }
2946
2947       if ( checkLock( aStudy ) )
2948         break;
2949
2950       EmitSignalDeactivateDialog();
2951
2952       SMESHGUI_GroupOpDlg* aDlg = 0;
2953       if ( theCommandID == 810 )
2954         aDlg = new SMESHGUI_UnionGroupsDlg( this );
2955       else if ( theCommandID == 811 )
2956         aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2957       else
2958         aDlg = new SMESHGUI_CutGroupsDlg( this );
2959
2960       aDlg->show();
2961
2962       break;
2963     }
2964
2965     case 814: // Create groups of entities from existing groups of superior dimensions
2966     {
2967       if ( checkLock( aStudy ) )
2968         break;
2969
2970       EmitSignalDeactivateDialog();
2971       SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2972       aDlg->show();
2973
2974       break;
2975     }
2976
2977     case 813: // Delete groups with their contents
2978     {
2979       if ( !vtkwnd )
2980       {
2981         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2982                                   tr( "NOT_A_VTK_VIEWER" ) );
2983         break;
2984       }
2985
2986       if ( checkLock( aStudy ) )
2987         break;
2988
2989       EmitSignalDeactivateDialog();
2990
2991       ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2992       break;
2993     }
2994
2995   case 900:                                     // MESH INFOS
2996   case 903:                                     // WHAT IS
2997     {
2998       int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2999       EmitSignalDeactivateDialog();
3000       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3001       SALOME_ListIO selected;
3002       if( aSel )
3003         aSel->selectedObjects( selected );
3004
3005       if ( selected.Extent() > 1 ) { // a dlg for each IO
3006         SALOME_ListIteratorOfListIO It( selected );
3007         for ( ; It.More(); It.Next() ) {
3008           SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3009           dlg->showInfo( It.Value() );
3010           dlg->show();
3011         }
3012       }
3013       else {
3014         SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3015         dlg->show();
3016       }
3017       break;
3018     }
3019
3020   case 904:                                     // FIND ELEM
3021     {
3022       startOperation( theCommandID );
3023       break;
3024     }
3025
3026   case 1100:                                    // EDIT HYPOTHESIS
3027     {
3028       if(checkLock(aStudy)) break;
3029
3030       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3031       SALOME_ListIO selected;
3032       if( aSel )
3033         aSel->selectedObjects( selected );
3034
3035       int nbSel = selected.Extent();
3036
3037       if (nbSel == 1) {
3038         Handle(SALOME_InteractiveObject) anIObject = selected.First();
3039         SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3040
3041         /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
3042         /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects                   */
3043         /* Warning : however by internal mechanism all subMeshes icons are changed !                     */
3044         if ( !aHypothesis->_is_nil() )
3045         {
3046           // BUG 0020378
3047           //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
3048           SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
3049           if (aCreator) {
3050             aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3051           }
3052           else
3053           {
3054             // report error
3055           }
3056         }
3057       }
3058       break;
3059     }
3060   case 1102:                                    // REMOVE HYPOTHESIS / ALGORITHMS
3061     {
3062       if(checkLock(aStudy)) break;
3063       SUIT_OverrideCursor wc;
3064
3065       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3066       SALOME_ListIO selected;
3067       if( aSel )
3068         aSel->selectedObjects( selected, QString::null, false );
3069
3070       SALOME_ListIteratorOfListIO It(selected);
3071       for (int i = 0; It.More(); It.Next(), i++) {
3072         Handle(SALOME_InteractiveObject) IObject = It.Value();
3073         SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3074       }
3075       SALOME_ListIO l1;
3076       aSel->setSelectedObjects( l1 );
3077       updateObjBrowser();
3078       break;
3079     }
3080
3081   case 4008:                                    // BALL
3082   case 4009:                                    // ELEM0D
3083   case 4010:                                    // EDGE
3084   case 4021:                                    // TRIANGLE
3085   case 4022:                                    // QUAD
3086   case 4023:                                    // POLYGON
3087   case 4031:                                    // TETRA
3088   case 4032:                                    // HEXA
3089   case 4133:                                    // PENTA
3090   case 4134:                                    // PYRAMID
3091   case 4135:                                    // OCTA12
3092     {
3093       if(checkLock(aStudy)) break;
3094       if ( vtkwnd ) {
3095         EmitSignalDeactivateDialog();
3096         SMDSAbs_EntityType type = SMDSEntity_Edge;
3097         switch (theCommandID) {
3098         case 4008: type = SMDSEntity_Ball;            break;
3099         case 4009: type = SMDSEntity_0D;              break;
3100         case 4021: type = SMDSEntity_Triangle;        break;
3101         case 4022: type = SMDSEntity_Quadrangle;      break;
3102         case 4031: type = SMDSEntity_Tetra;           break;
3103         case 4023: type = SMDSEntity_Polygon;         break;
3104         case 4032: type = SMDSEntity_Hexa;            break;
3105         case 4133: type = SMDSEntity_Penta;           break;
3106         case 4134: type = SMDSEntity_Pyramid;         break;
3107         case 4135: type = SMDSEntity_Hexagonal_Prism; break;
3108         default:;
3109         }
3110         ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3111       }
3112       else {
3113         SUIT_MessageBox::warning(desktop(),
3114                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3115       }
3116       break;
3117     }
3118   case 4033:                                    // POLYHEDRON
3119     {
3120       if(checkLock(aStudy)) break;
3121       if ( vtkwnd ) {
3122         EmitSignalDeactivateDialog();
3123         ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3124       }
3125       else {
3126         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3127                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3128       }
3129       break;
3130     }
3131   case 4034:     // QUADRATIC EDGE
3132   case 4035:     // QUADRATIC TRIANGLE
3133   case 4036:     // QUADRATIC QUADRANGLE
3134   case 4136:     // BIQUADRATIC QUADRANGLE
3135   case 4137:     // BIQUADRATIC TRIANGLE
3136   case 4037:     // QUADRATIC TETRAHEDRON
3137   case 4038:     // QUADRATIC PYRAMID
3138   case 4039:     // QUADRATIC PENTAHEDRON
3139   case 4040:     // QUADRATIC HEXAHEDRON
3140   case 4140:     // TRIQUADRATIC HEXAHEDRON
3141     {
3142       if(checkLock(aStudy)) break;
3143       if ( vtkwnd ) {
3144         EmitSignalDeactivateDialog();
3145         SMDSAbs_EntityType type = SMDSEntity_Last;
3146
3147         switch (theCommandID) {
3148         case 4034: type = SMDSEntity_Quad_Edge; break;
3149         case 4035: type = SMDSEntity_Quad_Triangle; break;
3150         case 4036: type = SMDSEntity_Quad_Quadrangle; break;
3151         case 4136: type = SMDSEntity_BiQuad_Quadrangle; break;
3152         case 4137: type = SMDSEntity_BiQuad_Triangle; break;
3153         case 4037: type = SMDSEntity_Quad_Tetra; break;
3154         case 4038: type = SMDSEntity_Quad_Pyramid; break;
3155         case 4039: type = SMDSEntity_Quad_Penta; break;
3156         case 4040: type = SMDSEntity_Quad_Hexa; break;
3157         case 4140: type = SMDSEntity_TriQuad_Hexa; break;
3158         default: break;
3159         }
3160         if ( type != SMDSEntity_Last )
3161           ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3162       }
3163       else {
3164         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3165                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3166       }
3167       break;
3168     }
3169   case 4041:                                    // REMOVES NODES
3170     {
3171       if(checkLock(aStudy)) break;
3172       if ( vtkwnd ) {
3173         EmitSignalDeactivateDialog();
3174         ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3175       }
3176       else {
3177         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3178                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3179       }
3180       break;
3181     }
3182   case 4042:                                    // REMOVES ELEMENTS
3183     {
3184       if(checkLock(aStudy)) break;
3185       if( vtkwnd ) {
3186         EmitSignalDeactivateDialog();
3187         ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3188       }
3189       else
3190         {
3191           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3192                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3193         }
3194       break;
3195     }
3196   case 4043: {                                // CLEAR_MESH
3197
3198     if(checkLock(aStudy)) break;
3199
3200     SALOME_ListIO selected;
3201     if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3202       aSel->selectedObjects( selected );
3203
3204     SUIT_OverrideCursor wc;
3205     SALOME_ListIteratorOfListIO It (selected);
3206     for ( ; It.More(); It.Next() )
3207     {
3208       Handle(SALOME_InteractiveObject) IOS = It.Value();
3209       SMESH::SMESH_Mesh_var aMesh =
3210         SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3211       if ( aMesh->_is_nil()) continue;
3212       try {
3213         SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3214         aMesh->Clear();
3215         _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3216         SMESH::ModifiedMesh( aMeshSObj, false, true);
3217         // hide groups and submeshes
3218         _PTR(ChildIterator) anIter =
3219           SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3220         for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3221         {
3222           _PTR(SObject) so = anIter->Value();
3223           SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3224         }
3225       }
3226       catch (const SALOME::SALOME_Exception& S_ex){
3227         wc.suspend();
3228         SalomeApp_Tools::QtCatchCorbaException(S_ex);
3229         wc.resume();
3230       }
3231     }
3232     SMESH::UpdateView();
3233     updateObjBrowser();
3234     break;
3235   }
3236   case 4044:                                     // REMOVE ORPHAN NODES
3237     {
3238       if(checkLock(aStudy)) break;
3239       SALOME_ListIO selected;
3240       if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3241         aSel->selectedObjects( selected );
3242       if ( selected.Extent() == 1 ) {
3243         Handle(SALOME_InteractiveObject) anIO = selected.First();
3244         SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3245         if ( !aMesh->_is_nil() ) {
3246           bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3247                                                     tr( "SMESH_WARNING" ),
3248                                                     tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3249                                                     SUIT_MessageBox::Yes |
3250                                                     SUIT_MessageBox::No,
3251                                                     SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3252           if( confirm ) {
3253             try {
3254               SUIT_OverrideCursor wc;
3255               SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3256               int removed = aMeshEditor->RemoveOrphanNodes();
3257               SUIT_MessageBox::information(SMESHGUI::desktop(),
3258                                            tr("SMESH_INFORMATION"),
3259                                            tr("NB_NODES_REMOVED").arg(removed));
3260               if ( removed > 0 ) {
3261                 SMESH::UpdateView();
3262                 SMESHGUI::Modified();
3263               }
3264             }
3265             catch (const SALOME::SALOME_Exception& S_ex) {
3266               SalomeApp_Tools::QtCatchCorbaException(S_ex);
3267             }
3268             catch (...) {
3269             }
3270           }
3271         }
3272       }
3273       break;
3274     }
3275   case 4051:                                    // RENUMBERING NODES
3276     {
3277       if(checkLock(aStudy)) break;
3278       if( vtkwnd ) {
3279         EmitSignalDeactivateDialog();
3280         ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3281       }
3282       else
3283         {
3284           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3285                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3286         }
3287       break;
3288     }
3289   case 4052:                                    // RENUMBERING ELEMENTS
3290     {
3291       if(checkLock(aStudy)) break;
3292       if ( vtkwnd ) {
3293         EmitSignalDeactivateDialog();
3294         ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3295       }
3296       else
3297         {
3298           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3299                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3300         }
3301       break;
3302     }
3303   case 4061:                                   // TRANSLATION
3304     {
3305       if(checkLock(aStudy)) break;
3306       if ( vtkwnd ) {
3307         EmitSignalDeactivateDialog();
3308         ( new SMESHGUI_TranslationDlg( this ) )->show();
3309       }
3310       else {
3311         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3312                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3313       }
3314       break;
3315     }
3316   case 4062:                                   // ROTATION
3317     {
3318       if(checkLock(aStudy)) break;
3319       if( vtkwnd ) {
3320         EmitSignalDeactivateDialog();
3321         ( new SMESHGUI_RotationDlg( this ) )->show();
3322       }
3323       else {
3324         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3325                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3326       }
3327       break;
3328     }
3329   case 4063:                                   // SYMMETRY
3330     {
3331       if(checkLock(aStudy)) break;
3332       if(vtkwnd) {
3333         EmitSignalDeactivateDialog();
3334         ( new SMESHGUI_SymmetryDlg( this ) )->show();
3335       }
3336       else {
3337         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3338                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3339       }
3340       break;
3341     }
3342   case 4064:                                   // SEWING
3343     {
3344       if(checkLock(aStudy)) break;
3345       if(vtkwnd) {
3346         EmitSignalDeactivateDialog();
3347         ( new SMESHGUI_SewingDlg( this ) )->show();
3348       }
3349       else {
3350         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3351                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3352       }
3353       break;
3354     }
3355   case 4065:                                   // MERGE NODES
3356     {
3357       if(checkLock(aStudy)) break;
3358       if(vtkwnd) {
3359         EmitSignalDeactivateDialog();
3360         ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3361       }
3362       else {
3363         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3364                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3365       }
3366       break;
3367     }
3368   case 4066:                                   // MERGE EQUAL ELEMENTS
3369     {
3370       if (checkLock(aStudy)) break;
3371       if (vtkwnd) {
3372         EmitSignalDeactivateDialog();
3373         ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3374       } else {
3375         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3376                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3377       }
3378       break;
3379     }
3380
3381   case 4067: // MAKE MESH PASS THROUGH POINT
3382     startOperation( 4067 );
3383     break;
3384
3385   case 4068: // SCALE
3386     {
3387       if(checkLock(aStudy)) break;
3388       if ( vtkwnd ) {
3389         EmitSignalDeactivateDialog();
3390         ( new SMESHGUI_ScaleDlg( this ) )->show();
3391       }
3392       else {
3393         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3394                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3395       }
3396       break;
3397     }
3398
3399   case 4069: // DUPLICATE NODES
3400     {
3401       if(checkLock(aStudy)) break;
3402       if ( vtkwnd ) {
3403         EmitSignalDeactivateDialog();
3404         ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3405       }
3406       else {
3407         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3408                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3409       }
3410       break;
3411     }
3412
3413   case 4070: // 0D_ON_ALL_NODES
3414     startOperation( 4070 );
3415     break;
3416
3417   case 5105: // Library of selection filters
3418   {
3419     static QList<int> aTypes;
3420     if ( aTypes.isEmpty() )
3421     {
3422       aTypes.append( SMESH::NODE );
3423       aTypes.append( SMESH::EDGE );
3424       aTypes.append( SMESH::FACE );
3425       aTypes.append( SMESH::VOLUME );
3426     }
3427     if (!myFilterLibraryDlg)
3428       myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3429     else if (myFilterLibraryDlg->isHidden())
3430       myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3431     myFilterLibraryDlg->raise();
3432   }
3433   break;
3434
3435   case 6017:                                    // CONTROLS
3436   case 6016:
3437   case 6015:
3438   case 6014:
3439   case 6013:
3440   case 6012:
3441   case 6011:
3442   case 6001:
3443   case 6018:
3444   case 6019:
3445   case 6002:
3446   case 6003:
3447   case 6004:
3448   case 6005:
3449   case 6009:
3450   case 6021:
3451   case 6022:
3452   case 6023:
3453   case 6024:
3454   case 6025:
3455   case 6026:
3456   case 6027:
3457   case 6028:
3458   case 6029:
3459   case 6030:
3460   case 6031:
3461     if ( vtkwnd ) {
3462
3463       LightApp_SelectionMgr* mgr = selectionMgr();
3464       SALOME_ListIO selected; mgr->selectedObjects( selected );
3465
3466       if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3467         _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3468         if ( SO ) {
3469           CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3470           SMESH::SMESH_Mesh_var      aMesh    = SMESH::SMESH_Mesh::_narrow( aObject );
3471           SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3472           SMESH::SMESH_GroupBase_var aGroup   = SMESH::SMESH_GroupBase::_narrow( aObject );
3473           if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3474             SUIT_OverrideCursor wc;
3475             ::Control( theCommandID );
3476             break;
3477           }
3478         }
3479       }
3480       SUIT_MessageBox::warning(desktop(),
3481                                tr( "SMESH_WRN_WARNING" ),
3482                                tr( "SMESH_BAD_SELECTION" ) );
3483       break;
3484     }
3485     else {
3486       SUIT_MessageBox::warning(desktop(),
3487                                tr( "SMESH_WRN_WARNING" ),
3488                                tr( "NOT_A_VTK_VIEWER" ) );
3489     }
3490     break;
3491   case 6032:
3492     OverallMeshQuality();
3493     break;
3494   case 9010:
3495     {
3496       SUIT_OverrideCursor wc;
3497       LightApp_SelectionMgr* mgr = selectionMgr();
3498       SALOME_ListIO selected; mgr->selectedObjects( selected );
3499
3500       SALOME_ListIteratorOfListIO it(selected);
3501       for( ; it.More(); it.Next()) {
3502         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3503         if(anIObject->hasEntry()) {
3504           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3505             anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3506           }
3507         }
3508       }
3509       break;
3510     }
3511   case 9011:
3512     {
3513       SUIT_OverrideCursor wc;
3514       LightApp_SelectionMgr* mgr = selectionMgr();
3515       SALOME_ListIO selected; mgr->selectedObjects( selected );
3516
3517       SALOME_ListIteratorOfListIO it(selected);
3518       for( ; it.More(); it.Next()) {
3519         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3520         if(anIObject->hasEntry())
3521           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3522             anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3523           }
3524       }
3525       break;
3526     }
3527   case 501:
3528   case 502:
3529     {
3530       int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3531       EmitSignalDeactivateDialog();
3532       SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3533       dlg->show();
3534       break;
3535     }
3536   }
3537
3538   anApp->updateActions(); //SRN: To update a Save button in the toolbar
3539   //updateObjBrowser();
3540   return true;
3541 }
3542
3543 //=============================================================================
3544 /*!
3545  *
3546  */
3547 //=============================================================================
3548 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3549 {
3550   return false;
3551 }
3552
3553 //=============================================================================
3554 /*!
3555  *
3556  */
3557 //=============================================================================
3558 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3559 {
3560   return true;
3561 }
3562
3563 //=============================================================================
3564 /*!
3565  *
3566  */
3567 //=============================================================================
3568 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3569 {
3570   return true;
3571 }
3572
3573 //=============================================================================
3574 /*! Method:  BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3575  *  Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3576  */
3577 //=============================================================================
3578 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3579                                   SUIT_ViewWindow* wnd )
3580 {
3581   if(theIO->hasEntry()){
3582     //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3583     SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3584   }
3585 }
3586
3587 //=======================================================================
3588 // function : createSMESHAction
3589 // purpose  :
3590 //=======================================================================
3591 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3592                                   const int key, const bool toggle, const QString& shortcutAction  )
3593 {
3594   QIcon icon;
3595   QWidget* parent = application()->desktop();
3596   SUIT_ResourceMgr* resMgr = resourceMgr();
3597   QPixmap pix;
3598   if ( !icon_id.isEmpty() )
3599     pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3600   else
3601     pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3602   if ( !pix.isNull() )
3603     icon = QIcon( pix );
3604
3605   QString tooltip    = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3606           menu       = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3607           status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3608
3609   createAction( id, tooltip, icon, menu, status_bar, key, parent,
3610                 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3611 }
3612
3613 //=======================================================================
3614 // function : createPopupItem
3615 // purpose  :
3616 //=======================================================================
3617 void SMESHGUI::createPopupItem( const int id,
3618                                 const QString& clients,
3619                                 const QString& types,
3620                                 const QString& theRule,
3621                                 const int pId )
3622 {
3623   if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3624     popupMgr()->insert( action( id ), pId, 0 );
3625
3626   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
3627   QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3628   QString rule = "(%1) and (%2) and (%3)";
3629   rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3630   if( clients.isEmpty() )
3631     rule = rule.arg( QString( "true" ) );
3632   else
3633     rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3634   rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3635   rule += theRule;
3636
3637   bool cont = myRules.contains( id );
3638   if( cont )
3639     rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3640
3641   popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3642   myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3643 }
3644
3645 //=======================================================================
3646 // function : initialize
3647 // purpose  :
3648 //=======================================================================
3649 void SMESHGUI::initialize( CAM_Application* app )
3650 {
3651   SalomeApp_Module::initialize( app );
3652
3653 //   SUIT_ResourceMgr* mgr = app->resourceMgr();
3654 //   if ( mgr )
3655   /* Automatic Update flag */
3656 //     myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3657
3658   // ----- create actions --------------
3659
3660   //createSMESHAction(  111, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3661   createSMESHAction(  112, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3662   createSMESHAction(  113, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3663   createSMESHAction(  114, "NUM" );
3664   createSMESHAction(  115, "IMPORT_STL"  );
3665   createSMESHAction(  116, "IMPORT_CGNS" );
3666   createSMESHAction(  117, "IMPORT_SAUV" );
3667   createSMESHAction(  118, "IMPORT_GMF"  );
3668   createSMESHAction(  121, "DAT" );
3669   createSMESHAction(  122, "MED" );
3670   createSMESHAction(  123, "UNV" );
3671   createSMESHAction(  140, "STL" );
3672   createSMESHAction(  142, "CGNS");
3673   createSMESHAction(  144, "SAUV");
3674   createSMESHAction(  146, "GMF" );
3675   createSMESHAction(  124, "DAT" );
3676   createSMESHAction(  125, "MED" );
3677   createSMESHAction(  126, "UNV" );
3678   createSMESHAction(  141, "STL" );
3679   createSMESHAction(  143, "CGNS");
3680   createSMESHAction(  145, "SAUV");
3681   createSMESHAction(  147, "GMF" );
3682   createSMESHAction(  150, "FILE_INFO" );
3683   createSMESHAction(   33, "DELETE",          "ICON_DELETE", Qt::Key_Delete );
3684   createSMESHAction( 5105, "SEL_FILTER_LIB" );
3685   createSMESHAction(  701, "COMPUTE",         "ICON_COMPUTE" );
3686   createSMESHAction(  702, "CREATE_MESH",     "ICON_DLG_INIT_MESH" );
3687   createSMESHAction(  703, "CREATE_SUBMESH",  "ICON_DLG_ADD_SUBMESH" );
3688   createSMESHAction(  704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3689   createSMESHAction(  705, "COPY_MESH",       "ICON_COPY_MESH" );
3690   createSMESHAction(  710, "BUILD_COMPOUND",  "ICON_BUILD_COMPOUND" );
3691   createSMESHAction(  711, "PRECOMPUTE",      "ICON_PRECOMPUTE" );
3692   createSMESHAction(  712, "EVALUATE",        "ICON_COMPUTE" );
3693   createSMESHAction(  713, "MESH_ORDER",      "ICON_COMPUTE" );
3694   createSMESHAction(  806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3695   createSMESHAction(  801, "CREATE_GROUP",    "ICON_CREATE_GROUP" );
3696   createSMESHAction(  802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3697   createSMESHAction(  803, "EDIT_GROUP",      "ICON_EDIT_GROUP" );
3698   createSMESHAction(  815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3699   createSMESHAction(  804, "ADD" );
3700   createSMESHAction(  805, "REMOVE" );
3701   createSMESHAction(  810, "UN_GROUP",        "ICON_UNION" );
3702   createSMESHAction(  811, "INT_GROUP",       "ICON_INTERSECT" );
3703   createSMESHAction(  812, "CUT_GROUP",       "ICON_CUT" );
3704   createSMESHAction(  814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3705   createSMESHAction(  813, "DEL_GROUP",       "ICON_DEL_GROUP" );
3706   createSMESHAction(  900, "ADV_INFO",        "ICON_ADV_INFO" );
3707   //createSMESHAction(  902, "STD_INFO",        "ICON_STD_INFO" );
3708   //createSMESHAction(  903, "WHAT_IS",         "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3709   createSMESHAction(  904, "FIND_ELEM",       "ICON_FIND_ELEM" );
3710   createSMESHAction( 6001, "LENGTH",          "ICON_LENGTH",        0, true );
3711   createSMESHAction( 6002, "FREE_EDGE",       "ICON_FREE_EDGE",     0, true );
3712   createSMESHAction( 6021, "FREE_FACES",      "ICON_FREE_FACES",    0, true );
3713   createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D",  "ICON_MAX_ELEMENT_LENGTH_2D",   0, true );
3714   createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D",  "ICON_MAX_ELEMENT_LENGTH_3D",   0, true );
3715   createSMESHAction( 6024, "BARE_BORDER_VOLUME",     "ICON_BARE_BORDER_VOLUME",      0, true );
3716   createSMESHAction( 6025, "BARE_BORDER_FACE",       "ICON_BARE_BORDER_FACE",        0, true );
3717   createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3718   createSMESHAction( 6027, "OVER_CONSTRAINED_FACE",  "ICON_OVER_CONSTRAINED_FACE",   0, true );
3719   createSMESHAction( 6028, "EQUAL_NODE",      "ICON_EQUAL_NODE",    0, true );
3720   createSMESHAction( 6029, "EQUAL_EDGE",      "ICON_EQUAL_EDGE",    0, true );
3721   createSMESHAction( 6030, "EQUAL_FACE",      "ICON_EQUAL_FACE",    0, true );
3722   createSMESHAction( 6031, "EQUAL_VOLUME",    "ICON_EQUAL_VOLUME",  0, true );
3723   createSMESHAction( 6032, "OVERALL_MESH_QUALITY" );
3724   createSMESHAction( 6003, "FREE_BORDER",     "ICON_FREE_EDGE_2D",  0, true );
3725   createSMESHAction( 6004, "CONNECTION",      "ICON_CONNECTION",    0, true );
3726   createSMESHAction( 6005, "FREE_NODE",       "ICON_FREE_NODE",     0, true );
3727   createSMESHAction( 6011, "AREA",            "ICON_AREA",          0, true );
3728   createSMESHAction( 6012, "TAPER",           "ICON_TAPER",         0, true );
3729   createSMESHAction( 6013, "ASPECT",          "ICON_ASPECT",        0, true );
3730   createSMESHAction( 6014, "MIN_ANG",         "ICON_ANGLE",         0, true );
3731   createSMESHAction( 6015, "WARP",            "ICON_WARP",          0, true );
3732   createSMESHAction( 6016, "SKEW",            "ICON_SKEW",          0, true );
3733   createSMESHAction( 6017, "ASPECT_3D",       "ICON_ASPECT_3D",     0, true );
3734   createSMESHAction( 6018, "LENGTH_2D",       "ICON_LENGTH_2D",     0, true );
3735   createSMESHAction( 6019, "CONNECTION_2D",   "ICON_CONNECTION_2D", 0, true );
3736   createSMESHAction( 6009, "VOLUME_3D",       "ICON_VOLUME_3D",     0, true );
3737   createSMESHAction( 4000, "NODE",            "ICON_DLG_NODE" );
3738   createSMESHAction( 4009, "ELEM0D",          "ICON_DLG_ELEM0D" );
3739   createSMESHAction( 4008, "BALL",            "ICON_DLG_BALL" );
3740   createSMESHAction( 4010, "EDGE",            "ICON_DLG_EDGE" );
3741   createSMESHAction( 4021, "TRIANGLE",        "ICON_DLG_TRIANGLE" );
3742   createSMESHAction( 4022, "QUAD",            "ICON_DLG_QUADRANGLE" );
3743   createSMESHAction( 4023, "POLYGON",         "ICON_DLG_POLYGON" );
3744   createSMESHAction( 4031, "TETRA",           "ICON_DLG_TETRAS" );
3745   createSMESHAction( 4032, "HEXA",            "ICON_DLG_HEXAS" );
3746   createSMESHAction( 4133, "PENTA",           "ICON_DLG_PENTA" );
3747   createSMESHAction( 4134, "PYRAMID",         "ICON_DLG_PYRAMID" );
3748   createSMESHAction( 4135, "OCTA",            "ICON_DLG_OCTA" );
3749   createSMESHAction( 4033, "POLYHEDRON",              "ICON_DLG_POLYHEDRON" );
3750   createSMESHAction( 4034, "QUADRATIC_EDGE",          "ICON_DLG_QUADRATIC_EDGE" );
3751   createSMESHAction( 4035, "QUADRATIC_TRIANGLE",      "ICON_DLG_QUADRATIC_TRIANGLE" );
3752   createSMESHAction( 4036, "QUADRATIC_QUADRANGLE",    "ICON_DLG_QUADRATIC_QUADRANGLE" );
3753   createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE",  "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3754   createSMESHAction( 4137, "BIQUADRATIC_TRIANGLE",    "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3755   createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON",   "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3756   createSMESHAction( 4038, "QUADRATIC_PYRAMID",       "ICON_DLG_QUADRATIC_PYRAMID" );
3757   createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON",   "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3758   createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON",    "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3759   createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3760   createSMESHAction( 4041, "REMOVE_NODES",          "ICON_DLG_REM_NODE" );
3761   createSMESHAction( 4042, "REMOVE_ELEMENTS",       "ICON_DLG_REM_ELEMENT" );
3762   createSMESHAction( 4044, "REMOVE_ORPHAN_NODES",   "ICON_DLG_REM_ORPHAN_NODES" );
3763   createSMESHAction( 4043, "CLEAR_MESH"    ,  "ICON_CLEAR_MESH" );
3764   createSMESHAction( 4051, "RENUM_NODES",     "ICON_DLG_RENUMBERING_NODES" );
3765   createSMESHAction( 4052, "RENUM_ELEMENTS",  "ICON_DLG_RENUMBERING_ELEMENTS" );
3766   createSMESHAction( 4061, "TRANS",           "ICON_SMESH_TRANSLATION_VECTOR" );
3767   createSMESHAction( 4062, "ROT",             "ICON_DLG_MESH_ROTATION" );
3768   createSMESHAction( 4063, "SYM",             "ICON_SMESH_SYMMETRY_PLANE" );
3769   createSMESHAction( 4064, "SEW",             "ICON_SMESH_SEWING_FREEBORDERS" );
3770   createSMESHAction( 4065, "MERGE",           "ICON_SMESH_MERGE_NODES" );
3771   createSMESHAction( 4066, "MERGE_ELEMENTS",  "ICON_DLG_MERGE_ELEMENTS" );
3772   createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3773   createSMESHAction( 4068, "SCALE",           "ICON_DLG_MESH_SCALE" );
3774   createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3775   createSMESHAction( 4070, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3776   createSMESHAction(  407, "INV",             "ICON_DLG_MESH_DIAGONAL" );
3777   createSMESHAction(  408, "UNION2",          "ICON_UNION2TRI" );
3778   createSMESHAction(  409, "ORIENT",          "ICON_DLG_MESH_ORIENTATION" );
3779   createSMESHAction(  410, "UNION",           "ICON_UNIONTRI" );
3780   createSMESHAction(  411, "CUT",             "ICON_CUTQUAD" );
3781   createSMESHAction(  412, "SMOOTH",          "ICON_DLG_SMOOTHING" );
3782   createSMESHAction(  413, "EXTRUSION",       "ICON_EXTRUSION" );
3783   createSMESHAction(  414, "REVOLUTION",      "ICON_REVOLUTION" );
3784   createSMESHAction(  415, "MAP",             "ICON_MAP" );
3785   createSMESHAction(  416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3786   createSMESHAction(  417, "CONV_TO_QUAD",    "ICON_CONV_TO_QUAD" );
3787   createSMESHAction(  418, "2D_FROM_3D",      "ICON_2D_FROM_3D" );
3788   createSMESHAction(  419, "SPLIT_TO_TETRA",  "ICON_SPLIT_TO_TETRA" );
3789   createSMESHAction(  420, "REORIENT_2D",     "ICON_REORIENT_2D" );
3790   createSMESHAction(  200, "RESET" );
3791   createSMESHAction(  201, "SCALAR_BAR_PROP" );
3792   createSMESHAction(  2021, "SAVE_DISTRIBUTION" );
3793   createSMESHAction(  2022, "SHOW_DISTRIBUTION","",0, true );
3794 #ifndef DISABLE_PLOT2DVIEWER
3795   createSMESHAction(  2023, "PLOT_DISTRIBUTION" );
3796 #endif
3797   createSMESHAction(  211, "WIRE",           "ICON_WIRE", 0, true );
3798   createSMESHAction(  212, "SHADE",          "ICON_SHADE", 0, true );
3799   createSMESHAction(  213, "SHRINK",         "ICON_SHRINK", 0, true );
3800   createSMESHAction(  214, "UPDATE",         "ICON_UPDATE" );
3801   createSMESHAction(  215, "NODES",          "ICON_POINTS", 0, true );
3802   createSMESHAction(  222, "BALLS",          "ICON_DLG_BALL", 0, true );
3803   createSMESHAction(  216, "ELEMS0D",        "ICON_DLG_ELEM0D", 0, true );
3804   createSMESHAction(  217, "EDGES",          "ICON_DLG_EDGE", 0, true );
3805   createSMESHAction(  218, "FACES",          "ICON_DLG_TRIANGLE", 0, true );
3806   createSMESHAction(  219, "VOLUMES",        "ICON_DLG_TETRAS", 0, true );
3807   createSMESHAction(  220, "ALL" );
3808   createSMESHAction(  221, "FACE_ORIENTATION", "", 0, true );
3809
3810   createSMESHAction(  231, "LINE_REPRESENTATION", "", 0, true );
3811   createSMESHAction(  232, "ARC_REPRESENTATION", "", 0, true );
3812
3813   createSMESHAction( 1100, "EDIT_HYPO" );
3814   createSMESHAction( 1102, "UNASSIGN" );
3815   createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3816   createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3817   createSMESHAction( 1131, "DISPMODE" );
3818   createSMESHAction( 1132, "COLORS" );
3819   createSMESHAction( 1133, "TRANSP" );
3820   createSMESHAction( 1134, "CLIP" );
3821   createSMESHAction( 1135, "DISP_ENT" );
3822   createSMESHAction( 1136, "AUTO_COLOR" );
3823   createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3824   createSMESHAction( 2000, "CTRL" );
3825
3826   createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3827   createSMESHAction( 502, "MEASURE_BND_BOX",  "ICON_MEASURE_BND_BOX" );
3828
3829   createSMESHAction( 300, "HIDE" );
3830   createSMESHAction( 301, "SHOW" );
3831   createSMESHAction( 302, "DISPLAY_ONLY" );
3832
3833   // ----- create menu --------------
3834   int fileId    = createMenu( tr( "MEN_FILE" ),    -1,  1 ),
3835       editId    = createMenu( tr( "MEN_EDIT" ),    -1,  3 ),
3836       toolsId   = createMenu( tr( "MEN_TOOLS" ),   -1,  5, 50 ),
3837       meshId    = createMenu( tr( "MEN_MESH" ),    -1, 70, 10 ),
3838       ctrlId    = createMenu( tr( "MEN_CTRL" ),    -1, 60, 10 ),
3839       modifyId  = createMenu( tr( "MEN_MODIFY" ),  -1, 40, 10 ),
3840       measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3841       viewId    = createMenu( tr( "MEN_VIEW" ),    -1,  2 );
3842
3843   createMenu( separator(), fileId );
3844
3845   int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3846       exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3847       nodeId   = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3848       edgeId   = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3849       faceId   = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3850       volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3851       addId    = createMenu( tr( "MEN_ADD" ),    modifyId, 402 ),
3852       removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3853       renumId  = createMenu( tr( "MEN_RENUM" ),  modifyId, 404 ),
3854       transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3855
3856   //createMenu( 111, importId, -1 );
3857   createMenu( 112, importId, -1 );
3858   createMenu( 113, importId, -1 );
3859   createMenu( 115, importId, -1 );
3860 #ifdef WITH_CGNS
3861   createMenu( 116, importId, -1 );
3862 #endif
3863   createMenu( 117, importId, -1 );
3864   createMenu( 118, importId, -1 );
3865   createMenu( 121, exportId, -1 );
3866   createMenu( 122, exportId, -1 );
3867   createMenu( 123, exportId, -1 );
3868   createMenu( 140, exportId, -1 ); // export to STL
3869 #ifdef WITH_CGNS
3870   createMenu( 142, exportId, -1 ); // export to CGNS
3871 #endif
3872   createMenu( 144, exportId, -1 ); // export to SAUV
3873   createMenu( 146, exportId, -1 ); // export to GMF
3874   createMenu( separator(), fileId, 10 );
3875
3876   createMenu( 33, editId, -1 );
3877
3878   createMenu( 5105, toolsId, -1 );
3879
3880   createMenu( 702, meshId, -1 ); // "Mesh" menu
3881   createMenu( 703, meshId, -1 );
3882   createMenu( 704, meshId, -1 );
3883   createMenu( 710, meshId, -1 );
3884   createMenu( 705, meshId, -1 );
3885   createMenu( separator(), meshId, -1 );
3886   createMenu( 701, meshId, -1 );
3887   createMenu( 711, meshId, -1 );
3888   createMenu( 712, meshId, -1 );
3889   createMenu( 713, meshId, -1 );
3890   createMenu( separator(), meshId, -1 );
3891   createMenu( 801, meshId, -1 );
3892   createMenu( 806, meshId, -1 );
3893   createMenu( 802, meshId, -1 );
3894   createMenu( 803, meshId, -1 );
3895   createMenu( 815, meshId, -1 );
3896   createMenu( separator(), meshId, -1 );
3897   createMenu( 810, meshId, -1 );
3898   createMenu( 811, meshId, -1 );
3899   createMenu( 812, meshId, -1 );
3900   createMenu( separator(), meshId, -1 );
3901   createMenu( 814, meshId, -1 );
3902   createMenu( separator(), meshId, -1 );
3903   createMenu( 900, meshId, -1 );
3904   //createMenu( 902, meshId, -1 );
3905   //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3906   createMenu( 904, meshId, -1 );
3907   createMenu( separator(), meshId, -1 );
3908
3909   createMenu( 6005, nodeId, -1 );
3910   createMenu( 6028, nodeId, -1 );
3911   createMenu( 6002, edgeId, -1 );
3912   createMenu( 6003, edgeId, -1 );
3913   createMenu( 6001, edgeId, -1 );
3914   createMenu( 6004, edgeId, -1 );
3915   createMenu( 6029, edgeId, -1 );
3916   createMenu( 6021, faceId, -1 );
3917   createMenu( 6025, faceId, -1 );
3918   createMenu( 6027, faceId, -1 );
3919   createMenu( 6018, faceId, -1 );
3920   createMenu( 6019, faceId, -1 );
3921   createMenu( 6011, faceId, -1 );
3922   createMenu( 6012, faceId, -1 );
3923   createMenu( 6013, faceId, -1 );
3924   createMenu( 6014, faceId, -1 );
3925   createMenu( 6015, faceId, -1 );
3926   createMenu( 6016, faceId, -1 );
3927   createMenu( 6022, faceId, -1 );
3928   createMenu( 6030, faceId, -1 );
3929   createMenu( 6017, volumeId, -1 );
3930   createMenu( 6009, volumeId, -1 );
3931   createMenu( 6023, volumeId, -1 );
3932   createMenu( 6024, volumeId, -1 );
3933   createMenu( 6026, volumeId, -1 );
3934   createMenu( 6031, volumeId, -1 );
3935   createMenu( separator(), ctrlId, -1 );
3936   createMenu( 6032, ctrlId, -1 );
3937
3938   createMenu( 4000, addId, -1 );
3939   createMenu( 4009, addId, -1 );
3940   createMenu( 4070, addId, -1 );
3941   createMenu( 4008, addId, -1 );
3942   createMenu( 4010, addId, -1 );
3943   createMenu( 4021, addId, -1 );
3944   createMenu( 4022, addId, -1 );
3945   createMenu( 4023, addId, -1 );
3946   createMenu( 4031, addId, -1 );
3947   createMenu( 4032, addId, -1 );
3948   createMenu( 4133, addId, -1 );
3949   createMenu( 4134, addId, -1 );
3950   createMenu( 4135, addId, -1 );
3951   createMenu( 4033, addId, -1 );
3952   createMenu( separator(), addId, -1 );
3953   createMenu( 4034, addId, -1 );
3954   createMenu( 4035, addId, -1 );
3955   createMenu( 4137, addId, -1 );
3956   createMenu( 4036, addId, -1 );
3957   createMenu( 4136, addId, -1 );
3958   createMenu( 4037, addId, -1 );
3959   createMenu( 4038, addId, -1 );
3960   createMenu( 4039, addId, -1 );
3961   createMenu( 4040, addId, -1 );
3962   createMenu( 4140, addId, -1 );
3963
3964   createMenu( 4041, removeId, -1 );
3965   createMenu( 4042, removeId, -1 );
3966   createMenu( 4044, removeId, -1 );
3967   createMenu( separator(), removeId, -1 );
3968   createMenu( 813, removeId, -1 );
3969   createMenu( separator(), removeId, -1 );
3970   createMenu( 4043, removeId, -1 );
3971
3972   createMenu( 4051, renumId, -1 );
3973   createMenu( 4052, renumId, -1 );
3974
3975   createMenu( 4061, transfId, -1 );
3976   createMenu( 4062, transfId, -1 );
3977   createMenu( 4063, transfId, -1 );
3978   createMenu( 4068, transfId, -1 );
3979   createMenu( 4064, transfId, -1 );
3980   createMenu( 4065, transfId, -1 );
3981   createMenu( 4066, transfId, -1 );
3982   createMenu( 4069, transfId, -1 );
3983
3984   createMenu( 4067,modifyId, -1 );
3985   createMenu( 407, modifyId, -1 );
3986   createMenu( 408, modifyId, -1 );
3987   createMenu( 409, modifyId, -1 );
3988   createMenu( 420, modifyId, -1 );
3989   createMenu( 410, modifyId, -1 );
3990   createMenu( 411, modifyId, -1 );
3991   createMenu( 419, modifyId, -1 );
3992   createMenu( 412, modifyId, -1 );
3993   createMenu( 413, modifyId, -1 );
3994   createMenu( 416, modifyId, -1 );
3995   createMenu( 414, modifyId, -1 );
3996   createMenu( 415, modifyId, -1 );
3997   createMenu( 417, modifyId, -1 );
3998   createMenu( 418, modifyId, -1 );
3999
4000   createMenu( 501, measureId, -1 );
4001   createMenu( 502, measureId, -1 );
4002   createMenu( 214, viewId, -1 );
4003
4004   // ----- create toolbars --------------
4005   int meshTb     = createTool( tr( "TB_MESH" ) ),
4006       ctrlTb     = createTool( tr( "TB_CTRL" ) ),
4007       addRemTb   = createTool( tr( "TB_ADD_REMOVE" ) ),
4008       modifyTb   = createTool( tr( "TB_MODIFY" ) ),
4009       dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
4010
4011   createTool( 702, meshTb );
4012   createTool( 703, meshTb );
4013   createTool( 704, meshTb );
4014   createTool( 710, meshTb );
4015   createTool( 705, meshTb );
4016   createTool( separator(), meshTb );
4017   createTool( 701, meshTb );
4018   createTool( 711, meshTb );
4019   createTool( 712, meshTb );
4020   createTool( 713, meshTb );
4021   createTool( separator(), meshTb );
4022   createTool( 801, meshTb );
4023   createTool( 806, meshTb );
4024   createTool( 802, meshTb );
4025   createTool( 803, meshTb );
4026   //createTool( 815, meshTb );
4027   createTool( separator(), meshTb );
4028   createTool( 900, meshTb );
4029   //createTool( 902, meshTb );
4030   //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4031   createTool( 904, meshTb );
4032   createTool( separator(), meshTb );
4033
4034   createTool( 6005, ctrlTb );
4035   createTool( 6028, ctrlTb );
4036   createTool( separator(), ctrlTb );
4037   createTool( 6002, ctrlTb );
4038   createTool( 6003, ctrlTb );
4039   createTool( 6001, ctrlTb );
4040   createTool( 6004, ctrlTb );
4041   createTool( 6029, ctrlTb );
4042   createTool( separator(), ctrlTb );
4043   createTool( 6021, ctrlTb );
4044   createTool( 6025, ctrlTb );
4045   createTool( 6027, ctrlTb );
4046   createTool( 6018, ctrlTb );
4047   createTool( 6019, ctrlTb );
4048   createTool( 6011, ctrlTb );
4049   createTool( 6012, ctrlTb );
4050   createTool( 6013, ctrlTb );
4051   createTool( 6014, ctrlTb );
4052   createTool( 6015, ctrlTb );
4053   createTool( 6016, ctrlTb );
4054   createTool( 6022, ctrlTb );
4055   createTool( 6030, ctrlTb );
4056   createTool( separator(), ctrlTb );
4057   createTool( 6017, ctrlTb );
4058   createTool( 6009, ctrlTb );
4059   createTool( 6023, ctrlTb );
4060   createTool( 6024, ctrlTb );
4061   createTool( 6026, ctrlTb );
4062   createTool( 6031, ctrlTb );
4063   createTool( separator(), ctrlTb );
4064
4065   createTool( 4000, addRemTb );
4066   createTool( 4009, addRemTb );
4067   createTool( 4070, addRemTb );
4068   createTool( 4008, addRemTb );
4069   createTool( 4010, addRemTb );
4070   createTool( 4021, addRemTb );
4071   createTool( 4022, addRemTb );
4072   createTool( 4023, addRemTb );
4073   createTool( 4031, addRemTb );
4074   createTool( 4032, addRemTb );
4075   createTool( 4133, addRemTb );
4076   createTool( 4134, addRemTb );
4077   createTool( 4135, addRemTb );
4078   createTool( 4033, addRemTb );
4079   createTool( separator(), addRemTb );
4080   createTool( 4034, addRemTb );
4081   createTool( 4035, addRemTb );
4082   createTool( 4137, addRemTb );
4083   createTool( 4036, addRemTb );
4084   createTool( 4136, addRemTb );
4085   createTool( 4037, addRemTb );
4086   createTool( 4038, addRemTb );
4087   createTool( 4039, addRemTb );
4088   createTool( 4040, addRemTb );
4089   createTool( 4140, addRemTb );
4090   createTool( separator(), addRemTb );
4091   createTool( 4041, addRemTb );
4092   createTool( 4042, addRemTb );
4093   createTool( 4044, addRemTb );
4094   createTool( 4043, addRemTb );
4095   createTool( separator(), addRemTb );
4096   createTool( 4051, addRemTb );
4097   createTool( 4052, addRemTb );
4098   createTool( separator(), addRemTb );
4099   createTool( 4061, addRemTb );
4100   createTool( 4062, addRemTb );
4101   createTool( 4063, addRemTb );
4102   createTool( 4068, addRemTb );
4103   createTool( 4064, addRemTb );
4104   createTool( 4065, addRemTb );
4105   createTool( 4066, addRemTb );
4106   createTool( 4069, addRemTb );
4107   createTool( separator(), addRemTb );
4108
4109   createTool( 4067,modifyTb );
4110   createTool( 407, modifyTb );
4111   createTool( 408, modifyTb );
4112   createTool( 409, modifyTb );
4113   createTool( 420, modifyTb );
4114   createTool( 410, modifyTb );
4115   createTool( 411, modifyTb );
4116   createTool( 419, modifyTb );
4117   createTool( 412, modifyTb );
4118   createTool( 413, modifyTb );
4119   createTool( 416, modifyTb );
4120   createTool( 414, modifyTb );
4121   createTool( 415, modifyTb );
4122   createTool( 417, modifyTb );
4123   createTool( 418, modifyTb );
4124
4125   createTool( 214, dispModeTb );
4126
4127   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
4128   QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4129
4130   myRules.clear();
4131   QString OB = "'ObjectBrowser'",
4132           View = "'" + SVTK_Viewer::Type() + "'",
4133           pat = "'%1'",
4134           mesh    = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4135           group   = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4136           hypo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4137           algo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4138           elems   = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4139                        arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4140                        arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4141                        arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4142                        arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4143                        arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4144                        arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4145           subMesh = elems,
4146           mesh_part = mesh + " " + subMesh + " " + group,
4147           mesh_group = mesh + " " + group,
4148           hyp_alg = hypo + " " + algo;
4149
4150   // popup for object browser
4151   QString
4152     isInvisible("not( isVisible )"),
4153     isEmpty("numberOfNodes = 0"),
4154     isNotEmpty("numberOfNodes <> 0"),
4155
4156     // has nodes, edges, etc in VISIBLE! actor
4157     hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4158     hasElems("(count( elemTypes ) > 0)"),
4159     hasDifferentElems("(count( elemTypes ) > 1)"),
4160     hasBalls("({'BallElem'} in elemTypes)"),
4161     hasElems0d("({'Elem0d'} in elemTypes)"),
4162     hasEdges("({'Edge'} in elemTypes)"),
4163     hasFaces("({'Face'} in elemTypes)"),
4164     hasVolumes("({'Volume'} in elemTypes)");
4165
4166   createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" );      // FILE INFORMATION
4167   createPopupItem( 703, OB, mesh, "&& isComputable");      // CREATE_SUBMESH
4168   createPopupItem( 704, OB, mesh, "&& isComputable");      // EDIT_MESHSUBMESH
4169   createPopupItem( 704, OB, subMesh, "&& isComputable" );  // EDIT_MESHSUBMESH
4170   createPopupItem( 803, OB, group );                       // EDIT_GROUP
4171   createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
4172
4173   popupMgr()->insert( separator(), -1, 0 );
4174   createPopupItem( 701, OB, mesh, "&& isComputable" );     // COMPUTE
4175   createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
4176   createPopupItem( 712, OB, mesh, "&& isComputable" );     // EVALUATE
4177   createPopupItem( 713, OB, mesh, "&& isComputable" );     // MESH ORDER
4178   createPopupItem( 214, OB, mesh_part );                   // UPDATE
4179   createPopupItem( 900, OB, mesh_part );                   // ADV_INFO
4180   createPopupItem( 904, OB, mesh_group );                  // FIND_ELEM
4181   createPopupItem( 6032, OB, mesh_part );                  // CTRL_INFO
4182   popupMgr()->insert( separator(), -1, 0 );
4183   createPopupItem( 801, OB, mesh );                        // CREATE_GROUP
4184   createPopupItem( 806, OB, mesh );                        // CREATE_GEO_GROUP
4185   createPopupItem( 802, OB, subMesh );                     // CONSTRUCT_GROUP
4186   popupMgr()->insert( separator(), -1, 0 );
4187   createPopupItem( 1100, OB, hypo);                        // EDIT HYPOTHESIS
4188   createPopupItem( 1102, OB, hyp_alg );                    // REMOVE HYPOTHESIS / ALGORITHMS
4189   popupMgr()->insert( separator(), -1, 0 );
4190   createPopupItem( 4043, OB, mesh );                       // CLEAR_MESH
4191   popupMgr()->insert( separator(), -1, 0 );
4192   createPopupItem( 417, OB, mesh + " " + subMesh );        // convert to quadratic
4193   createPopupItem( 418, OB, mesh + " " + group,            // create 2D mesh from 3D
4194                    "&& dim>=2");
4195   popupMgr()->insert( separator(), -1, 0 );
4196
4197   QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4198   QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4199   QString only_one_2D        = only_one_non_empty + " && dim>1";
4200
4201   int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 );        // EXPORT submenu
4202   createPopupItem( 125, OB, mesh_group, multiple_non_empty, anId );   // EXPORT_MED
4203   createPopupItem( 126, OB, mesh_group, only_one_non_empty, anId );   // EXPORT_UNV
4204   createPopupItem( 141, OB, mesh_group, only_one_2D, anId );          // EXPORT_STL
4205 #ifdef WITH_CGNS
4206   createPopupItem( 143, OB, mesh_group, multiple_non_empty, anId );   // EXPORT_CGNS
4207 #endif
4208   createPopupItem( 145, OB, mesh_group, multiple_non_empty, anId );   // EXPORT_SAUV
4209   createPopupItem( 147, OB, mesh_group, multiple_non_empty, anId );   // EXPORT_GMF
4210   createPopupItem( 124, OB, mesh_group, multiple_non_empty, anId );   // EXPORT_DAT
4211   createPopupItem(  33, OB, mesh_part + " " + hyp_alg );        // DELETE
4212   createPopupItem( 813, OB, group );                            // DEL_GROUP with contents
4213   popupMgr()->insert( separator(), -1, 0 );
4214
4215   // popup for viewer
4216   createPopupItem( 803, View, group ); // EDIT_GROUP
4217   createPopupItem( 804, View, elems ); // ADD
4218   createPopupItem( 805, View, elems ); // REMOVE
4219
4220   popupMgr()->insert( separator(), -1, 0 );
4221   createPopupItem( 214, View, mesh_part );  // UPDATE
4222   createPopupItem( 900, View, mesh_part );  // ADV_INFO
4223   createPopupItem( 904, View, mesh );       // FIND_ELEM
4224   popupMgr()->insert( separator(), -1, 0 );
4225
4226   createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
4227   createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" );       // DISABLE_AUTO_COLOR
4228   popupMgr()->insert( separator(), -1, 0 );
4229
4230   QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4231   QString aType = QString( "%1type in {%2}" ).arg( lc );
4232   aType = aType.arg( mesh_part );
4233   QString aMeshInVTK = aClient + "&&" + aType;
4234
4235   aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4236   QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4237   QString aSelCount = QString( "%1 > 0" ).arg( dc );
4238
4239   //-------------------------------------------------
4240   // Numbering
4241   //-------------------------------------------------
4242   anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4243
4244   popupMgr()->insert( action( 9010 ), anId, -1 );
4245   popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4246   popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4247
4248   popupMgr()->insert( action( 9011 ), anId, -1 );
4249   popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4250   popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4251
4252   popupMgr()->insert( separator(), -1, -1 );
4253
4254   //-------------------------------------------------
4255   // Display Mode
4256   //-------------------------------------------------
4257   anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4258
4259   popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4260   popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4261   popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4262
4263   popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4264   popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4265   popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4266
4267   popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4268   popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4269   popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4270
4271   popupMgr()->insert( separator(), anId, -1 );
4272
4273   popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4274   popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4275   popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4276
4277   //-------------------------------------------------
4278   // Display Entity
4279   //-------------------------------------------------
4280   QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4281
4282   anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4283
4284   popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4285   popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4286   popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4287
4288   popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4289   popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4290   popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4291
4292   popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4293   popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4294   popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4295
4296   popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4297   popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4298   popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4299
4300   popupMgr()->insert( action( 222 ), anId, -1 ); // BALLS
4301   popupMgr()->setRule( action( 222 ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4302   popupMgr()->setRule( action( 222 ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4303
4304   popupMgr()->insert( separator(), anId, -1 );
4305
4306   popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4307   popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4308
4309
4310   //-------------------------------------------------
4311   // Representation of the 2D Quadratic elements
4312   //-------------------------------------------------
4313   anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4314   popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4315   popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4316   popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4317
4318   popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4319   popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4320   popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4321
4322   //-------------------------------------------------
4323   // Orientation of faces
4324   //-------------------------------------------------
4325   popupMgr()->insert( action( 221 ), -1, -1 );
4326   popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4327   popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4328
4329   //-------------------------------------------------
4330   // Color / Size
4331   //-------------------------------------------------
4332   popupMgr()->insert( action( 1132 ), -1, -1 );
4333   popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4334
4335   //-------------------------------------------------
4336   // Transparency
4337   //-------------------------------------------------
4338   popupMgr()->insert( action( 1133 ), -1, -1 );
4339   popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4340
4341   //-------------------------------------------------
4342   // Controls
4343   //-------------------------------------------------
4344   QString
4345     aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4346     aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4347     aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4348     aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4349
4350   anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4351
4352   popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4353   popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4354
4355   popupMgr()->insert( separator(), anId, -1 );
4356
4357   int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4358
4359   popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4360   popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4361   popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4362
4363   popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4364   popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4365   popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4366
4367   aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4368
4369   popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4370   popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4371   popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4372
4373   popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4374   popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4375   popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4376
4377   popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4378   popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4379   popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4380
4381   popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4382   popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4383   popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4384   popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4385   popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4386   popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4387
4388   aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4389
4390   popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4391   popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4392                                        QtxPopupMgr::VisibleRule );
4393   popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4394
4395   popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4396   popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4397   popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4398
4399   popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4400   popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4401   popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4402
4403   popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4404   popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4405   popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4406
4407   popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4408   popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4409   popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4410
4411   popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4412   popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4413   popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4414
4415   popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4416   popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4417   popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4418
4419   popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4420   popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4421   popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4422
4423   popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4424   popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4425   popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4426
4427   popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4428   popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4429   popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4430
4431   popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4432   popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4433   popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4434
4435   popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4436   popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4437   popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4438   popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4439   popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4440   popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4441
4442   aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4443
4444   popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4445   popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4446   popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4447
4448   popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4449   popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4450   popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4451
4452   popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4453   popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4454   popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4455
4456   popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4457   popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4458   popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4459
4460   popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4461   popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4462   popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4463
4464   popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4465   popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4466   popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4467
4468   popupMgr()->insert( separator(), anId, -1 );
4469
4470   popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4471   popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4472
4473   popupMgr()->insert( separator(), anId, -1 );
4474
4475   aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4476
4477   popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4478   popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4479
4480   popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4481   popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4482   popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4483
4484 #ifndef DISABLE_PLOT2DVIEWER
4485   popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4486   popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4487 #endif
4488
4489   //-------------------------------------------------
4490   // Display / Erase
4491   //-------------------------------------------------
4492   popupMgr()->insert( separator(), -1, -1 );
4493   QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4494     aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4495   popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4496   popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4497
4498   popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4499   popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4500
4501   popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4502   popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4503
4504   popupMgr()->insert( separator(), -1, -1 );
4505
4506   //-------------------------------------------------
4507   // Clipping
4508   //-------------------------------------------------
4509   popupMgr()->insert( action( 1134 ), -1, -1 );
4510   popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4511
4512   popupMgr()->insert( separator(), -1, -1 );
4513
4514   connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4515            this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4516
4517   connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4518            this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4519 }
4520
4521 //================================================================================
4522 /*!
4523  * \brief Return true if SMESH or GEOM objects are selected.
4524  * Is called form LightApp_Module::activateModule() which clear selection if
4525  * not isSelectionCompatible()
4526  */
4527 //================================================================================
4528
4529 bool SMESHGUI::isSelectionCompatible()
4530 {
4531   bool isCompatible = true;
4532   SALOME_ListIO selected;
4533   if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4534     Sel->selectedObjects( selected );
4535
4536   SALOME_ListIteratorOfListIO It( selected );
4537   for ( ; isCompatible && It.More(); It.Next())
4538     isCompatible =
4539       ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4540       ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4541
4542   return isCompatible;
4543 }
4544
4545
4546 bool SMESHGUI::reusableOperation( const int id )
4547 {
4548   // compute, evaluate and precompute are not reusable operations
4549   return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4550 }
4551
4552 bool SMESHGUI::activateModule( SUIT_Study* study )
4553 {
4554   bool res = SalomeApp_Module::activateModule( study );
4555
4556   setMenuShown( true );
4557   setToolShown( true );
4558
4559   // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4560   PyGILState_STATE gstate = PyGILState_Ensure();
4561   PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4562   if(pluginsmanager==NULL)
4563     PyErr_Print();
4564   else
4565     {
4566       PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4567       if(result==NULL)
4568         PyErr_Print();
4569       Py_XDECREF(result);
4570     }
4571   PyGILState_Release(gstate);
4572   // end of GEOM plugins loading
4573
4574   // Reset actions accelerator keys
4575   //action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4576   action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4577   action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4578
4579   action(  33)->setEnabled(true); // Delete: Key_Delete
4580
4581   //  0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4582   GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4583   if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4584     if ( _PTR(Study) aStudy = s->studyDS()) {
4585       GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4586       updateObjBrowser(); // objects can be removed
4587     }
4588
4589   // get all view currently opened in the study and connect their signals  to
4590   // the corresponding slots of the class.
4591   SUIT_Desktop* aDesk = study->application()->desktop();
4592   if ( aDesk ) {
4593     QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4594     SUIT_ViewWindow* wnd;
4595     foreach ( wnd, wndList )
4596       connectView( wnd );
4597   }
4598
4599   return res;
4600 }
4601
4602 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4603 {
4604   setMenuShown( false );
4605   setToolShown( false );
4606
4607   EmitSignalCloseAllDialogs();
4608
4609   // Unset actions accelerator keys
4610   //action(111)->setShortcut(QKeySequence()); // Import DAT
4611   action(112)->setShortcut(QKeySequence()); // Import UNV
4612   action(113)->setShortcut(QKeySequence()); // Import MED
4613
4614   action(  33)->setEnabled(false); // Delete: Key_Delete
4615
4616   return SalomeApp_Module::deactivateModule( study );
4617 }
4618
4619 void SMESHGUI::studyClosed( SUIT_Study* s )
4620 {
4621   SMESH::RemoveVisuData( s->id() );
4622   SalomeApp_Module::studyClosed( s );
4623 }
4624
4625 void SMESHGUI::OnGUIEvent()
4626 {
4627   const QObject* obj = sender();
4628   if ( !obj || !obj->inherits( "QAction" ) )
4629     return;
4630   int id = actionId((QAction*)obj);
4631   if ( id != -1 )
4632     OnGUIEvent( id );
4633 }
4634
4635 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4636 {
4637   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4638   if ( CORBA::is_nil( myComponentSMESH ) )
4639     {
4640       SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4641       if ( aStudy )
4642         aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4643       return aGUI.myComponentSMESH;
4644     }
4645   if ( aStudy )
4646     myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4647   return myComponentSMESH;
4648 }
4649
4650 QString SMESHGUI::engineIOR() const
4651 {
4652   CORBA::ORB_var anORB = getApp()->orb();
4653   CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4654   return QString( anIOR.in() );
4655 }
4656
4657 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4658 {
4659   SalomeApp_Module::contextMenuPopup( client, menu, title );
4660   SALOME_ListIO lst;
4661   selectionMgr()->selectedObjects( lst );
4662   if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4663     Handle(SALOME_InteractiveObject) io = lst.First();
4664     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4665     _PTR(Study) study = appStudy->studyDS();
4666     _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4667     if ( obj ) {
4668       QString aName = QString( obj->GetName().c_str() );
4669       while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4670           aName.remove( (aName.length() - 1), 1 );
4671       title = aName;
4672     }
4673   }
4674 }
4675
4676 LightApp_Selection* SMESHGUI::createSelection() const
4677 {
4678   return new SMESHGUI_Selection();
4679 }
4680
4681 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4682 {
4683   aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4684   aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4685 }
4686
4687 void SMESHGUI::viewManagers( QStringList& list ) const
4688 {
4689   list.append( SVTK_Viewer::Type() );
4690 }
4691
4692 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4693 {
4694   if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4695     SMESH::UpdateSelectionProp( this );
4696
4697     QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4698     for(int i = 0; i < aViews.count() ; i++){
4699       SUIT_ViewWindow *sf = aViews[i];
4700       connectView( sf );
4701     }
4702   }
4703 }
4704
4705 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4706 {
4707   if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4708     myClippingPlaneInfoMap.erase( theViewManager );
4709 }
4710
4711 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4712 {
4713   theActor->AddObserver( SMESH::DeleteActorEvent,
4714                          myEventCallbackCommand.GetPointer(),
4715                          myPriority );
4716 }
4717
4718 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4719                               unsigned long theEvent,
4720                               void* theClientData,
4721                               void* theCallData )
4722 {
4723   if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4724     if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4725       if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4726         SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4727         SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4728         for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4729           SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4730           SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4731           for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4732             SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4733             std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4734             SMESH::TActorList::iterator anIter3 = anActorList.begin();
4735             for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4736               if( anActor == *anIter3 ) {
4737                 anActorList.erase( anIter3 );
4738                 break;
4739               }
4740             }
4741           }
4742         }
4743       }
4744     }
4745   }
4746 }
4747
4748 void SMESHGUI::createPreferences()
4749 {
4750   // General tab ------------------------------------------------------------------------
4751   int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4752
4753   int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4754   setPreferenceProperty( autoUpdate, "columns", 2 );
4755   int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4756   setPreferenceProperty( lim, "min",  0 );
4757   setPreferenceProperty( lim, "max",  100000000 );
4758   setPreferenceProperty( lim, "step", 1000 );
4759   setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4760   addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4761
4762   int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4763   setPreferenceProperty( qaGroup, "columns", 2 );
4764   addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4765   addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4766   int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4767   setPreferenceProperty( prec, "min", 0 );
4768   setPreferenceProperty( prec, "max", 16 );
4769   int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4770   setPreferenceProperty( doubleNodesTol, "precision", 10 );
4771   setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4772   setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4773   setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4774
4775   int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4776   setPreferenceProperty( dispgroup, "columns", 2 );
4777   int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4778   QStringList modes;
4779   modes.append( tr("MEN_WIRE") );
4780   modes.append( tr("MEN_SHADE") );
4781   modes.append( tr("MEN_NODES") );
4782   modes.append( tr("MEN_SHRINK") );
4783   QList<QVariant> indices;
4784   indices.append( 0 );
4785   indices.append( 1 );
4786   indices.append( 2 );
4787   indices.append( 3 );
4788   setPreferenceProperty( dispmode, "strings", modes );
4789   setPreferenceProperty( dispmode, "indexes", indices );
4790
4791   int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4792   setPreferenceProperty( arcgroup, "columns", 2 );
4793   int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4794   QStringList quadraticModes;
4795   quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4796   quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4797   indices.clear();
4798   indices.append( 0 );
4799   indices.append( 1 );
4800   setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4801   setPreferenceProperty( quadraticmode, "indexes", indices );
4802
4803   int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4804                               "SMESH", "max_angle" );
4805   setPreferenceProperty( maxAngle, "min", 1 );
4806   setPreferenceProperty( maxAngle, "max", 90 );
4807
4808
4809
4810   int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4811   setPreferenceProperty( exportgroup, "columns", 2 );
4812   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4813   //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4814
4815   int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4816   setPreferenceProperty( computeGroup, "columns", 2 );
4817   int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4818   modes.clear();
4819   modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4820   modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4821   modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4822   indices.clear();
4823   indices.append( 0 );
4824   indices.append( 1 );
4825   indices.append( 2 );
4826   setPreferenceProperty( notifyMode, "strings", modes );
4827   setPreferenceProperty( notifyMode, "indexes", indices );
4828
4829   int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4830   setPreferenceProperty( infoGroup, "columns", 2 );
4831   int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4832   modes.clear();
4833   modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4834   modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4835   indices.clear();
4836   indices.append( 0 );
4837   indices.append( 1 );
4838   setPreferenceProperty( elemInfo, "strings", modes );
4839   setPreferenceProperty( elemInfo, "indexes", indices );
4840   int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4841   setPreferenceProperty( nodesLim, "min", 0 );
4842   setPreferenceProperty( nodesLim, "max", 10000000 );
4843   setPreferenceProperty( nodesLim, "step", 10000 );
4844   setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4845   int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
4846   setPreferenceProperty( ctrlLim, "min", 0 );
4847   setPreferenceProperty( ctrlLim, "max", 10000000 );
4848   setPreferenceProperty( ctrlLim, "step", 1000 );
4849   addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
4850   addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
4851   addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
4852   addPreference( tr( "PREF_DUMP_ADD_INFO"  ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
4853   addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
4854
4855   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4856   setPreferenceProperty( segGroup, "columns", 2 );
4857   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4858                               "SMESH", "segmentation" );
4859   setPreferenceProperty( segLen, "min", 1 );
4860   setPreferenceProperty( segLen, "max", 10000000 );
4861   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4862                              "SMESH", "nb_segments_per_edge" );
4863   setPreferenceProperty( nbSeg, "min", 1 );
4864   setPreferenceProperty( nbSeg, "max", 10000000 );
4865
4866   int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4867   addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4868                  "SMESH", "forget_mesh_on_hyp_modif" );
4869
4870
4871   // Quantities with individual precision settings
4872   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4873   setPreferenceProperty( precGroup, "columns", 2 );
4874
4875   const int nbQuantities = 6;
4876   int precs[nbQuantities], ii = 0;
4877   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4878                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4879   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4880                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4881   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4882                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4883   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4884                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4885   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4886                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4887   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4888                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4889
4890   // Set property for precision value for spinboxes
4891   for ( ii = 0; ii < nbQuantities; ii++ ){
4892     setPreferenceProperty( precs[ii], "min", -14 );
4893     setPreferenceProperty( precs[ii], "max", 14 );
4894     setPreferenceProperty( precs[ii], "precision", 2 );
4895   }
4896
4897   int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4898   setPreferenceProperty( previewGroup, "columns", 2 );
4899   int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4900   setPreferenceProperty( chunkSize, "min",  1 );
4901   setPreferenceProperty( chunkSize, "max",  1000 );
4902   setPreferenceProperty( chunkSize, "step", 50 );
4903
4904   int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4905   addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4906
4907   // Mesh tab ------------------------------------------------------------------------
4908   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4909   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4910   setPreferenceProperty( nodeGroup, "columns", 3 );
4911
4912   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4913
4914   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4915
4916   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4917   QList<QVariant> aMarkerTypeIndicesList;
4918   QList<QVariant> aMarkerTypeIconsList;
4919   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4920     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4921     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4922     aMarkerTypeIndicesList << i;
4923     aMarkerTypeIconsList << pixmap;
4924   }
4925   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4926   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
4927
4928   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4929
4930   QList<QVariant> aMarkerScaleIndicesList;
4931   QStringList     aMarkerScaleValuesList;
4932   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4933     aMarkerScaleIndicesList << i;
4934     aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4935   }
4936   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4937   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4938
4939   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4940   //setPreferenceProperty( elemGroup, "columns", 2 );
4941
4942   int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4943   setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4944   ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
4945   setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
4946   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4947   addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
4948   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4949   addPreference( tr( "PREF_WIREFRAME"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4950
4951
4952   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4953   setPreferenceProperty( grpGroup, "columns", 2 );
4954
4955   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4956   addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
4957
4958   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4959                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4960   int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
4961                              LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
4962   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
4963                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
4964   int outW  = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
4965                              LightApp_Preferences::IntSpin, "SMESH", "outline_width");
4966   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4967                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4968
4969   setPreferenceProperty( size0d, "min", 1 );
4970   setPreferenceProperty( size0d, "max", 10 );
4971
4972   setPreferenceProperty( ballSize, "min", 1 );
4973   setPreferenceProperty( ballSize, "max", 10 );
4974
4975   setPreferenceProperty( elemW, "min", 1 );
4976   setPreferenceProperty( elemW, "max", 5 );
4977
4978   setPreferenceProperty( outW, "min", 1 );
4979   setPreferenceProperty( outW, "max", 5 );
4980
4981   setPreferenceProperty( shrink, "min", 0 );
4982   setPreferenceProperty( shrink, "max", 100 );
4983
4984   int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
4985   setPreferenceProperty( numGroup, "columns", 2 );
4986
4987   addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
4988   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
4989
4990   addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
4991   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
4992
4993   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4994   setPreferenceProperty( orientGroup, "columns", 1 );
4995
4996   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4997   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4998
4999   setPreferenceProperty( orientScale, "min", 0.05 );
5000   setPreferenceProperty( orientScale, "max", 0.5 );
5001   setPreferenceProperty( orientScale, "step", 0.05 );
5002
5003   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5004
5005   // Selection tab ------------------------------------------------------------------------
5006   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5007
5008   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5009   setPreferenceProperty( selGroup, "columns", 2 );
5010
5011   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5012   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5013
5014   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5015   setPreferenceProperty( preGroup, "columns", 2 );
5016
5017   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5018
5019   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5020   setPreferenceProperty( precSelGroup, "columns", 2 );
5021
5022   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5023   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5024   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5025
5026   // Scalar Bar tab ------------------------------------------------------------------------
5027   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5028   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5029   setPreferenceProperty( fontGr, "columns", 2 );
5030
5031   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5032   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5033
5034   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5035   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5036
5037   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5038   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5039
5040   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5041   setPreferenceProperty( numcol, "min", 2 );
5042   setPreferenceProperty( numcol, "max", 256 );
5043
5044   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5045   setPreferenceProperty( numlab, "min", 2 );
5046   setPreferenceProperty( numlab, "max", 65 );
5047
5048   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5049   setPreferenceProperty( orientGr, "columns", 2 );
5050   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5051   QStringList orients;
5052   orients.append( tr( "SMESH_VERTICAL" ) );
5053   orients.append( tr( "SMESH_HORIZONTAL" ) );
5054   indices.clear(); indices.append( 0 ); indices.append( 1 );
5055   setPreferenceProperty( orient, "strings", orients );
5056   setPreferenceProperty( orient, "indexes", indices );
5057
5058   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5059   setPreferenceProperty( posVSizeGr, "columns", 2 );
5060   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5061   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5062   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5063   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5064   setPreferenceProperty( xv, "step", 0.1 );
5065   setPreferenceProperty( xv, "min", 0.0 );
5066   setPreferenceProperty( xv, "max", 1.0 );
5067   setPreferenceProperty( yv, "step", 0.1 );
5068   setPreferenceProperty( yv, "min", 0.0 );
5069   setPreferenceProperty( yv, "max", 1.0 );
5070   setPreferenceProperty( wv, "step", 0.1 );
5071   setPreferenceProperty( wv, "min", 0.0 );
5072   setPreferenceProperty( wv, "max", 1.0 );
5073   setPreferenceProperty( hv, "min", 0.0 );
5074   setPreferenceProperty( hv, "max", 1.0 );
5075   setPreferenceProperty( hv, "step", 0.1 );
5076
5077   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5078   setPreferenceProperty( posHSizeGr, "columns", 2 );
5079   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5080   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5081   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5082   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5083   setPreferenceProperty( xv, "min", 0.0 );
5084   setPreferenceProperty( xv, "max", 1.0 );
5085   setPreferenceProperty( xv, "step", 0.1 );
5086   setPreferenceProperty( xh, "min", 0.0 );
5087   setPreferenceProperty( xh, "max", 1.0 );
5088   setPreferenceProperty( xh, "step", 0.1 );
5089   setPreferenceProperty( yh, "min", 0.0 );
5090   setPreferenceProperty( yh, "max", 1.0 );
5091   setPreferenceProperty( yh, "step", 0.1 );
5092   setPreferenceProperty( wh, "min", 0.0 );
5093   setPreferenceProperty( wh, "max", 1.0 );
5094   setPreferenceProperty( wh, "step", 0.1 );
5095   setPreferenceProperty( hh, "min", 0.0 );
5096   setPreferenceProperty( hh, "max", 1.0 );
5097   setPreferenceProperty( hh, "step", 0.1 );
5098
5099   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5100   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5101   setPreferenceProperty( distributionGr, "columns", 3 );
5102   QStringList types;
5103   types.append( tr( "SMESH_MONOCOLOR" ) );
5104   types.append( tr( "SMESH_MULTICOLOR" ) );
5105   indices.clear(); indices.append( 0 ); indices.append( 1 );
5106   setPreferenceProperty( coloringType, "strings", types );
5107   setPreferenceProperty( coloringType, "indexes", indices );
5108   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5109
5110 }
5111
5112 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5113 {
5114   if( sect=="SMESH" ) {
5115     float sbX1,sbY1,sbW,sbH;
5116     float aTol = 1.00000009999999;
5117     std::string aWarning;
5118     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5119     if( name=="selection_object_color" || name=="selection_element_color" ||
5120         name=="highlight_color" ||
5121         name=="selection_precision_node" || name=="selection_precision_element" ||
5122         name=="selection_precision_object")
5123       SMESH::UpdateSelectionProp( this );
5124     else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5125       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5126       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5127       if(sbX1+sbW > aTol){
5128         aWarning = "Origin and Size Vertical: X+Width > 1\n";
5129         sbX1=0.01;
5130         sbW=0.08;
5131         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5132         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5133       }
5134     }
5135     else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5136       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5137       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5138       if(sbY1+sbH > aTol){
5139         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5140         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5141         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5142       }
5143     }
5144     else if(name ==  QString("scalar_bar_horizontal_x") || name ==  QString("scalar_bar_horizontal_width")){
5145       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5146       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5147       if(sbX1+sbW > aTol){
5148         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5149         sbX1=0.1;
5150         sbW=0.08;
5151         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5152         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5153       }
5154     }
5155     else if(name ==  QString("scalar_bar_horizontal_y") || name ==  QString("scalar_bar_horizontal_height")){
5156       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5157       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5158       if(sbY1+sbH > aTol){
5159         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5160         sbY1=0.01;
5161         sbH=0.08;
5162         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5163         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5164       }
5165     }
5166     else if ( name == "segmentation" ) {
5167       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5168       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5169     }
5170     else if ( name == "nb_segments_per_edge" ) {
5171       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5172       myComponentSMESH->SetDefaultNbSegments( nbSeg );
5173     }
5174     else if ( name == "historical_python_dump" ||
5175               name == "forget_mesh_on_hyp_modif") {
5176       QString val = aResourceMgr->stringValue( "SMESH", name );
5177       myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5178     }
5179     else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5180       SMESH::UpdateFontProp( this );
5181     }
5182     else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5183       SMESH::UpdateFontProp( this );
5184     }
5185
5186     if(aWarning.size() != 0){
5187       aWarning += "The default values are applied instead.";
5188       SUIT_MessageBox::warning(SMESHGUI::desktop(),
5189                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5190                                QObject::tr(aWarning.c_str()));
5191     }
5192   }
5193 }
5194
5195 //================================================================================
5196 /*!
5197  * \brief Update something in accordance with update flags
5198   * \param theFlags - update flags
5199 *
5200 * Update viewer or/and object browser etc. in accordance with update flags ( see
5201 * LightApp_UpdateFlags enumeration ).
5202 */
5203 //================================================================================
5204 void SMESHGUI::update( const int flags )
5205 {
5206   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5207     SMESH::UpdateView();
5208   else
5209     SalomeApp_Module::update( flags );
5210 }
5211
5212 //================================================================================
5213 /*!
5214  * \brief Set default selection mode
5215 *
5216 * SLOT called when operation commited. Sets default selection mode
5217 */
5218 //================================================================================
5219 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5220 {
5221   SVTK_ViewWindow* vtkWnd =
5222     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5223   if ( vtkWnd )
5224     vtkWnd->SetSelectionMode( ActorSelection );
5225 }
5226
5227 //================================================================================
5228 /*!
5229  * \brief Set default selection mode
5230 *
5231 * SLOT called when operation aborted. Sets default selection mode
5232 */
5233 //================================================================================
5234 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5235 {
5236   SVTK_ViewWindow* vtkWnd =
5237     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5238   if ( vtkWnd )
5239     vtkWnd->SetSelectionMode( ActorSelection );
5240 }
5241
5242 //================================================================================
5243 /*!
5244  * \brief Creates operation with given identifier
5245   * \param id - identifier of operation to be started
5246   * \return Pointer on created operation or NULL if operation is not created
5247 *
5248 * Virtual method redefined from the base class creates operation with given id.
5249 * It is called called automatically from startOperation method of base class.
5250 */
5251 //================================================================================
5252 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5253 {
5254   LightApp_Operation* op = 0;
5255   // to do : create operation here
5256   switch( id )
5257   {
5258     case 417: //convert to quadratic
5259       op = new SMESHGUI_ConvToQuadOp();
5260     break;
5261     case 418: // create 2D mesh as boundary on 3D
5262       op = new SMESHGUI_Make2DFrom3DOp();
5263     break;
5264     case 420: // Reorient faces
5265       op = new SMESHGUI_ReorientFacesOp();
5266       break;
5267     case 701: // Compute mesh
5268       op = new SMESHGUI_ComputeOp();
5269     break;
5270     case 702: // Create mesh
5271       op = new SMESHGUI_MeshOp( true, true );
5272     break;
5273     case 703: // Create sub-mesh
5274       op = new SMESHGUI_MeshOp( true, false );
5275     break;
5276     case 704: // Edit mesh/sub-mesh
5277       op = new SMESHGUI_MeshOp( false );
5278     break;
5279     case 711: // Precompute mesh
5280       op = new SMESHGUI_PrecomputeOp();
5281     break;
5282     case 712: // Evaluate mesh
5283       op = new SMESHGUI_EvaluateOp();
5284     break;
5285     case 713: // Evaluate mesh
5286       op = new SMESHGUI_MeshOrderOp();
5287     break;
5288     case 806: // Create group on geom
5289       op = new SMESHGUI_GroupOnShapeOp();
5290       break;
5291     case 904: // Find element
5292       op = new SMESHGUI_FindElemByPointOp();
5293       break;
5294     case 4067: // Make mesh pass through point
5295       op = new SMESHGUI_MakeNodeAtPointOp();
5296       break;
5297     case 4070: // Create 0D elements on all nodes
5298       op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5299       break;
5300     default:
5301     break;
5302   }
5303
5304   if( !op )
5305     op = SalomeApp_Module::createOperation( id );
5306   return op;
5307 }
5308
5309 //================================================================================
5310 /*!
5311  * \brief Stops current operations and starts a given one
5312   * \param id - The id of the operation to start
5313  */
5314 //================================================================================
5315
5316 void SMESHGUI::switchToOperation(int id)
5317 {
5318   if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5319     activeStudy()->abortAllOperations();
5320   startOperation( id );
5321 }
5322
5323 LightApp_Displayer* SMESHGUI::displayer()
5324 {
5325   if( !myDisplayer )
5326     myDisplayer = new SMESHGUI_Displayer( getApp() );
5327   return myDisplayer;
5328 }
5329
5330 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5331 {
5332   int aHue = -1;
5333   int aTolerance = 64;
5334   int anIterations = 0;
5335   int aPeriod = 5;
5336
5337   while( 1 )
5338   {
5339     anIterations++;
5340     if( anIterations % aPeriod == 0 )
5341     {
5342       aTolerance /= 2;
5343       if( aTolerance < 1 )
5344         break;
5345     }
5346
5347     aHue = (int)( 360.0 * rand() / RAND_MAX );
5348
5349     bool ok = true;
5350     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5351     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5352     for( ; it != itEnd; ++it )
5353     {
5354       SALOMEDS::Color anAutoColor = *it;
5355       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5356
5357       int h, s, v;
5358       aQColor.getHsv( &h, &s, &v );
5359       if( abs( h - aHue ) < aTolerance )
5360       {
5361         ok = false;
5362         break;
5363       }
5364     }
5365
5366     if( ok )
5367       break;
5368   }
5369
5370   QColor aColor;
5371   aColor.setHsv( aHue, 255, 255 );
5372
5373   SALOMEDS::Color aSColor;
5374   aSColor.R = aColor.redF();
5375   aSColor.G = aColor.greenF();
5376   aSColor.B = aColor.blueF();
5377
5378   return aSColor;
5379 }
5380
5381 const char* gSeparator = "_"; // character used to separate parameter names
5382 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5383 const char* gPathSep   = "|"; // character used to separate paths
5384
5385 /*!
5386  * \brief Store visual parameters
5387  *
5388  * This method is called just before the study document is saved.
5389  * Store visual parameters in AttributeParameter attribue(s)
5390  */
5391 void SMESHGUI::storeVisualParameters (int savePoint)
5392 {
5393   // localizing
5394   Kernel_Utils::Localizer loc;
5395
5396   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5397   if (!appStudy || !appStudy->studyDS())
5398     return;
5399   _PTR(Study) studyDS = appStudy->studyDS();
5400
5401   // componentName is used for encoding of entries when storing them in IParameters
5402   std::string componentName = myComponentSMESH->ComponentDataType();
5403   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5404   //if (!aSComponent) return;
5405
5406   // IParameters
5407   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5408                                                              componentName.c_str(),
5409                                                              savePoint);
5410   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5411
5412   // store map of custom markers
5413   const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5414   if( !aMarkerMap.empty() )
5415   {
5416     VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5417     for( ; anIter != aMarkerMap.end(); anIter++ )
5418     {
5419       int anId = anIter->first;
5420       VTK::MarkerData aMarkerData = anIter->second;
5421       std::string aMarkerFileName = aMarkerData.first;
5422       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5423       if( aMarkerTexture.size() < 3 )
5424         continue; // should contain at least width, height and the first value
5425
5426       QString aPropertyName( "texture" );
5427       aPropertyName += gSeparator;
5428       aPropertyName += QString::number( anId );
5429
5430       QString aPropertyValue = aMarkerFileName.c_str();
5431       aPropertyValue += gPathSep;
5432
5433       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5434       ushort aWidth = *aTextureIter++;
5435       ushort aHeight = *aTextureIter++;
5436       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5437       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5438       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5439         aPropertyValue += QString::number( *aTextureIter );
5440
5441       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5442     }
5443   }
5444
5445   // viewers counters are used for storing view_numbers in IParameters
5446   int vtkViewers = 0;
5447
5448   // main cycle to store parameters of displayed objects
5449   QList<SUIT_ViewManager*> lst;
5450   QList<SUIT_ViewManager*>::Iterator it;
5451   getApp()->viewManagers(lst);
5452   for (it = lst.begin(); it != lst.end(); it++)
5453   {
5454     SUIT_ViewManager* vman = *it;
5455     QString vType = vman->getType();
5456
5457     // saving VTK actors properties
5458     if (vType == SVTK_Viewer::Type())
5459     {
5460       // store the clipping planes attached to the view manager
5461       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5462       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5463       if( anIter != myClippingPlaneInfoMap.end() )
5464         aClippingPlaneInfoList = anIter->second;
5465
5466       if( !aClippingPlaneInfoList.empty() ) {
5467         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5468         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5469         {
5470           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5471           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5472
5473           QString aPropertyName( "ClippingPlane" );
5474           aPropertyName += gSeparator;
5475           aPropertyName += QString::number( vtkViewers );
5476           aPropertyName += gSeparator;
5477           aPropertyName += QString::number( anId );
5478
5479           QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5480           aPropertyValue += gDigitsSep;
5481           aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5482           aPropertyValue += gDigitsSep;
5483           aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5484           aPropertyValue += gDigitsSep;
5485           aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5486
5487           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5488         }
5489       }
5490
5491       QVector<SUIT_ViewWindow*> views = vman->getViews();
5492       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5493       {
5494         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5495         {
5496           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5497           vtkActorCollection* allActors = aCopy.GetActors();
5498           allActors->InitTraversal();
5499           while (vtkActor* actor = allActors->GetNextActor())
5500           {
5501             if (actor->GetVisibility()) // store only visible actors
5502             {
5503               SMESH_Actor* aSmeshActor = 0;
5504               if (actor->IsA("SMESH_Actor"))
5505                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5506               if (aSmeshActor && aSmeshActor->hasIO())
5507               {
5508                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5509                 if (io->hasEntry())
5510                 {
5511                   // entry is "encoded" = it does NOT contain component adress,
5512                   // since it is a subject to change on next component loading
5513                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5514
5515                   std::string param, vtkParam = vType.toLatin1().data();
5516                   vtkParam += gSeparator;
5517                   vtkParam += QString::number(vtkViewers).toLatin1().data();
5518                   vtkParam += gSeparator;
5519
5520                   // Visibility
5521                   param = vtkParam + "Visibility";
5522                   ip->setParameter(entry, param, "On");
5523
5524                   // Representation
5525                   param = vtkParam + "Representation";
5526                   ip->setParameter(entry, param, QString::number
5527                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5528
5529                   // IsShrunk
5530                   param = vtkParam + "IsShrunk";
5531                   ip->setParameter(entry, param, QString::number
5532                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5533
5534                   // Displayed entities
5535                   unsigned int aMode = aSmeshActor->GetEntityMode();
5536                   bool isE  = aMode & SMESH_Actor::eEdges;
5537                   bool isF  = aMode & SMESH_Actor::eFaces;
5538                   bool isV  = aMode & SMESH_Actor::eVolumes;
5539                   bool is0d = aMode & SMESH_Actor::e0DElements;
5540                   bool isB  = aMode & SMESH_Actor::eBallElem;
5541
5542                   QString modeStr ("e");
5543                   modeStr += gDigitsSep; modeStr += QString::number(isE);
5544                   modeStr += gDigitsSep; modeStr += "f";
5545                   modeStr += gDigitsSep; modeStr += QString::number(isF);
5546                   modeStr += gDigitsSep; modeStr += "v";
5547                   modeStr += gDigitsSep; modeStr += QString::number(isV);
5548                   modeStr += gDigitsSep; modeStr += "0d";
5549                   modeStr += gDigitsSep; modeStr += QString::number(is0d);
5550                   modeStr += gDigitsSep; modeStr += "b";
5551                   modeStr += gDigitsSep; modeStr += QString::number(isB);
5552
5553                   param = vtkParam + "Entities";
5554                   ip->setParameter(entry, param, modeStr.toLatin1().data());
5555
5556                   // Colors
5557                   double r, g, b;
5558                   int delta;
5559
5560                   aSmeshActor->GetSufaceColor(r, g, b, delta);
5561                   QStringList colorStr;
5562                   colorStr << "surface";
5563                   colorStr << QString::number(r);
5564                   colorStr << QString::number(g);
5565                   colorStr << QString::number(b);
5566
5567                   colorStr << "backsurface";
5568                   colorStr << QString::number(delta);
5569
5570                   aSmeshActor->GetVolumeColor(r, g, b, delta);
5571                   colorStr << "volume";
5572                   colorStr << QString::number(r);
5573                   colorStr << QString::number(g);
5574                   colorStr << QString::number(b);
5575                   colorStr << QString::number(delta);
5576
5577                   aSmeshActor->GetEdgeColor(r, g, b);
5578                   colorStr << "edge";
5579                   colorStr << QString::number(r);
5580                   colorStr << QString::number(g);
5581                   colorStr << QString::number(b);
5582
5583                   aSmeshActor->GetNodeColor(r, g, b);
5584                   colorStr << "node";
5585                   colorStr << QString::number(r);
5586                   colorStr << QString::number(g);
5587                   colorStr << QString::number(b);
5588
5589                   aSmeshActor->GetOutlineColor(r, g, b);
5590                   colorStr << "outline";
5591                   colorStr << QString::number(r);
5592                   colorStr << QString::number(g);
5593                   colorStr << QString::number(b);
5594
5595                   aSmeshActor->Get0DColor(r, g, b);
5596                   colorStr << "elem0d";
5597                   colorStr << QString::number(r);
5598                   colorStr << QString::number(g);
5599                   colorStr << QString::number(b);
5600
5601                   aSmeshActor->GetBallColor(r, g, b);
5602                   colorStr << "ball";
5603                   colorStr << QString::number(r);
5604                   colorStr << QString::number(g);
5605                   colorStr << QString::number(b);
5606
5607                   aSmeshActor->GetFacesOrientationColor(r, g, b);
5608                   colorStr << "orientation";
5609                   colorStr << QString::number(r);
5610                   colorStr << QString::number(g);
5611                   colorStr << QString::number(b);
5612
5613                   param = vtkParam + "Colors";
5614                   ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5615
5616                   // Sizes
5617                   QStringList sizeStr;
5618                   sizeStr << "line";
5619                   sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5620                   sizeStr << "outline";
5621                   sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5622                   sizeStr << "elem0d";
5623                   sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5624                   sizeStr << "ball";
5625                   sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5626                   sizeStr << "shrink";
5627                   sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5628                   sizeStr << "orientation";
5629                   sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5630                   sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5631
5632                   param = vtkParam + "Sizes";
5633                   ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5634
5635                   // Point marker
5636                   QString markerStr;
5637
5638                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5639                   if( aMarkerType == VTK::MT_USER ) {
5640                     markerStr += "custom";
5641                     markerStr += gDigitsSep;
5642                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5643                   }
5644                   else {
5645                     markerStr += "std";
5646                     markerStr += gDigitsSep;
5647                     markerStr += QString::number( (int)aMarkerType );
5648                     markerStr += gDigitsSep;
5649                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5650                   }
5651
5652                   param = vtkParam + "PointMarker";
5653                   ip->setParameter(entry, param, markerStr.toLatin1().data());
5654
5655                   // Opacity
5656                   param = vtkParam + "Opacity";
5657                   ip->setParameter(entry, param,
5658                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5659
5660                   // Clipping
5661                   param = vtkParam + "ClippingPlane";
5662                   int aPlaneId = 0;
5663                   if( !aClippingPlaneInfoList.empty() ) {
5664                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5665                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5666                     {
5667                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5668                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5669                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
5670                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5671                         if( aSmeshActor == *anIter2 ) {
5672                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5673                                             QString::number( anId ).toLatin1().constData() );
5674                           break;
5675                         }
5676                       }
5677                     }
5678                   }
5679                   if( aPlaneId == 0 )
5680                     ip->setParameter( entry, param, "Off" );
5681                 } // if (io->hasEntry())
5682               } // SMESH_Actor && hasIO
5683             } // isVisible
5684           } // while.. actors traversal
5685         } // if (vtkView)
5686       } // for (views)
5687       vtkViewers++;
5688     } // if (SVTK view model)
5689   } // for (viewManagers)
5690 }
5691
5692 // data structures for clipping planes processing
5693 typedef struct {
5694   int Id;
5695   vtkIdType Orientation;
5696   double Distance;
5697   double Angle[2];
5698 } TPlaneData;
5699 typedef std::list<TPlaneData>         TPlaneDataList;
5700 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5701
5702 typedef std::list<vtkActor*>          TActorList;
5703 typedef struct {
5704   int PlaneId;
5705   TActorList ActorList;
5706   SUIT_ViewManager* ViewManager;
5707 } TPlaneInfo;
5708 typedef std::list<TPlaneInfo>         TPlaneInfoList;
5709 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5710
5711 /*!
5712  * \brief Restore visual parameters
5713  *
5714  * This method is called after the study document is opened.
5715  * Restore visual parameters from AttributeParameter attribue(s)
5716  */
5717 void SMESHGUI::restoreVisualParameters (int savePoint)
5718 {
5719   // localizing
5720   Kernel_Utils::Localizer loc;
5721
5722   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5723   if (!appStudy || !appStudy->studyDS())
5724     return;
5725   _PTR(Study) studyDS = appStudy->studyDS();
5726
5727   // componentName is used for encoding of entries when storing them in IParameters
5728   std::string componentName = myComponentSMESH->ComponentDataType();
5729   //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5730   //if (!aSComponent) return;
5731
5732   // IParameters
5733   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5734                                                              componentName.c_str(),
5735                                                              savePoint);
5736   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5737
5738   // restore map of custom markers and map of clipping planes
5739   VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5740   TPlaneDataMap aPlaneDataMap;
5741
5742   std::vector<std::string> properties = ip->getProperties();
5743   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5744   {
5745     std::string property = *propIt;
5746     QString aPropertyName( property.c_str() );
5747     QString aPropertyValue( ip->getProperty( property ).c_str() );
5748
5749     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5750     if( aPropertyNameList.isEmpty() )
5751       continue;
5752
5753     QString aPropertyType = aPropertyNameList[0];
5754     if( aPropertyType == "texture" )
5755     {
5756       if( aPropertyNameList.size() != 2 )
5757         continue;
5758
5759       bool ok = false;
5760       int anId = aPropertyNameList[1].toInt( &ok );
5761       if( !ok || anId < 1 )
5762         continue;
5763
5764       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5765       if( aPropertyValueList.size() != 2 )
5766         continue;
5767
5768       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5769       QString aMarkerTextureString = aPropertyValueList[1];
5770       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5771       if( aMarkerTextureStringList.size() != 3 )
5772         continue;
5773
5774       ok = false;
5775       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5776       if( !ok )
5777         continue;
5778
5779       ok = false;
5780       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5781       if( !ok )
5782         continue;
5783
5784       VTK::MarkerTexture aMarkerTexture;
5785       aMarkerTexture.push_back( aWidth );
5786       aMarkerTexture.push_back( aHeight );
5787
5788       QString aMarkerTextureData = aMarkerTextureStringList[2];
5789       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5790       {
5791         QChar aChar = aMarkerTextureData.at( i );
5792         if( aChar.isDigit() )
5793           aMarkerTexture.push_back( aChar.digitValue() );
5794       }
5795
5796       aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5797     }
5798     else if( aPropertyType == "ClippingPlane" )
5799     {
5800       if( aPropertyNameList.size() != 3 )
5801         continue;
5802
5803       bool ok = false;
5804       int aViewId = aPropertyNameList[1].toInt( &ok );
5805       if( !ok || aViewId < 0 )
5806         continue;
5807
5808       ok = false;
5809       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5810       if( !ok || aClippingPlaneId < 0 )
5811         continue;
5812
5813       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5814       if( aPropertyValueList.size() != 4 )
5815         continue;
5816
5817       TPlaneData aPlaneData;
5818       aPlaneData.Id = aClippingPlaneId;
5819
5820       ok = false;
5821       aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5822       if( !ok )
5823         continue;
5824
5825       ok = false;
5826       aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5827       if( !ok )
5828         continue;
5829
5830       ok = false;
5831       aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5832       if( !ok )
5833         continue;
5834
5835       ok = false;
5836       aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5837       if( !ok )
5838         continue;
5839
5840       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5841       aPlaneDataList.push_back( aPlaneData );
5842     }
5843   }
5844
5845   TPlaneInfoMap aPlaneInfoMap;
5846
5847   std::vector<std::string> entries = ip->getEntries();
5848
5849   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5850   {
5851     // entry is a normal entry - it should be "decoded" (setting base adress of component)
5852     QString entry (ip->decodeEntry(*entIt).c_str());
5853
5854     // Check that the entry corresponds to a real object in the Study
5855     // as the object may be deleted or modified after the visual state is saved.
5856     _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5857     if (!so) continue; //Skip the not existent entry
5858
5859     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5860     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5861
5862     std::vector<std::string>::iterator namesIt = paramNames.begin();
5863     std::vector<std::string>::iterator valuesIt = paramValues.begin();
5864
5865     // actors are stored in a map after displaying of them for
5866     // quicker access in the future: map < viewID to actor >
5867     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5868
5869     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5870     {
5871       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5872       // '_' is used as separator and should not be used in viewer type or parameter names.
5873       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5874       if (lst.size() != 3)
5875         continue;
5876
5877       QString viewerTypStr = lst[0];
5878       QString viewIndexStr = lst[1];
5879       QString paramNameStr = lst[2];
5880
5881       bool ok;
5882       int viewIndex = viewIndexStr.toUInt(&ok);
5883       if (!ok) // bad conversion of view index to integer
5884         continue;
5885
5886       // viewers
5887       if (viewerTypStr == SVTK_Viewer::Type())
5888       {
5889         SMESH_Actor* aSmeshActor = 0;
5890         if (vtkActors.IsBound(viewIndex))
5891           aSmeshActor = vtkActors.Find(viewIndex);
5892
5893         QList<SUIT_ViewManager*> lst;
5894         getApp()->viewManagers(viewerTypStr, lst);
5895
5896         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5897         SUIT_ViewManager* vman = NULL;
5898         if (viewIndex >= 0 && viewIndex < lst.count())
5899           vman = lst.at(viewIndex);
5900
5901         if (paramNameStr == "Visibility")
5902         {
5903           if (!aSmeshActor && displayer() && vman)
5904           {
5905             SUIT_ViewModel* vmodel = vman->getViewModel();
5906             // SVTK view model can be casted to SALOME_View
5907             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5908
5909             // store displayed actor in a temporary map for quicker
5910             // access later when restoring other parameters
5911             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5912             vtkRenderer* Renderer = vtkView->getRenderer();
5913             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5914             vtkActorCollection* theActors = aCopy.GetActors();
5915             theActors->InitTraversal();
5916             bool isFound = false;
5917             vtkActor *ac = theActors->GetNextActor();
5918             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5919               if (ac->IsA("SMESH_Actor")) {
5920                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5921                 if (aGeomAc->hasIO()) {
5922                   Handle(SALOME_InteractiveObject) io =
5923                     Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5924                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5925                     isFound = true;
5926                     vtkActors.Bind(viewIndex, aGeomAc);
5927                   }
5928                 }
5929               }
5930             }
5931           }
5932         } // if (paramNameStr == "Visibility")
5933         else
5934         {
5935           // the rest properties "work" with SMESH_Actor
5936           if (aSmeshActor)
5937           {
5938             QString val ((*valuesIt).c_str());
5939
5940             // Representation
5941             if (paramNameStr == "Representation") {
5942               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5943             }
5944             // IsShrunk
5945             else if (paramNameStr == "IsShrunk") {
5946               if (val.toInt()) {
5947                 if (!aSmeshActor->IsShrunk())
5948                   aSmeshActor->SetShrink();
5949               }
5950               else {
5951                 if (aSmeshActor->IsShrunk())
5952                   aSmeshActor->UnShrink();
5953               }
5954             }
5955             // Displayed entities
5956             else if (paramNameStr == "Entities") {
5957               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5958               int aEntityMode = SMESH_Actor::eAllEntity;
5959               for ( int i = 0; i < mode.count(); i+=2 ) {
5960                 if ( i < mode.count()-1 ) {
5961                   QString type = mode[i];
5962                   bool val = mode[i+1].toInt();
5963                   if      ( type == "e" && !val )
5964                     aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
5965                   else if ( type == "f" && !val )
5966                     aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
5967                   else if ( type == "v" && !val )
5968                     aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
5969                   else if ( type == "0d" && !val )
5970                     aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
5971                   else if ( type == "b" && !val )
5972                     aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
5973                 }
5974               }
5975               aSmeshActor->SetEntityMode( aEntityMode );
5976             }
5977             // Colors
5978             else if (paramNameStr == "Colors") {
5979               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5980               QColor nodeColor;
5981               QColor edgeColor;
5982               QColor faceColor;
5983               QColor volumeColor;
5984               QColor elem0dColor;
5985               QColor ballColor;
5986               QColor outlineColor;
5987               QColor orientationColor;
5988               int deltaF;
5989               int deltaV;
5990               QColor c;
5991               double r, g, b;
5992               bool bOk;
5993               // below lines are required to get default values for delta coefficients
5994               // of backface color for faces and color of reversed volumes
5995               SMESH::GetColor( "SMESH", "fill_color",   c, deltaF, "0,170,255|-100" );
5996               SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
5997               for ( int i = 0; i < colors.count(); i++ ) {
5998                 QString type = colors[i];
5999                 if ( type == "surface" ) {
6000                   // face color is set by 3 values r:g:b, where
6001                   // - r,g,b - is rgb color components
6002                   if ( i+1 >= colors.count() ) break;                  // format error
6003                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6004                   if ( i+2 >= colors.count() ) break;                  // format error
6005                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6006                   if ( i+3 >= colors.count() ) break;                  // format error
6007                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6008                   faceColor.setRgbF( r, g, b );
6009                   i += 3;
6010                 }
6011                 else if ( type == "backsurface" ) {
6012                   // backface color can be defined in several ways
6013                   // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6014                   // - in latest versions, it is set as delta coefficient
6015                   bool rgbOk = false, deltaOk;
6016                   if ( i+1 >= colors.count() ) break;                  // format error
6017                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6018                   int delta = colors[i+1].toInt( &deltaOk );
6019                   i++;                                 // shift index
6020                   if ( i+1 < colors.count() )          // index is shifted to 1
6021                     g = colors[i+1].toDouble( &rgbOk );
6022                   if ( rgbOk ) i++;                    // shift index
6023                   if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6024                     b = colors[i+1].toDouble( &rgbOk );
6025                   if ( rgbOk ) i++;
6026                   // - as currently there's no way to set directly backsurface color as it was before,
6027                   // we ignore old dump where r,g,b triple was set
6028                   // - also we check that delta parameter is set properly
6029                   if ( !rgbOk && deltaOk )
6030                     deltaF = delta;
6031                 }
6032                 else if ( type == "volume" ) {
6033                   // volume color is set by 4 values r:g:b:delta, where
6034                   // - r,g,b - is a normal volume rgb color components
6035                   // - delta - is a reversed volume color delta coefficient
6036                   if ( i+1 >= colors.count() ) break;                  // format error
6037                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6038                   if ( i+2 >= colors.count() ) break;                  // format error
6039                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6040                   if ( i+3 >= colors.count() ) break;                  // format error
6041                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6042                   if ( i+4 >= colors.count() ) break;                  // format error
6043                   int delta = colors[i+4].toInt( &bOk );
6044                   if ( !bOk ) break;                                   // format error
6045                   volumeColor.setRgbF( r, g, b );
6046                   deltaV = delta;
6047                   i += 4;
6048                 }
6049                 else if ( type == "edge" ) {
6050                   // edge color is set by 3 values r:g:b, where
6051                   // - r,g,b - is rgb color components
6052                   if ( i+1 >= colors.count() ) break;                  // format error
6053                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6054                   if ( i+2 >= colors.count() ) break;                  // format error
6055                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6056                   if ( i+3 >= colors.count() ) break;                  // format error
6057                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6058                   edgeColor.setRgbF( r, g, b );
6059                   i += 3;
6060                 }
6061                 else if ( type == "node" ) {
6062                   // node color is set by 3 values r:g:b, where
6063                   // - r,g,b - is rgb color components
6064                   if ( i+1 >= colors.count() ) break;                  // format error
6065                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6066                   if ( i+2 >= colors.count() ) break;                  // format error
6067                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6068                   if ( i+3 >= colors.count() ) break;                  // format error
6069                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6070                   nodeColor.setRgbF( r, g, b );
6071                   i += 3;
6072                 }
6073                 else if ( type == "elem0d" ) {
6074                   // 0d element color is set by 3 values r:g:b, where
6075                   // - r,g,b - is rgb color components
6076                   if ( i+1 >= colors.count() ) break;                  // format error
6077                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6078                   if ( i+2 >= colors.count() ) break;                  // format error
6079                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6080                   if ( i+3 >= colors.count() ) break;                  // format error
6081                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6082                   elem0dColor.setRgbF( r, g, b );
6083                   i += 3;
6084                 }
6085                 else if ( type == "ball" ) {
6086                   // ball color is set by 3 values r:g:b, where
6087                   // - r,g,b - is rgb color components
6088                   if ( i+1 >= colors.count() ) break;                  // format error
6089                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6090                   if ( i+2 >= colors.count() ) break;                  // format error
6091                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6092                   if ( i+3 >= colors.count() ) break;                  // format error
6093                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6094                   ballColor.setRgbF( r, g, b );
6095                   i += 3;
6096                 }
6097                 else if ( type == "outline" ) {
6098                   // outline color is set by 3 values r:g:b, where
6099                   // - r,g,b - is rgb color components
6100                   if ( i+1 >= colors.count() ) break;                  // format error
6101                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6102                   if ( i+2 >= colors.count() ) break;                  // format error
6103                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6104                   if ( i+3 >= colors.count() ) break;                  // format error
6105                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6106                   outlineColor.setRgbF( r, g, b );
6107                   i += 3;
6108                 }
6109                 else if ( type == "orientation" ) {
6110                   // orientation color is set by 3 values r:g:b, where
6111                   // - r,g,b - is rgb color components
6112                   if ( i+1 >= colors.count() ) break;                  // format error
6113                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6114                   if ( i+2 >= colors.count() ) break;                  // format error
6115                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6116                   if ( i+3 >= colors.count() ) break;                  // format error
6117                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6118                   orientationColor.setRgbF( r, g, b );
6119                   i += 3;
6120                 }
6121               }
6122               // node color
6123               if ( nodeColor.isValid() )
6124                 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6125               // edge color
6126               if ( edgeColor.isValid() )
6127                 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6128               // face color
6129               if ( faceColor.isValid() )
6130                 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6131               // volume color
6132               if ( volumeColor.isValid() )
6133                 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6134               else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6135                 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6136               // 0d element color
6137               if ( elem0dColor.isValid() )
6138                 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6139               // ball color
6140               if ( ballColor.isValid() )
6141                 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6142               // outline color
6143               if ( outlineColor.isValid() )
6144                 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6145               // orientation color
6146               if ( orientationColor.isValid() )
6147                 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6148             }
6149             // Sizes
6150             else if (paramNameStr == "Sizes") {
6151               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6152               bool bOk;
6153               int lineWidth = -1;
6154               int outlineWidth = -1;
6155               int elem0dSize = -1;
6156               int ballSize = -1;
6157               double shrinkSize = -1;
6158               double orientationSize = -1;
6159               bool orientation3d = false;
6160               for ( int i = 0; i < sizes.count(); i++ ) {
6161                 QString type = sizes[i];
6162                 if ( type == "line" ) {
6163                   // line (wireframe) width is given as single integer value
6164                   if ( i+1 >= sizes.count() ) break;                    // format error
6165                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6166                   lineWidth = v;
6167                   i++;
6168                 }
6169                 if ( type == "outline" ) {
6170                   // outline width is given as single integer value
6171                   if ( i+1 >= sizes.count() ) break;                    // format error
6172                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6173                   outlineWidth = v;
6174                   i++;
6175                 }
6176                 else if ( type == "elem0d" ) {
6177                   // 0d element size is given as single integer value
6178                   if ( i+1 >= sizes.count() ) break;                    // format error
6179                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6180                   elem0dSize = v;
6181                   i++;
6182                 }
6183                 else if ( type == "ball" ) {
6184                   // ball size is given as single integer value
6185                   if ( i+1 >= sizes.count() ) break;                    // format error
6186                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6187                   ballSize = v;
6188                   i++;
6189                 }
6190                 else if ( type == "shrink" ) {
6191                   // shrink factor is given as single floating point value
6192                   if ( i+1 >= sizes.count() ) break;                          // format error
6193                   double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break;  // format error
6194                   shrinkSize = v;
6195                   i++;
6196                 }
6197                 else if ( type == "orientation" ) {
6198                   // orientation vectors are specified by two values size:3d, where
6199                   // - size - is a floating point value specifying scale factor
6200                   // - 3d - is a boolean
6201                   if ( i+1 >= sizes.count() ) break;                          // format error
6202                   double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6203                   if ( i+2 >= sizes.count() ) break;                          // format error
6204                   int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break;       // format error
6205                   orientationSize = v1;
6206                   orientation3d = (bool)v2;
6207                   i += 2;
6208                 }
6209               }
6210               // line (wireframe) width
6211               if ( lineWidth > 0 )
6212                 aSmeshActor->SetLineWidth( lineWidth );
6213               // outline width
6214               if ( outlineWidth > 0 )
6215                 aSmeshActor->SetOutlineWidth( outlineWidth );
6216               else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6217                 aSmeshActor->SetOutlineWidth( lineWidth );
6218               // 0d element size
6219               if ( elem0dSize > 0 )
6220                 aSmeshActor->Set0DSize( elem0dSize );
6221               // ball size
6222               if ( ballSize > 0 )
6223                 aSmeshActor->SetBallSize( ballSize );
6224               // shrink factor
6225               if ( shrinkSize > 0 )
6226                 aSmeshActor->SetShrinkFactor( shrinkSize );
6227               // orientation vectors
6228               if ( orientationSize > 0 ) {
6229                 aSmeshActor->SetFacesOrientationScale( orientationSize );
6230                 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6231               }
6232             }
6233             // Point marker
6234             else if (paramNameStr == "PointMarker") {
6235               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6236               if( data.count() >= 2 ) {
6237                 bool ok = false;
6238                 int aParam1 = data[1].toInt( &ok );
6239                 if( ok ) {
6240                   if( data[0] == "std" && data.count() == 3 ) {
6241                     int aParam2 = data[2].toInt( &ok );
6242                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6243                   }
6244                   else if( data[0] == "custom" ) {
6245                     VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6246                     if( markerIt != aMarkerMap.end() ) {
6247                       VTK::MarkerData aMarkerData = markerIt->second;
6248                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6249                     }
6250                   }
6251                 }
6252               }
6253             }
6254             // Opacity
6255             else if (paramNameStr == "Opacity") {
6256               aSmeshActor->SetOpacity(val.toFloat());
6257             }
6258             // Clipping
6259             else if (paramNameStr.startsWith("ClippingPlane")) {
6260               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6261               // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
6262               // new format - val looks like "Off" or "0" (plane id)
6263               // (note: in new format "Off" value is used only for consistency,
6264               //  so it is processed together with values in old format)
6265               bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
6266               if( anIsOldFormat ) {
6267                 if (paramNameStr == "ClippingPlane1" || val == "Off")
6268                   aSmeshActor->RemoveAllClippingPlanes();
6269                 if (val != "Off") {
6270                   SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
6271                   double aDistance = vals[1].toFloat();
6272                   double anAngle[2];
6273                   anAngle[0] = vals[2].toFloat();
6274                   anAngle[1] = vals[3].toFloat();
6275
6276                   QList<SUIT_ViewManager*> lst;
6277                   getApp()->viewManagers(viewerTypStr, lst);
6278                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6279                   if (viewIndex >= 0 && viewIndex < lst.count()) {
6280                     SUIT_ViewManager* vman = lst.at(viewIndex);
6281                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6282
6283                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6284
6285                     SMESH::TActorList anActorList;
6286                     anActorList.push_back( aSmeshActor );
6287                     SMESH::OrientedPlane* aPlane =
6288                       SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
6289                     if( aPlane ) {
6290                       SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6291                       aClippingPlaneInfo.Plane = aPlane;
6292                       aClippingPlaneInfo.ActorList = anActorList;
6293                       aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6294                     }
6295                   }
6296                 }
6297               }
6298               else {
6299                 bool ok = false;
6300                 int aPlaneId = val.toInt( &ok );
6301                 if( ok && aPlaneId >= 0 ) {
6302                   bool anIsDefinedPlane = false;
6303                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6304                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6305                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6306                     TPlaneInfo& aPlaneInfo = *anIter;
6307                     if( aPlaneInfo.PlaneId == aPlaneId ) {
6308                       aPlaneInfo.ActorList.push_back( aSmeshActor );
6309                       anIsDefinedPlane = true;
6310                       break;
6311                     }
6312                   }
6313                   if( !anIsDefinedPlane ) {
6314                     TPlaneInfo aPlaneInfo;
6315                     aPlaneInfo.PlaneId = aPlaneId;
6316                     aPlaneInfo.ActorList.push_back( aSmeshActor );
6317                     aPlaneInfo.ViewManager = vman;
6318
6319                     // to make the list sorted by plane id
6320                     anIter = aPlaneInfoList.begin();
6321                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6322                       const TPlaneInfo& aPlaneInfoRef = *anIter;
6323                       if( aPlaneInfoRef.PlaneId > aPlaneId )
6324                         break;
6325                     }
6326                     aPlaneInfoList.insert( anIter, aPlaneInfo );
6327                   }
6328                 }
6329               }
6330             }
6331           } // if (aSmeshActor)
6332         } // other parameters than Visibility
6333       }
6334     } // for names/parameters iterator
6335   } // for entries iterator
6336
6337   // take into account planes with empty list of actors referred to them
6338   QList<SUIT_ViewManager*> aVMList;
6339   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6340
6341   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6342   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6343     int aViewId = aPlaneDataIter->first;
6344     if( aViewId >= 0 && aViewId < aVMList.count() ) {
6345       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6346
6347       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6348
6349       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6350       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6351       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6352         const TPlaneData& aPlaneData = *anIter2;
6353         int aPlaneId = aPlaneData.Id;
6354
6355         bool anIsFound = false;
6356         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6357         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6358           const TPlaneInfo& aPlaneInfo = *anIter3;
6359           if( aPlaneInfo.PlaneId == aPlaneId ) {
6360             anIsFound = true;
6361             break;
6362           }
6363         }
6364
6365         if( !anIsFound ) {
6366           TPlaneInfo aPlaneInfo; // ActorList field is empty
6367           aPlaneInfo.PlaneId = aPlaneId;
6368           aPlaneInfo.ViewManager = aViewManager;
6369
6370           // to make the list sorted by plane id
6371           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6372           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6373             const TPlaneInfo& aPlaneInfoRef = *anIter4;
6374             if( aPlaneInfoRef.PlaneId > aPlaneId )
6375               break;
6376           }
6377           aPlaneInfoList.insert( anIter4, aPlaneInfo );
6378         }
6379       }
6380     }
6381   }
6382
6383   // add clipping planes to actors according to the restored parameters
6384   // and update the clipping plane map
6385   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6386   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6387     int aViewId = anIter1->first;
6388     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6389
6390     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6391     if( anIter2 == aPlaneDataMap.end() )
6392       continue;
6393     const TPlaneDataList& aPlaneDataList = anIter2->second;
6394
6395     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6396     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6397       const TPlaneInfo& aPlaneInfo = *anIter3;
6398       int aPlaneId = aPlaneInfo.PlaneId;
6399       const TActorList& anActorList = aPlaneInfo.ActorList;
6400       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6401       if( !aViewManager )
6402         continue;
6403
6404       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6405       if( !aViewWindow )
6406         continue;
6407
6408       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6409
6410       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6411       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6412         const TPlaneData& aPlaneData = *anIter4;
6413         if( aPlaneData.Id == aPlaneId ) {
6414           SMESH::OrientedPlane* aPlane =
6415             SMESHGUI_ClippingDlg::AddPlane( anActorList,
6416                                             aViewWindow,
6417                                             (SMESH::Orientation)aPlaneData.Orientation,
6418                                             aPlaneData.Distance,
6419                                             aPlaneData.Angle );
6420           if( aPlane ) {
6421             SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6422             aClippingPlaneInfo.Plane = aPlane;
6423             aClippingPlaneInfo.ActorList = anActorList;
6424             aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6425           }
6426           break;
6427         }
6428       }
6429     }
6430   }
6431
6432   // update all VTK views
6433   QList<SUIT_ViewManager*> lst;
6434   getApp()->viewManagers(lst);
6435   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6436     SUIT_ViewModel* vmodel = (*it)->getViewModel();
6437     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6438       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6439       vtkView->getRenderer()->ResetCameraClippingRange();
6440       vtkView->Repaint();
6441     }
6442   }
6443 }
6444
6445 /*!
6446   \brief Adds preferences for dfont of VTK viewer
6447   \param label label
6448   \param pIf group identifier
6449   \param param parameter
6450   \return identifier of preferences
6451 */
6452 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6453 {
6454   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6455
6456   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6457
6458   QStringList fam;
6459   fam.append( tr( "SMESH_FONT_ARIAL" ) );
6460   fam.append( tr( "SMESH_FONT_COURIER" ) );
6461   fam.append( tr( "SMESH_FONT_TIMES" ) );
6462
6463   setPreferenceProperty( tfont, "fonts", fam );
6464
6465   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6466   if ( needSize ) f = f | QtxFontEdit::Size;
6467   setPreferenceProperty( tfont, "features", f );
6468
6469   return tfont;
6470 }
6471
6472 /*!
6473   \brief Actions after hypothesis edition
6474   Updates object browser after hypothesis edition
6475 */
6476 void SMESHGUI::onHypothesisEdit( int result )
6477 {
6478   if( result == 1 )
6479     SMESHGUI::Modified();
6480   updateObjBrowser( true );
6481 }
6482
6483
6484 /*!
6485   \brief Signal handler closing(SUIT_ViewWindow*) of a view
6486   \param pview view being closed
6487 */
6488 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6489 #ifndef DISABLE_PLOT2DVIEWER
6490   //Crear all Plot2d Viewers if need.
6491   SMESH::ClearPlot2Viewers(pview);
6492 #endif
6493 }
6494
6495 void SMESHGUI::message( const QString& msg )
6496 {
6497   // dispatch message
6498   QStringList data = msg.split("/");
6499   if ( data.count() > 0 ) {
6500     if ( data.first() == "mesh_loading" ) {
6501       // get mesh entry
6502       QString entry = data.count() > 1 ? data[1] : QString();
6503       if ( entry.isEmpty() )
6504         return;
6505       // get study
6506       _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6507       // get mesh name
6508       _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6509       QString name;
6510       if ( obj )
6511         name = obj->GetName().c_str();
6512       if ( name.isEmpty() )
6513         return;
6514
6515       if ( data.last() == "stop" )
6516         application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6517       else
6518         application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6519       QApplication::processEvents();
6520     }
6521   }
6522 }
6523
6524 /*!
6525   \brief Connects or disconnects signals about activating and cloning view on the module slots
6526   \param pview view which is connected/disconnected
6527 */
6528 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6529   if(!pview)
6530     return;
6531
6532   SUIT_ViewManager* viewMgr = pview->getViewManager();
6533   if ( viewMgr ) {
6534     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6535                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6536
6537     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6538              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6539   }
6540 }
6541
6542 /*!
6543   \brief Return \c true if object can be renamed
6544 */
6545 bool SMESHGUI::renameAllowed( const QString& entry) const {
6546   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6547   if( !anApp )
6548     return false;
6549
6550   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6551   if( !appStudy )
6552     return false;
6553
6554   SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6555
6556   if(!obj)
6557     return false;
6558
6559   if(appStudy->isComponent(entry) || obj->isReference())
6560     return false;
6561
6562   // check type to prevent renaming of inappropriate objects
6563   int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6564   if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6565       aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6566       aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6567       aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6568       aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6569     return true;
6570
6571   return false;
6572 }
6573
6574 /*!
6575   Rename object by entry.
6576   \param entry entry of the object
6577   \param name new name of the object
6578   \brief Return \c true if rename operation finished successfully, \c false otherwise.
6579 */
6580 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6581
6582   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6583   if( !anApp )
6584     return false;
6585
6586   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6587
6588   if(!appStudy)
6589     return false;
6590
6591   _PTR(Study) aStudy = appStudy->studyDS();
6592
6593   if(!aStudy)
6594     return false;
6595
6596   bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6597   if ( aLocked ) {
6598     SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6599     return false;
6600   }
6601
6602
6603   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6604   _PTR(GenericAttribute) anAttr;
6605   _PTR(AttributeName) aName;
6606   if ( obj ) {
6607     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6608       aName = anAttr;
6609       // check type to prevent renaming of inappropriate objects
6610       int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6611       if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6612           aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6613           aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6614           aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6615           aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6616         if ( !name.isEmpty() ) {
6617           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6618
6619           // update name of group object and its actor
6620           Handle(SALOME_InteractiveObject) IObject =
6621             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6622
6623           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6624           if( !aGroupObject->_is_nil() ) {
6625             aGroupObject->SetName( qPrintable(name) );
6626             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6627               anActor->setName( qPrintable(name) );
6628           }
6629           return true;
6630         }
6631       }
6632     }
6633   }
6634   return false;
6635 }
6636
6637
6638 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6639 {
6640   static QList<QColor> colors;
6641
6642   if ( colors.isEmpty() ) {
6643
6644     for (int s = 0; s < 2 ; s++)
6645     {
6646       for (int v = 100; v >= 40; v = v - 20)
6647       {
6648         for (int h = 0; h < 359 ; h = h + 60)
6649         {
6650           colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
6651         }
6652       }
6653     }
6654   }
6655   static int currentColor = 0;
6656
6657   SALOMEDS::Color color;
6658   color.R = (double)colors[currentColor].red()   / 255.0;
6659   color.G = (double)colors[currentColor].green() / 255.0;
6660   color.B = (double)colors[currentColor].blue()  / 255.0;
6661
6662   currentColor = (currentColor+1) % colors.count();
6663
6664   return color;
6665 }