src/SMESHGUI/SMESHGUI.cxx

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