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