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