src/SMESHGUI/SMESHGUI.cxx

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