src/SMESHGUI/SMESHGUI.cxx

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