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     {
4989       connectView(wnd);
4990
4991       // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
4992       SMESH::UpdateActorsAfterUpdateStudy(wnd);
4993
4994       wnd->update();
4995     }
4996   }
4997
4998   Py_XDECREF(pluginsmanager);
4999   return res;
5000 }
5001
5002 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5003 {
5004   setMenuShown( false );
5005   setToolShown( false );
5006
5007   EmitSignalCloseAllDialogs();
5008
5009   // Unset actions accelerator keys
5010   action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5011
5012   return SalomeApp_Module::deactivateModule( study );
5013 }
5014
5015 void SMESHGUI::studyClosed( SUIT_Study* s )
5016 {
5017   if( !s )
5018     return;
5019   SMESH::RemoveVisuData();
5020   SalomeApp_Module::studyClosed( s );
5021 }
5022
5023 void SMESHGUI::OnGUIEvent()
5024 {
5025   const QObject* obj = sender();
5026   if ( !obj || !obj->inherits( "QAction" ) )
5027     return;
5028   int id = actionId((QAction*)obj);
5029   if ( id != -1 )
5030     OnGUIEvent( id );
5031 }
5032
5033 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5034 {
5035   if ( CORBA::is_nil( myComponentSMESH ) )
5036   {
5037     SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5038     return aGUI.myComponentSMESH;
5039   }
5040   return myComponentSMESH;
5041 }
5042
5043 QString SMESHGUI::engineIOR() const
5044 {
5045   CORBA::ORB_var anORB = getApp()->orb();
5046   CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5047   return QString( anIOR.in() );
5048 }
5049
5050 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5051 {
5052   SalomeApp_Module::contextMenuPopup( client, menu, title );
5053   SALOME_ListIO lst;
5054   selectionMgr()->selectedObjects( lst );
5055   if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5056     Handle(SALOME_InteractiveObject) io = lst.First();
5057     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5058     _PTR(Study) study = appStudy->studyDS();
5059     _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5060     if ( obj ) {
5061       QString aName = SMESH::fromUtf8( obj->GetName());
5062       while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5063         aName.remove(( aName.length() - 1 ), 1 );
5064       title = aName;
5065     }
5066   }
5067 }
5068
5069 LightApp_Selection* SMESHGUI::createSelection() const
5070 {
5071   return new SMESHGUI_Selection();
5072 }
5073
5074 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5075 {
5076   aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5077   aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5078 #ifndef DISABLE_PYCONSOLE
5079   aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5080 #endif
5081 }
5082
5083 void SMESHGUI::viewManagers( QStringList& list ) const
5084 {
5085   list.append( SVTK_Viewer::Type() );
5086 }
5087
5088 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5089 {
5090   if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5091     SMESH::UpdateSelectionProp( this );
5092
5093     QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5094     for(int i = 0; i < aViews.count() ; i++){
5095       SUIT_ViewWindow *sf = aViews[i];
5096       connectView( sf );
5097     }
5098     EmitSignalActivatedViewManager();
5099   }
5100 }
5101
5102 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5103 {
5104   if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5105     myClippingPlaneInfoMap.erase( theViewManager );
5106 }
5107
5108 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5109 {
5110   theActor->AddObserver( SMESH::DeleteActorEvent,
5111                          myEventCallbackCommand.GetPointer(),
5112                          myPriority );
5113 }
5114
5115 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5116                               unsigned long theEvent,
5117                               void* theClientData,
5118                               void* theCallData )
5119 {
5120   if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5121     if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5122       if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5123         SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5124         SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5125         for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5126           SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5127           SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5128           for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5129             SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5130             std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5131             SMESH::TActorList::iterator anIter3 = anActorList.begin();
5132             for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5133               if( anActor == *anIter3 ) {
5134                 anActorList.erase( anIter3 );
5135                 break;
5136               }
5137             }
5138           }
5139         }
5140       }
5141     }
5142   }
5143 }
5144
5145 void SMESHGUI::createPreferences()
5146 {
5147   // General tab ------------------------------------------------------------------------
5148   int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5149
5150   int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5151   setPreferenceProperty( autoUpdate, "columns", 2 );
5152   int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5153   setPreferenceProperty( lim, "min",  0 );
5154   setPreferenceProperty( lim, "max",  100000000 );
5155   setPreferenceProperty( lim, "step", 1000 );
5156   setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5157   addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5158
5159   int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5160   setPreferenceProperty( dispgroup, "columns", 2 );
5161
5162   addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5163
5164   int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5165   QStringList modes;
5166   modes.append( tr("MEN_WIRE") );
5167   modes.append( tr("MEN_SHADE") );
5168   modes.append( tr("MEN_NODES") );
5169   modes.append( tr("MEN_SHRINK") );
5170   QList<QVariant> indices;
5171   indices.append( 0 );
5172   indices.append( 1 );
5173   indices.append( 2 );
5174   indices.append( 3 );
5175   setPreferenceProperty( dispmode, "strings", modes );
5176   setPreferenceProperty( dispmode, "indexes", indices );
5177
5178   int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5179   setPreferenceProperty( arcgroup, "columns", 2 );
5180   int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5181   QStringList quadraticModes;
5182   quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5183   quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5184   indices.clear();
5185   indices.append( 0 );
5186   indices.append( 1 );
5187   setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5188   setPreferenceProperty( quadraticmode, "indexes", indices );
5189
5190   int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5191                               "SMESH", "max_angle" );
5192   setPreferenceProperty( maxAngle, "min", 1 );
5193   setPreferenceProperty( maxAngle, "max", 90 );
5194
5195   int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5196   setPreferenceProperty( qaGroup, "columns", 2 );
5197   addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5198   addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5199   int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5200   setPreferenceProperty( prec, "min", 0 );
5201   setPreferenceProperty( prec, "max", 100 );
5202   int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5203   setPreferenceProperty( doubleNodesTol, "precision", 10 );
5204   setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5205   setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5206   setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5207
5208   /*
5209   int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5210   setPreferenceProperty( cinc, "min", 0 );
5211   setPreferenceProperty( cinc, "max", 5 );
5212   */
5213
5214   int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5215   setPreferenceProperty( exportgroup, "columns", 2 );
5216   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5217   addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5218   int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5219   setPreferenceProperty( zTol, "precision", 10 );
5220   setPreferenceProperty( zTol, "min", 0.0000000001 );
5221   setPreferenceProperty( zTol, "max", 1000000.0 );
5222   setPreferenceProperty( zTol, "step", 1. );
5223   //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5224
5225   int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5226   setPreferenceProperty( computeGroup, "columns", 2 );
5227   int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5228   modes.clear();
5229   modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5230   modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5231   modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5232   indices.clear();
5233   indices.append( 0 );
5234   indices.append( 1 );
5235   indices.append( 2 );
5236   setPreferenceProperty( notifyMode, "strings", modes );
5237   setPreferenceProperty( notifyMode, "indexes", indices );
5238
5239   int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5240   setPreferenceProperty( infoGroup, "columns", 2 );
5241   int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5242   modes.clear();
5243   modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5244   modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5245   indices.clear();
5246   indices.append( 0 );
5247   indices.append( 1 );
5248   setPreferenceProperty( elemInfo, "strings", modes );
5249   setPreferenceProperty( elemInfo, "indexes", indices );
5250   int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5251   setPreferenceProperty( nodesLim, "min", 0 );
5252   setPreferenceProperty( nodesLim, "max", 10000000 );
5253   setPreferenceProperty( nodesLim, "step", 10000 );
5254   setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5255   int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5256   setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5257   setPreferenceProperty( ctrlLim, "min", 0 );
5258   setPreferenceProperty( ctrlLim, "max", 10000000 );
5259   setPreferenceProperty( ctrlLim, "step", 1000 );
5260   addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5261   addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5262   addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5263   addPreference( tr( "PREF_DUMP_ADD_INFO"  ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5264   addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5265
5266   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5267   setPreferenceProperty( segGroup, "columns", 2 );
5268   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5269                               "SMESH", "segmentation" );
5270   setPreferenceProperty( segLen, "min", 1 );
5271   setPreferenceProperty( segLen, "max", 10000000 );
5272   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5273                              "SMESH", "nb_segments_per_edge" );
5274   setPreferenceProperty( nbSeg, "min", 1 );
5275   setPreferenceProperty( nbSeg, "max", 10000000 );
5276
5277   int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5278   addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5279                  "SMESH", "forget_mesh_on_hyp_modif" );
5280
5281
5282   // Quantities with individual precision settings
5283   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5284   setPreferenceProperty( precGroup, "columns", 2 );
5285
5286   const int nbQuantities = 6;
5287   int precs[nbQuantities], ii = 0;
5288   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5289                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5290   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5291                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5292   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5293                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5294   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5295                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5296   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5297                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5298   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5299                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5300
5301   // Set property for precision value for spinboxes
5302   for ( ii = 0; ii < nbQuantities; ii++ ){
5303     setPreferenceProperty( precs[ii], "min", -14 );
5304     setPreferenceProperty( precs[ii], "max", 14 );
5305     setPreferenceProperty( precs[ii], "precision", 2 );
5306   }
5307
5308   int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5309   setPreferenceProperty( previewGroup, "columns", 2 );
5310   int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5311   setPreferenceProperty( chunkSize, "min",  1 );
5312   setPreferenceProperty( chunkSize, "max",  1000 );
5313   setPreferenceProperty( chunkSize, "step", 50 );
5314
5315   int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5316   addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5317
5318   // Mesh tab ------------------------------------------------------------------------
5319   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5320   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5321   setPreferenceProperty( nodeGroup, "columns", 3 );
5322
5323   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5324
5325   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5326
5327   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5328   QList<QVariant> aMarkerTypeIndicesList;
5329   QList<QVariant> aMarkerTypeIconsList;
5330   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5331     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5332     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5333     aMarkerTypeIndicesList << i;
5334     aMarkerTypeIconsList << pixmap;
5335   }
5336   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5337   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
5338
5339   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5340
5341   QList<QVariant> aMarkerScaleIndicesList;
5342   QStringList     aMarkerScaleValuesList;
5343   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5344     aMarkerScaleIndicesList << i;
5345     //aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5346     aMarkerScaleValuesList  << QString::number( i );
5347   }
5348   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5349   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5350
5351   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5352   //setPreferenceProperty( elemGroup, "columns", 2 );
5353
5354   int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5355   setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5356   ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5357   setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5358   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5359   addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5360   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5361   addPreference( tr( "PREF_WIREFRAME"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5362   addPreference( tr( "PREF_PREVIEW_COLOR"  ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5363
5364
5365   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5366   setPreferenceProperty( grpGroup, "columns", 2 );
5367
5368   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5369   addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5370
5371   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5372                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5373   /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5374                              LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5375   double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5376                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5377   double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5378                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5379   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
5380                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
5381   int outW  = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5382                              LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5383   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5384                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5385
5386   setPreferenceProperty( size0d, "min", 1 );
5387   setPreferenceProperty( size0d, "max", 10 );
5388
5389  // setPreferenceProperty( ballSize, "min", 1 );
5390  // setPreferenceProperty( ballSize, "max", 10 );
5391
5392   setPreferenceProperty( ballDiameter, "min", 1e-7 );
5393   setPreferenceProperty( ballDiameter, "max", 1e9 );
5394   setPreferenceProperty( ballDiameter, "step", 0.1 );
5395
5396   setPreferenceProperty( ballScale, "min", 1e-2 );
5397   setPreferenceProperty( ballScale, "max", 1e7 );
5398   setPreferenceProperty( ballScale, "step", 0.5 );
5399
5400   setPreferenceProperty( elemW, "min", 1 );
5401   setPreferenceProperty( elemW, "max", 5 );
5402
5403   setPreferenceProperty( outW, "min", 1 );
5404   setPreferenceProperty( outW, "max", 5 );
5405
5406   setPreferenceProperty( shrink, "min", 0 );
5407   setPreferenceProperty( shrink, "max", 100 );
5408
5409   int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5410   setPreferenceProperty( numGroup, "columns", 2 );
5411
5412   addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5413   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5414
5415   addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5416   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5417
5418   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5419   setPreferenceProperty( orientGroup, "columns", 1 );
5420
5421   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5422   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5423
5424   setPreferenceProperty( orientScale, "min", 0.05 );
5425   setPreferenceProperty( orientScale, "max", 0.5 );
5426   setPreferenceProperty( orientScale, "step", 0.05 );
5427
5428   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5429
5430   // Selection tab ------------------------------------------------------------------------
5431   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5432
5433   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5434   setPreferenceProperty( selGroup, "columns", 2 );
5435
5436   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5437   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5438
5439   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5440   setPreferenceProperty( preGroup, "columns", 2 );
5441
5442   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5443
5444   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5445   setPreferenceProperty( precSelGroup, "columns", 2 );
5446
5447   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5448   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5449   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5450
5451   int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5452   setPreferenceProperty( sinc, "min", 0 );
5453   setPreferenceProperty( sinc, "max", 5 );
5454
5455   // Scalar Bar tab ------------------------------------------------------------------------
5456   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5457   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5458   setPreferenceProperty( fontGr, "columns", 2 );
5459
5460   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5461   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5462
5463   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5464   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5465
5466   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5467   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5468
5469   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5470   setPreferenceProperty( numcol, "min", 2 );
5471   setPreferenceProperty( numcol, "max", 256 );
5472
5473   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5474   setPreferenceProperty( numlab, "min", 2 );
5475   setPreferenceProperty( numlab, "max", 65 );
5476
5477   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5478   setPreferenceProperty( orientGr, "columns", 2 );
5479   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5480   QStringList orients;
5481   orients.append( tr( "SMESH_VERTICAL" ) );
5482   orients.append( tr( "SMESH_HORIZONTAL" ) );
5483   indices.clear(); indices.append( 0 ); indices.append( 1 );
5484   setPreferenceProperty( orient, "strings", orients );
5485   setPreferenceProperty( orient, "indexes", indices );
5486
5487   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5488   setPreferenceProperty( posVSizeGr, "columns", 2 );
5489   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5490   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5491   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5492   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5493   setPreferenceProperty( xv, "step", 0.1 );
5494   setPreferenceProperty( xv, "min", 0.0 );
5495   setPreferenceProperty( xv, "max", 1.0 );
5496   setPreferenceProperty( yv, "step", 0.1 );
5497   setPreferenceProperty( yv, "min", 0.0 );
5498   setPreferenceProperty( yv, "max", 1.0 );
5499   setPreferenceProperty( wv, "step", 0.1 );
5500   setPreferenceProperty( wv, "min", 0.0 );
5501   setPreferenceProperty( wv, "max", 1.0 );
5502   setPreferenceProperty( hv, "min", 0.0 );
5503   setPreferenceProperty( hv, "max", 1.0 );
5504   setPreferenceProperty( hv, "step", 0.1 );
5505
5506   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5507   setPreferenceProperty( posHSizeGr, "columns", 2 );
5508   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5509   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5510   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5511   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5512   setPreferenceProperty( xv, "min", 0.0 );
5513   setPreferenceProperty( xv, "max", 1.0 );
5514   setPreferenceProperty( xv, "step", 0.1 );
5515   setPreferenceProperty( xh, "min", 0.0 );
5516   setPreferenceProperty( xh, "max", 1.0 );
5517   setPreferenceProperty( xh, "step", 0.1 );
5518   setPreferenceProperty( yh, "min", 0.0 );
5519   setPreferenceProperty( yh, "max", 1.0 );
5520   setPreferenceProperty( yh, "step", 0.1 );
5521   setPreferenceProperty( wh, "min", 0.0 );
5522   setPreferenceProperty( wh, "max", 1.0 );
5523   setPreferenceProperty( wh, "step", 0.1 );
5524   setPreferenceProperty( hh, "min", 0.0 );
5525   setPreferenceProperty( hh, "max", 1.0 );
5526   setPreferenceProperty( hh, "step", 0.1 );
5527
5528   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5529   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5530   setPreferenceProperty( distributionGr, "columns", 3 );
5531   QStringList types;
5532   types.append( tr( "SMESH_MONOCOLOR" ) );
5533   types.append( tr( "SMESH_MULTICOLOR" ) );
5534   indices.clear(); indices.append( 0 ); indices.append( 1 );
5535   setPreferenceProperty( coloringType, "strings", types );
5536   setPreferenceProperty( coloringType, "indexes", indices );
5537   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5538
5539 }
5540
5541 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5542 {
5543   if ( sect=="SMESH" ) {
5544     float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5545     float aTol = 1.00000009999999;
5546     std::string aWarning;
5547     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5548
5549     if ( name ==  "selection_object_color" ||
5550          name == "selection_element_color" ||
5551          name ==         "highlight_color" ||
5552          name == "selection_precision_node"    ||
5553          name == "selection_precision_element" ||
5554          name == "selection_precision_object"  ||
5555          name == "selection_increment")
5556     {
5557       SMESH::UpdateSelectionProp( this );
5558     }
5559     else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5560     {
5561       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x",     sbX1);
5562       sbW  = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5563       if ( sbX1+sbW > aTol ) {
5564         aWarning = "Origin and Size Vertical: X+Width > 1\n";
5565         sbX1 = 0.01;
5566         sbW  = 0.08;
5567         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x",     sbX1);
5568         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5569       }
5570     }
5571     else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5572     {
5573       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y",     sbY1);
5574       sbH  = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5575       if ( sbY1 + sbH > aTol ) {
5576         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5577         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y",     sbY1);
5578         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5579       }
5580     }
5581     else if (name == "scalar_bar_horizontal_x" || name ==  "scalar_bar_horizontal_width")
5582     {
5583       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x",     sbX1);
5584       sbW  = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5585       if ( sbX1 + sbW > aTol ) {
5586         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5587         sbX1=0.1;
5588         sbW =0.08;
5589         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5590         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5591       }
5592     }
5593     else if (name == "scalar_bar_horizontal_y" || name ==  "scalar_bar_horizontal_height")
5594     {
5595       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y",     sbY1);
5596       sbH  = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5597       if ( sbY1 + sbH > aTol ) {
5598         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5599         sbY1=0.01;
5600         sbH =0.08;
5601         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5602         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5603       }
5604     }
5605     else if ( name == "segmentation" )
5606     {
5607       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5608       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5609     }
5610     else if ( name == "nb_segments_per_edge" )
5611     {
5612       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5613       myComponentSMESH->SetDefaultNbSegments( nbSeg );
5614     }
5615     else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5616     {
5617       QString val = aResourceMgr->stringValue( "SMESH", name );
5618       myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5619     }
5620     else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5621     {
5622       SMESH::UpdateFontProp( this );
5623     }
5624     else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5625     {
5626       SMESH::UpdateFontProp( this );
5627     }
5628
5629     if ( aWarning.size() != 0 ) {
5630       aWarning += "The default values are applied instead.";
5631       SUIT_MessageBox::warning(SMESHGUI::desktop(),
5632                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5633                                QObject::tr(aWarning.c_str()));
5634     }
5635   }
5636 }
5637
5638 //================================================================================
5639 /*!
5640  * \brief Update something in accordance with update flags
5641   * \param theFlags - update flags
5642 *
5643 * Update viewer or/and object browser etc. in accordance with update flags ( see
5644 * LightApp_UpdateFlags enumeration ).
5645 */
5646 //================================================================================
5647 void SMESHGUI::update( const int flags )
5648 {
5649   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5650     SMESH::UpdateView();
5651   else
5652     SalomeApp_Module::update( flags );
5653 }
5654
5655 //================================================================================
5656 /*!
5657  * \brief Set default selection mode
5658 *
5659 * SLOT called when operation committed. Sets default selection mode
5660 */
5661 //================================================================================
5662 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5663 {
5664   SVTK_ViewWindow* vtkWnd =
5665     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5666   if ( vtkWnd )
5667     vtkWnd->SetSelectionMode( ActorSelection );
5668 }
5669
5670 //================================================================================
5671 /*!
5672  * \brief Set default selection mode
5673 *
5674 * SLOT called when operation aborted. Sets default selection mode
5675 */
5676 //================================================================================
5677 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5678 {
5679   SVTK_ViewWindow* vtkWnd =
5680     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5681   if ( vtkWnd )
5682     vtkWnd->SetSelectionMode( ActorSelection );
5683 }
5684
5685 //================================================================================
5686 /*!
5687  * \brief Creates operation with given identifier
5688   * \param id - identifier of operation to be started
5689   * \return Pointer on created operation or NULL if operation is not created
5690 *
5691 * Virtual method redefined from the base class creates operation with given id.
5692 * It is called called automatically from startOperation method of base class.
5693 */
5694 //================================================================================
5695 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5696 {
5697   LightApp_Operation* op = 0;
5698   // to do : create operation here
5699   switch( id )
5700   {
5701     case SMESHOp::OpSplitBiQuadratic:
5702       op = new SMESHGUI_SplitBiQuadOp();
5703     break;
5704     case SMESHOp::OpConvertMeshToQuadratic:
5705       op = new SMESHGUI_ConvToQuadOp();
5706     break;
5707     case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5708       op = new SMESHGUI_Make2DFrom3DOp();
5709     break;
5710     case SMESHOp::OpReorientFaces:
5711       op = new SMESHGUI_ReorientFacesOp();
5712       break;
5713     case SMESHOp::OpCreateMesh:
5714       op = new SMESHGUI_MeshOp( true, true );
5715     break;
5716     case SMESHOp::OpCreateSubMesh:
5717       op = new SMESHGUI_MeshOp( true, false );
5718     break;
5719     case SMESHOp::OpEditMeshOrSubMesh:
5720     case SMESHOp::OpEditMesh:
5721     case SMESHOp::OpEditSubMesh:
5722       op = new SMESHGUI_MeshOp( false );
5723     break;
5724     case SMESHOp::OpCompute:
5725     case SMESHOp::OpComputeSubMesh:
5726       op = new SMESHGUI_ComputeOp();
5727     break;
5728     case SMESHOp::OpPreCompute:
5729       op = new SMESHGUI_PrecomputeOp();
5730     break;
5731     case SMESHOp::OpEvaluate:
5732       op = new SMESHGUI_EvaluateOp();
5733     break;
5734     case SMESHOp::OpMeshOrder:
5735       op = new SMESHGUI_MeshOrderOp();
5736     break;
5737     case SMESHOp::OpCreateGeometryGroup:
5738       op = new SMESHGUI_GroupOnShapeOp();
5739       break;
5740     case SMESHOp::OpFindElementByPoint:
5741       op = new SMESHGUI_FindElemByPointOp();
5742       break;
5743     case SMESHOp::OpMoveNode: // Make mesh pass through point
5744       op = new SMESHGUI_MakeNodeAtPointOp();
5745       break;
5746     case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5747       op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5748       break;
5749     default:
5750     break;
5751   }
5752
5753   if( !op )
5754     op = SalomeApp_Module::createOperation( id );
5755   return op;
5756 }
5757
5758 //================================================================================
5759 /*!
5760  * \brief Stops current operations and starts a given one
5761   * \param id - The id of the operation to start
5762  */
5763 //================================================================================
5764
5765 void SMESHGUI::switchToOperation(int id)
5766 {
5767   activeStudy()->abortAllOperations();
5768   startOperation( id );
5769 }
5770
5771 LightApp_Displayer* SMESHGUI::displayer()
5772 {
5773   if( !myDisplayer )
5774     myDisplayer = new SMESHGUI_Displayer( getApp() );
5775   return myDisplayer;
5776 }
5777
5778 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5779 {
5780   int aHue = -1;
5781   int aTolerance = 64;
5782   int anIterations = 0;
5783   int aPeriod = 5;
5784
5785   while( 1 )
5786   {
5787     anIterations++;
5788     if( anIterations % aPeriod == 0 )
5789     {
5790       aTolerance /= 2;
5791       if( aTolerance < 1 )
5792         break;
5793     }
5794
5795     aHue = (int)( 360.0 * rand() / RAND_MAX );
5796
5797     bool ok = true;
5798     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5799     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5800     for( ; it != itEnd; ++it )
5801     {
5802       SALOMEDS::Color anAutoColor = *it;
5803       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5804
5805       int h, s, v;
5806       aQColor.getHsv( &h, &s, &v );
5807       if( abs( h - aHue ) < aTolerance )
5808       {
5809         ok = false;
5810         break;
5811       }
5812     }
5813
5814     if( ok )
5815       break;
5816   }
5817
5818   QColor aColor;
5819   aColor.setHsv( aHue, 255, 255 );
5820
5821   SALOMEDS::Color aSColor;
5822   aSColor.R = aColor.redF();
5823   aSColor.G = aColor.greenF();
5824   aSColor.B = aColor.blueF();
5825
5826   return aSColor;
5827 }
5828
5829 const char* gSeparator = "_"; // character used to separate parameter names
5830 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5831 const char* gPathSep   = "|"; // character used to separate paths
5832
5833 /*!
5834  * \brief Store visual parameters
5835  *
5836  * This method is called just before the study document is saved.
5837  * Store visual parameters in AttributeParameter attribute(s)
5838  */
5839 void SMESHGUI::storeVisualParameters (int savePoint)
5840 {
5841   // localizing
5842   Kernel_Utils::Localizer loc;
5843
5844   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5845   if (!appStudy || !appStudy->studyDS())
5846     return;
5847   _PTR(Study) studyDS = appStudy->studyDS();
5848
5849   // componentName is used for encoding of entries when storing them in IParameters
5850   std::string componentName = myComponentSMESH->ComponentDataType();
5851   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5852   //if (!aSComponent) return;
5853
5854   // IParameters
5855   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5856                                                              componentName.c_str(),
5857                                                              savePoint);
5858   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5859
5860   // store custom markers
5861   if( !myMarkerMap.empty() )
5862   {
5863     VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5864     for( ; anIter != myMarkerMap.end(); anIter++ )
5865     {
5866       int anId = anIter->first;
5867       VTK::MarkerData aMarkerData = anIter->second;
5868       std::string aMarkerFileName = aMarkerData.first;
5869       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5870       if( aMarkerTexture.size() < 3 )
5871         continue; // should contain at least width, height and the first value
5872
5873       QString aPropertyName( "texture" );
5874       aPropertyName += gSeparator;
5875       aPropertyName += QString::number( anId );
5876
5877       QString aPropertyValue = aMarkerFileName.c_str();
5878       aPropertyValue += gPathSep;
5879
5880       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5881       ushort aWidth = *aTextureIter++;
5882       ushort aHeight = *aTextureIter++;
5883       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5884       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5885       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5886         aPropertyValue += QString::number( *aTextureIter );
5887
5888       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5889     }
5890   }
5891
5892   // viewers counters are used for storing view_numbers in IParameters
5893   int vtkViewers = 0;
5894
5895   // main cycle to store parameters of displayed objects
5896   QList<SUIT_ViewManager*> lst;
5897   QList<SUIT_ViewManager*>::Iterator it;
5898   getApp()->viewManagers(lst);
5899   for (it = lst.begin(); it != lst.end(); it++)
5900   {
5901     SUIT_ViewManager* vman = *it;
5902     QString vType = vman->getType();
5903
5904     // saving VTK actors properties
5905     if (vType == SVTK_Viewer::Type())
5906     {
5907       // store the clipping planes attached to the view manager
5908       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5909       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5910       if( anIter != myClippingPlaneInfoMap.end() )
5911         aClippingPlaneInfoList = anIter->second;
5912
5913       if( !aClippingPlaneInfoList.empty() ) {
5914         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5915         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5916         {
5917           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5918           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5919
5920           QString aPropertyName( "ClippingPlane" );
5921           aPropertyName += gSeparator;
5922           aPropertyName += QString::number( vtkViewers );
5923           aPropertyName += gSeparator;
5924           aPropertyName += QString::number( anId );
5925
5926           QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5927           aPropertyValue += gDigitsSep;
5928           aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5929           aPropertyValue += gDigitsSep;
5930           if ( aPlane->PlaneMode == SMESH::Absolute ) {
5931             aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5932             aPropertyValue += gDigitsSep;
5933             aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5934             aPropertyValue += gDigitsSep;
5935             aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5936             aPropertyValue += gDigitsSep;
5937             aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5938             aPropertyValue += gDigitsSep;
5939             aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5940             aPropertyValue += gDigitsSep;
5941             aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5942             aPropertyValue += gDigitsSep;
5943             aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5944           }
5945           else if ( aPlane->PlaneMode == SMESH::Relative ) {
5946             aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5947             aPropertyValue += gDigitsSep;
5948             aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5949             aPropertyValue += gDigitsSep;
5950             aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5951             aPropertyValue += gDigitsSep;
5952             aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5953           }
5954
5955           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5956         }
5957       }
5958
5959       QVector<SUIT_ViewWindow*> views = vman->getViews();
5960       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5961       {
5962         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5963         {
5964           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5965           vtkActorCollection* allActors = aCopy.GetActors();
5966           allActors->InitTraversal();
5967           while (vtkActor* actor = allActors->GetNextActor())
5968           {
5969             if (actor->GetVisibility()) // store only visible actors
5970             {
5971               SMESH_Actor* aSmeshActor = 0;
5972               if (actor->IsA("SMESH_Actor"))
5973                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5974               if (aSmeshActor && aSmeshActor->hasIO())
5975               {
5976                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5977                 if (io->hasEntry())
5978                 {
5979                   // entry is "encoded" = it does NOT contain component address,
5980                   // since it is a subject to change on next component loading
5981                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5982
5983                   std::string param, vtkParam = vType.toLatin1().data();
5984                   vtkParam += gSeparator;
5985                   vtkParam += QString::number(vtkViewers).toLatin1().data();
5986                   vtkParam += gSeparator;
5987
5988                   // Visibility
5989                   param = vtkParam + "Visibility";
5990                   ip->setParameter(entry, param, "On");
5991
5992                   // Representation
5993                   param = vtkParam + "Representation";
5994                   ip->setParameter(entry, param, QString::number
5995                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5996
5997                   // IsShrunk
5998                   param = vtkParam + "IsShrunk";
5999                   ip->setParameter(entry, param, QString::number
6000                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6001
6002                   // Displayed entities
6003                   unsigned int aMode = aSmeshActor->GetEntityMode();
6004                   bool isE  = aMode & SMESH_Actor::eEdges;
6005                   bool isF  = aMode & SMESH_Actor::eFaces;
6006                   bool isV  = aMode & SMESH_Actor::eVolumes;
6007                   bool is0d = aMode & SMESH_Actor::e0DElements;
6008                   bool isB  = aMode & SMESH_Actor::eBallElem;
6009
6010                   QString modeStr ("e");
6011                   modeStr += gDigitsSep; modeStr += QString::number(isE);
6012                   modeStr += gDigitsSep; modeStr += "f";
6013                   modeStr += gDigitsSep; modeStr += QString::number(isF);
6014                   modeStr += gDigitsSep; modeStr += "v";
6015                   modeStr += gDigitsSep; modeStr += QString::number(isV);
6016                   modeStr += gDigitsSep; modeStr += "0d";
6017                   modeStr += gDigitsSep; modeStr += QString::number(is0d);
6018                   modeStr += gDigitsSep; modeStr += "b";
6019                   modeStr += gDigitsSep; modeStr += QString::number(isB);
6020
6021                   param = vtkParam + "Entities";
6022                   ip->setParameter(entry, param, modeStr.toLatin1().data());
6023
6024                   // Colors
6025                   double r, g, b;
6026                   int delta;
6027
6028                   aSmeshActor->GetSufaceColor(r, g, b, delta);
6029                   QStringList colorStr;
6030                   colorStr << "surface";
6031                   colorStr << QString::number(r);
6032                   colorStr << QString::number(g);
6033                   colorStr << QString::number(b);
6034
6035                   colorStr << "backsurface";
6036                   colorStr << QString::number(delta);
6037
6038                   aSmeshActor->GetVolumeColor(r, g, b, delta);
6039                   colorStr << "volume";
6040                   colorStr << QString::number(r);
6041                   colorStr << QString::number(g);
6042                   colorStr << QString::number(b);
6043                   colorStr << QString::number(delta);
6044
6045                   aSmeshActor->GetEdgeColor(r, g, b);
6046                   colorStr << "edge";
6047                   colorStr << QString::number(r);
6048                   colorStr << QString::number(g);
6049                   colorStr << QString::number(b);
6050
6051                   aSmeshActor->GetNodeColor(r, g, b);
6052                   colorStr << "node";
6053                   colorStr << QString::number(r);
6054                   colorStr << QString::number(g);
6055                   colorStr << QString::number(b);
6056
6057                   aSmeshActor->GetOutlineColor(r, g, b);
6058                   colorStr << "outline";
6059                   colorStr << QString::number(r);
6060                   colorStr << QString::number(g);
6061                   colorStr << QString::number(b);
6062
6063                   aSmeshActor->Get0DColor(r, g, b);
6064                   colorStr << "elem0d";
6065                   colorStr << QString::number(r);
6066                   colorStr << QString::number(g);
6067                   colorStr << QString::number(b);
6068
6069                   aSmeshActor->GetBallColor(r, g, b);
6070                   colorStr << "ball";
6071                   colorStr << QString::number(r);
6072                   colorStr << QString::number(g);
6073                   colorStr << QString::number(b);
6074
6075                   aSmeshActor->GetFacesOrientationColor(r, g, b);
6076                   colorStr << "orientation";
6077                   colorStr << QString::number(r);
6078                   colorStr << QString::number(g);
6079                   colorStr << QString::number(b);
6080
6081                   param = vtkParam + "Colors";
6082                   ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6083
6084                   // Sizes
6085                   QStringList sizeStr;
6086                   sizeStr << "line";
6087                   sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6088                   sizeStr << "outline";
6089                   sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6090                   sizeStr << "elem0d";
6091                   sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6092                   sizeStr << "ball";
6093                   //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6094                   sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6095                   sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6096                   sizeStr << "shrink";
6097                   sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6098                   sizeStr << "orientation";
6099                   sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6100                   sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6101
6102                   param = vtkParam + "Sizes";
6103                   ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6104
6105                   // Point marker
6106                   QString markerStr;
6107
6108                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6109                   if( aMarkerType == VTK::MT_USER ) {
6110                     markerStr += "custom";
6111                     markerStr += gDigitsSep;
6112                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6113                   }
6114                   else {
6115                     markerStr += "std";
6116                     markerStr += gDigitsSep;
6117                     markerStr += QString::number( (int)aMarkerType );
6118                     markerStr += gDigitsSep;
6119                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6120                   }
6121
6122                   param = vtkParam + "PointMarker";
6123                   ip->setParameter(entry, param, markerStr.toLatin1().data());
6124
6125                   // Opacity
6126                   param = vtkParam + "Opacity";
6127                   ip->setParameter(entry, param,
6128                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6129
6130                   // Clipping
6131                   param = vtkParam + "ClippingPlane";
6132                   int aPlaneId = 0;
6133                   if( !aClippingPlaneInfoList.empty() ) {
6134                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6135                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6136                     {
6137                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6138                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6139                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
6140                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6141                         if( aSmeshActor == *anIter2 ) {
6142                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6143                                             QString::number( anId ).toLatin1().constData() );
6144                           break;
6145                         }
6146                       }
6147                     }
6148                   }
6149                   if( aPlaneId == 0 )
6150                     ip->setParameter( entry, param, "Off" );
6151                 } // if (io->hasEntry())
6152               } // SMESH_Actor && hasIO
6153             } // isVisible
6154           } // while.. actors traversal
6155         } // if (vtkView)
6156       } // for (views)
6157       vtkViewers++;
6158     } // if (SVTK view model)
6159   } // for (viewManagers)
6160 }
6161
6162 // data structures for clipping planes processing
6163 typedef struct {
6164   int Id;
6165   int Mode;
6166   bool isOpenGLClipping;
6167   vtkIdType RelativeOrientation;
6168   double Distance;
6169   double Angle[2];
6170   int AbsoluteOrientation;
6171   double X, Y, Z, Dx, Dy, Dz;
6172 } TPlaneData;
6173 typedef std::list<TPlaneData>         TPlaneDataList;
6174 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6175
6176 typedef std::list<vtkActor*>          TActorList;
6177 typedef struct {
6178   int PlaneId;
6179   TActorList ActorList;
6180   SUIT_ViewManager* ViewManager;
6181 } TPlaneInfo;
6182 typedef std::list<TPlaneInfo>         TPlaneInfoList;
6183 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6184
6185 /*!
6186  * \brief Restore visual parameters
6187  *
6188  * This method is called after the study document is opened.
6189  * Restore visual parameters from AttributeParameter attribute(s)
6190  */
6191 void SMESHGUI::restoreVisualParameters (int savePoint)
6192 {
6193   // localizing
6194   Kernel_Utils::Localizer loc;
6195
6196   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6197   if (!appStudy || !appStudy->studyDS())
6198     return;
6199   _PTR(Study) studyDS = appStudy->studyDS();
6200
6201   // componentName is used for encoding of entries when storing them in IParameters
6202   std::string componentName = myComponentSMESH->ComponentDataType();
6203   //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6204   //if (!aSComponent) return;
6205
6206   // IParameters
6207   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6208                                                              componentName.c_str(),
6209                                                              savePoint);
6210   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6211
6212   // restore custom markers and map of clipping planes
6213   TPlaneDataMap aPlaneDataMap;
6214
6215   std::vector<std::string> properties = ip->getProperties();
6216   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6217   {
6218     std::string property = *propIt;
6219     QString aPropertyName( property.c_str() );
6220     QString aPropertyValue( ip->getProperty( property ).c_str() );
6221
6222     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6223     if( aPropertyNameList.isEmpty() )
6224       continue;
6225
6226     QString aPropertyType = aPropertyNameList[0];
6227     if( aPropertyType == "texture" )
6228     {
6229       if( aPropertyNameList.size() != 2 )
6230         continue;
6231
6232       bool ok = false;
6233       int anId = aPropertyNameList[1].toInt( &ok );
6234       if( !ok || anId < 1 )
6235         continue;
6236
6237       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6238       if( aPropertyValueList.size() != 2 )
6239         continue;
6240
6241       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6242       QString aMarkerTextureString = aPropertyValueList[1];
6243       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6244       if( aMarkerTextureStringList.size() != 3 )
6245         continue;
6246
6247       ok = false;
6248       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6249       if( !ok )
6250         continue;
6251
6252       ok = false;
6253       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6254       if( !ok )
6255         continue;
6256
6257       VTK::MarkerTexture aMarkerTexture;
6258       aMarkerTexture.push_back( aWidth );
6259       aMarkerTexture.push_back( aHeight );
6260
6261       QString aMarkerTextureData = aMarkerTextureStringList[2];
6262       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6263       {
6264         QChar aChar = aMarkerTextureData.at( i );
6265         if( aChar.isDigit() )
6266           aMarkerTexture.push_back( aChar.digitValue() );
6267       }
6268
6269       myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6270     }
6271     else if( aPropertyType == "ClippingPlane" )
6272     {
6273       if( aPropertyNameList.size() != 3 )
6274         continue;
6275
6276       bool ok = false;
6277       int aViewId = aPropertyNameList[1].toInt( &ok );
6278       if( !ok || aViewId < 0 )
6279         continue;
6280
6281       ok = false;
6282       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6283       if( !ok || aClippingPlaneId < 0 )
6284         continue;
6285
6286       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6287       if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6288         continue;
6289
6290       TPlaneData aPlaneData;
6291       aPlaneData.AbsoluteOrientation = false;
6292       aPlaneData.RelativeOrientation = 0;
6293       aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6294       aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6295       aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6296
6297       aPlaneData.Id = aClippingPlaneId;
6298
6299       ok = false;
6300       aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6301       if( !ok )
6302         continue;
6303
6304       ok = false;
6305       aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6306       if( !ok )
6307         continue;
6308
6309       if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6310       {
6311         ok = false;
6312         aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6313         if( !ok )
6314           continue;
6315
6316         ok = false;
6317         aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6318         if( !ok )
6319           continue;
6320
6321         ok = false;
6322         aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6323         if( !ok )
6324           continue;
6325
6326         ok = false;
6327         aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6328         if( !ok )
6329           continue;
6330
6331         ok = false;
6332         aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6333         if( !ok )
6334           continue;
6335
6336         ok = false;
6337         aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6338         if( !ok )
6339           continue;
6340
6341         ok = false;
6342         aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6343         if( !ok )
6344           continue;
6345       }
6346       else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6347         ok = false;
6348         aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6349         if( !ok )
6350           continue;
6351
6352         ok = false;
6353         aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6354         if( !ok )
6355           continue;
6356
6357         ok = false;
6358         aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6359         if( !ok )
6360           continue;
6361
6362         ok = false;
6363         aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6364         if( !ok )
6365           continue;
6366       }
6367
6368       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6369       aPlaneDataList.push_back( aPlaneData );
6370     }
6371   }
6372
6373   TPlaneInfoMap aPlaneInfoMap;
6374
6375   std::vector<std::string> entries = ip->getEntries();
6376
6377   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6378   {
6379     // entry is a normal entry - it should be "decoded" (setting base address of component)
6380     QString entry (ip->decodeEntry(*entIt).c_str());
6381
6382     // Check that the entry corresponds to a real object in the Study
6383     // as the object may be deleted or modified after the visual state is saved.
6384     _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6385     if (!so) continue; //Skip the not existent entry
6386
6387     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6388     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6389
6390     std::vector<std::string>::iterator namesIt = paramNames.begin();
6391     std::vector<std::string>::iterator valuesIt = paramValues.begin();
6392
6393     // actors are stored in a map after displaying of them for
6394     // quicker access in the future: map < viewID to actor >
6395     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6396
6397     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6398     {
6399       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6400       // '_' is used as separator and should not be used in viewer type or parameter names.
6401       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6402       if (lst.size() != 3)
6403         continue;
6404
6405       QString viewerTypStr = lst[0];
6406       QString viewIndexStr = lst[1];
6407       QString paramNameStr = lst[2];
6408
6409       bool ok;
6410       int viewIndex = viewIndexStr.toUInt(&ok);
6411       if (!ok) // bad conversion of view index to integer
6412         continue;
6413
6414       // viewers
6415       if (viewerTypStr == SVTK_Viewer::Type())
6416       {
6417         SMESH_Actor* aSmeshActor = 0;
6418         if (vtkActors.IsBound(viewIndex))
6419           aSmeshActor = vtkActors.Find(viewIndex);
6420
6421         QList<SUIT_ViewManager*> lst;
6422         getApp()->viewManagers(viewerTypStr, lst);
6423
6424         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6425         SUIT_ViewManager* vman = NULL;
6426         if (viewIndex >= 0 && viewIndex < lst.count())
6427           vman = lst.at(viewIndex);
6428
6429         if (paramNameStr == "Visibility")
6430         {
6431           if (!aSmeshActor && displayer() && vman)
6432           {
6433             SUIT_ViewModel* vmodel = vman->getViewModel();
6434             // SVTK view model can be casted to SALOME_View
6435             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6436
6437             // store displayed actor in a temporary map for quicker
6438             // access later when restoring other parameters
6439             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6440             vtkRenderer* Renderer = vtkView->getRenderer();
6441             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6442             vtkActorCollection* theActors = aCopy.GetActors();
6443             theActors->InitTraversal();
6444             bool isFound = false;
6445             vtkActor *ac = theActors->GetNextActor();
6446             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6447               if (ac->IsA("SMESH_Actor")) {
6448                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6449                 if (aGeomAc->hasIO()) {
6450                   Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6451                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6452                     isFound = true;
6453                     vtkActors.Bind(viewIndex, aGeomAc);
6454                   }
6455                 }
6456               }
6457             }
6458           }
6459         } // if (paramNameStr == "Visibility")
6460         else
6461         {
6462           // the rest properties "work" with SMESH_Actor
6463           if (aSmeshActor)
6464           {
6465             QString val ((*valuesIt).c_str());
6466
6467             // Representation
6468             if (paramNameStr == "Representation") {
6469               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6470             }
6471             // IsShrunk
6472             else if (paramNameStr == "IsShrunk") {
6473               if (val.toInt()) {
6474                 if (!aSmeshActor->IsShrunk())
6475                   aSmeshActor->SetShrink();
6476               }
6477               else {
6478                 if (aSmeshActor->IsShrunk())
6479                   aSmeshActor->UnShrink();
6480               }
6481             }
6482             // Displayed entities
6483             else if (paramNameStr == "Entities") {
6484               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6485               int aEntityMode = SMESH_Actor::eAllEntity;
6486               for ( int i = 0; i < mode.count(); i+=2 ) {
6487                 if ( i < mode.count()-1 ) {
6488                   QString type = mode[i];
6489                   bool val = mode[i+1].toInt();
6490                   if      ( type == "e" && !val )
6491                     aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6492                   else if ( type == "f" && !val )
6493                     aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6494                   else if ( type == "v" && !val )
6495                     aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6496                   else if ( type == "0d" && !val )
6497                     aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6498                   else if ( type == "b" && !val )
6499                     aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6500                 }
6501               }
6502               aSmeshActor->SetEntityMode( aEntityMode );
6503             }
6504             // Colors
6505             else if (paramNameStr == "Colors") {
6506               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6507               QColor nodeColor;
6508               QColor edgeColor;
6509               QColor faceColor;
6510               QColor volumeColor;
6511               QColor elem0dColor;
6512               QColor ballColor;
6513               QColor outlineColor;
6514               QColor orientationColor;
6515               int deltaF;
6516               int deltaV;
6517               QColor c;
6518               double r, g, b;
6519               bool bOk;
6520               // below lines are required to get default values for delta coefficients
6521               // of backface color for faces and color of reversed volumes
6522               SMESH::GetColor( "SMESH", "fill_color",   c, deltaF, "0,170,255|-100" );
6523               SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6524               for ( int i = 0; i < colors.count(); i++ ) {
6525                 QString type = colors[i];
6526                 if ( type == "surface" ) {
6527                   // face color is set by 3 values r:g:b, where
6528                   // - r,g,b - is rgb color components
6529                   if ( i+1 >= colors.count() ) break;                  // format error
6530                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6531                   if ( i+2 >= colors.count() ) break;                  // format error
6532                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6533                   if ( i+3 >= colors.count() ) break;                  // format error
6534                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6535                   faceColor.setRgbF( r, g, b );
6536                   i += 3;
6537                 }
6538                 else if ( type == "backsurface" ) {
6539                   // backface color can be defined in several ways
6540                   // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6541                   // - in latest versions, it is set as delta coefficient
6542                   bool rgbOk = false, deltaOk;
6543                   if ( i+1 >= colors.count() ) break;                  // format error
6544                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6545                   int delta = colors[i+1].toInt( &deltaOk );
6546                   i++;                                 // shift index
6547                   if ( i+1 < colors.count() )          // index is shifted to 1
6548                     g = colors[i+1].toDouble( &rgbOk );
6549                   if ( rgbOk ) i++;                    // shift index
6550                   if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6551                     b = colors[i+1].toDouble( &rgbOk );
6552                   if ( rgbOk ) i++;
6553                   // - as currently there's no way to set directly backsurface color as it was before,
6554                   // we ignore old dump where r,g,b triple was set
6555                   // - also we check that delta parameter is set properly
6556                   if ( !rgbOk && deltaOk )
6557                     deltaF = delta;
6558                 }
6559                 else if ( type == "volume" ) {
6560                   // volume color is set by 4 values r:g:b:delta, where
6561                   // - r,g,b - is a normal volume rgb color components
6562                   // - delta - is a reversed volume color delta coefficient
6563                   if ( i+1 >= colors.count() ) break;                  // format error
6564                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6565                   if ( i+2 >= colors.count() ) break;                  // format error
6566                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6567                   if ( i+3 >= colors.count() ) break;                  // format error
6568                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6569                   if ( i+4 >= colors.count() ) break;                  // format error
6570                   int delta = colors[i+4].toInt( &bOk );
6571                   if ( !bOk ) break;                                   // format error
6572                   volumeColor.setRgbF( r, g, b );
6573                   deltaV = delta;
6574                   i += 4;
6575                 }
6576                 else if ( type == "edge" ) {
6577                   // edge color is set by 3 values r:g:b, where
6578                   // - r,g,b - is rgb color components
6579                   if ( i+1 >= colors.count() ) break;                  // format error
6580                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6581                   if ( i+2 >= colors.count() ) break;                  // format error
6582                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6583                   if ( i+3 >= colors.count() ) break;                  // format error
6584                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6585                   edgeColor.setRgbF( r, g, b );
6586                   i += 3;
6587                 }
6588                 else if ( type == "node" ) {
6589                   // node color is set by 3 values r:g:b, where
6590                   // - r,g,b - is rgb color components
6591                   if ( i+1 >= colors.count() ) break;                  // format error
6592                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6593                   if ( i+2 >= colors.count() ) break;                  // format error
6594                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6595                   if ( i+3 >= colors.count() ) break;                  // format error
6596                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6597                   nodeColor.setRgbF( r, g, b );
6598                   i += 3;
6599                 }
6600                 else if ( type == "elem0d" ) {
6601                   // 0d element color is set by 3 values r:g:b, where
6602                   // - r,g,b - is rgb color components
6603                   if ( i+1 >= colors.count() ) break;                  // format error
6604                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6605                   if ( i+2 >= colors.count() ) break;                  // format error
6606                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6607                   if ( i+3 >= colors.count() ) break;                  // format error
6608                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6609                   elem0dColor.setRgbF( r, g, b );
6610                   i += 3;
6611                 }
6612                 else if ( type == "ball" ) {
6613                   // ball color is set by 3 values r:g:b, where
6614                   // - r,g,b - is rgb color components
6615                   if ( i+1 >= colors.count() ) break;                  // format error
6616                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6617                   if ( i+2 >= colors.count() ) break;                  // format error
6618                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6619                   if ( i+3 >= colors.count() ) break;                  // format error
6620                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6621                   ballColor.setRgbF( r, g, b );
6622                   i += 3;
6623                 }
6624                 else if ( type == "outline" ) {
6625                   // outline color is set by 3 values r:g:b, where
6626                   // - r,g,b - is rgb color components
6627                   if ( i+1 >= colors.count() ) break;                  // format error
6628                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6629                   if ( i+2 >= colors.count() ) break;                  // format error
6630                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6631                   if ( i+3 >= colors.count() ) break;                  // format error
6632                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6633                   outlineColor.setRgbF( r, g, b );
6634                   i += 3;
6635                 }
6636                 else if ( type == "orientation" ) {
6637                   // orientation color is set by 3 values r:g:b, where
6638                   // - r,g,b - is rgb color components
6639                   if ( i+1 >= colors.count() ) break;                  // format error
6640                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6641                   if ( i+2 >= colors.count() ) break;                  // format error
6642                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6643                   if ( i+3 >= colors.count() ) break;                  // format error
6644                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6645                   orientationColor.setRgbF( r, g, b );
6646                   i += 3;
6647                 }
6648               }
6649               // node color
6650               if ( nodeColor.isValid() )
6651                 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6652               // edge color
6653               if ( edgeColor.isValid() )
6654                 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6655               // face color
6656               if ( faceColor.isValid() )
6657                 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6658               // volume color
6659               if ( volumeColor.isValid() )
6660                 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6661               else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6662                 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6663               // 0d element color
6664               if ( elem0dColor.isValid() )
6665                 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6666               // ball color
6667               if ( ballColor.isValid() )
6668                 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6669               // outline color
6670               if ( outlineColor.isValid() )
6671                 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6672               // orientation color
6673               if ( orientationColor.isValid() )
6674                 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6675             }
6676             // Sizes
6677             else if (paramNameStr == "Sizes") {
6678               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6679               bool bOk;
6680               int lineWidth = -1;
6681               int outlineWidth = -1;
6682               int elem0dSize = -1;
6683               //int ballSize = -1;
6684               double ballDiameter = -1.0;
6685               double ballScale = -1.0;
6686               double shrinkSize = -1;
6687               double orientationSize = -1;
6688               bool orientation3d = false;
6689               for ( int i = 0; i < sizes.count(); i++ ) {
6690                 QString type = sizes[i];
6691                 if ( type == "line" ) {
6692                   // line (wireframe) 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                   lineWidth = v;
6696                   i++;
6697                 }
6698                 if ( type == "outline" ) {
6699                   // outline width 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                   outlineWidth = v;
6703                   i++;
6704                 }
6705                 else if ( type == "elem0d" ) {
6706                   // 0d element size is given as single integer value
6707                   if ( i+1 >= sizes.count() ) break;                    // format error
6708                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6709                   elem0dSize = v;
6710                   i++;
6711                 }
6712                 else if ( type == "ball" ) {
6713                   // balls are specified by two values: size:scale, where
6714                   // - size - is a integer value specifying size
6715                   // - scale - is a double value specifying scale factor
6716                   if ( i+1 >= sizes.count() ) break;                       // format error
6717                   //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6718                   double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6719                   if ( i+2 >= sizes.count() ) break;                       // format error
6720                   double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6721                   //ballSize = v1;
6722                   ballDiameter = v1;
6723                   ballScale = v2;
6724                   i += 2;
6725                 }
6726                 else if ( type == "shrink" ) {
6727                   // shrink factor is given as single floating point value
6728                   if ( i+1 >= sizes.count() ) break;                          // format error
6729                   double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break;  // format error
6730                   shrinkSize = v;
6731                   i++;
6732                 }
6733                 else if ( type == "orientation" ) {
6734                   // orientation vectors are specified by two values size:3d, where
6735                   // - size - is a floating point value specifying scale factor
6736                   // - 3d - is a boolean
6737                   if ( i+1 >= sizes.count() ) break;                          // format error
6738                   double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6739                   if ( i+2 >= sizes.count() ) break;                          // format error
6740                   int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break;       // format error
6741                   orientationSize = v1;
6742                   orientation3d = (bool)v2;
6743                   i += 2;
6744                 }
6745               }
6746               // line (wireframe) width
6747               if ( lineWidth > 0 )
6748                 aSmeshActor->SetLineWidth( lineWidth );
6749               // outline width
6750               if ( outlineWidth > 0 )
6751                 aSmeshActor->SetOutlineWidth( outlineWidth );
6752               else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6753                 aSmeshActor->SetOutlineWidth( lineWidth );
6754               // 0d element size
6755               if ( elem0dSize > 0 )
6756                 aSmeshActor->Set0DSize( elem0dSize );
6757               // ball size
6758               /*if ( ballSize > 0 )
6759                 aSmeshActor->SetBallSize( ballSize );*/
6760               // ball diameter
6761               if ( ballDiameter > 0 )
6762                 aSmeshActor->SetBallSize( ballDiameter );
6763               // ball scale
6764               if ( ballScale > 0.0 )
6765                 aSmeshActor->SetBallScale( ballScale );
6766               // shrink factor
6767               if ( shrinkSize > 0 )
6768                 aSmeshActor->SetShrinkFactor( shrinkSize );
6769               // orientation vectors
6770               if ( orientationSize > 0 ) {
6771                 aSmeshActor->SetFacesOrientationScale( orientationSize );
6772                 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6773               }
6774             }
6775             // Point marker
6776             else if (paramNameStr == "PointMarker") {
6777               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6778               if( data.count() >= 2 ) {
6779                 bool ok = false;
6780                 int aParam1 = data[1].toInt( &ok );
6781                 if( ok ) {
6782                   if( data[0] == "std" && data.count() == 3 ) {
6783                     int aParam2 = data[2].toInt( &ok );
6784                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6785                   }
6786                   else if( data[0] == "custom" ) {
6787                     VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6788                     if( markerIt != myMarkerMap.end() ) {
6789                       VTK::MarkerData aMarkerData = markerIt->second;
6790                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6791                     }
6792                   }
6793                 }
6794               }
6795             }
6796             // Opacity
6797             else if (paramNameStr == "Opacity") {
6798               aSmeshActor->SetOpacity(val.toFloat());
6799             }
6800             // Clipping
6801             else if (paramNameStr.startsWith("ClippingPlane")) {
6802               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6803               // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6804               // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6805               // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6806               // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6807               // new format - val looks like "Off" or "0" (plane id)
6808               // (note: in new format "Off" value is used only for consistency,
6809               //  so it is processed together with values in old format)
6810               bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6811               if( anIsOldFormat ) {
6812                 if (paramNameStr == "ClippingPlane1" || val == "Off")
6813                   aSmeshActor->RemoveAllClippingPlanes();
6814                 if (val != "Off") {
6815                   QList<SUIT_ViewManager*> lst;
6816                   getApp()->viewManagers(viewerTypStr, lst);
6817                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6818                   if (viewIndex >= 0 && viewIndex < lst.count()) {
6819                     SUIT_ViewManager* vman = lst.at(viewIndex);
6820                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6821
6822                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6823
6824                     SMESH::TActorList anActorList;
6825                     anActorList.push_back( aSmeshActor );
6826                     SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6827                     aPlane->myViewWindow = vtkView;
6828                     SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6829                     aPlane->PlaneMode = aMode;
6830                     bool isOpenGLClipping = ( bool )vals[1].toInt();
6831                     aPlane->IsOpenGLClipping = isOpenGLClipping;
6832                     if ( aMode == SMESH::Absolute ) {
6833                       aPlane->myAbsoluteOrientation = vals[2].toInt();
6834                       aPlane->X = vals[3].toFloat();
6835                       aPlane->Y = vals[4].toFloat();
6836                       aPlane->Z = vals[5].toFloat();
6837                       aPlane->Dx = vals[6].toFloat();
6838                       aPlane->Dy = vals[7].toFloat();
6839                       aPlane->Dz = vals[8].toFloat();
6840                     }
6841                     else if ( aMode == SMESH::Relative ) {
6842                       aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6843                       aPlane->myDistance = vals[3].toFloat();
6844                       aPlane->myAngle[0] = vals[4].toFloat();
6845                       aPlane->myAngle[1] = vals[5].toFloat();
6846                     }
6847
6848                     if( aPlane ) {
6849                       if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6850                         SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6851                         aClippingPlaneInfo.Plane = aPlane;
6852                         aClippingPlaneInfo.ActorList = anActorList;
6853                         aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6854                       }
6855                     }
6856                   }
6857                 }
6858               }
6859               else {
6860                 bool ok = false;
6861                 int aPlaneId = val.toInt( &ok );
6862                 if( ok && aPlaneId >= 0 ) {
6863                   bool anIsDefinedPlane = false;
6864                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6865                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6866                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6867                     TPlaneInfo& aPlaneInfo = *anIter;
6868                     if( aPlaneInfo.PlaneId == aPlaneId ) {
6869                       aPlaneInfo.ActorList.push_back( aSmeshActor );
6870                       anIsDefinedPlane = true;
6871                       break;
6872                     }
6873                   }
6874                   if( !anIsDefinedPlane ) {
6875                     TPlaneInfo aPlaneInfo;
6876                     aPlaneInfo.PlaneId = aPlaneId;
6877                     aPlaneInfo.ActorList.push_back( aSmeshActor );
6878                     aPlaneInfo.ViewManager = vman;
6879
6880                     // to make the list sorted by plane id
6881                     anIter = aPlaneInfoList.begin();
6882                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6883                       const TPlaneInfo& aPlaneInfoRef = *anIter;
6884                       if( aPlaneInfoRef.PlaneId > aPlaneId )
6885                         break;
6886                     }
6887                     aPlaneInfoList.insert( anIter, aPlaneInfo );
6888                   }
6889                 }
6890               }
6891             }
6892           } // if (aSmeshActor)
6893         } // other parameters than Visibility
6894       }
6895     } // for names/parameters iterator
6896   } // for entries iterator
6897
6898   // take into account planes with empty list of actors referred to them
6899   QList<SUIT_ViewManager*> aVMList;
6900   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6901
6902   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6903   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6904     int aViewId = aPlaneDataIter->first;
6905     if( aViewId >= 0 && aViewId < aVMList.count() ) {
6906       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6907
6908       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6909
6910       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6911       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6912       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6913         const TPlaneData& aPlaneData = *anIter2;
6914         int aPlaneId = aPlaneData.Id;
6915
6916         bool anIsFound = false;
6917         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6918         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6919           const TPlaneInfo& aPlaneInfo = *anIter3;
6920           if( aPlaneInfo.PlaneId == aPlaneId ) {
6921             anIsFound = true;
6922             break;
6923           }
6924         }
6925
6926         if( !anIsFound ) {
6927           TPlaneInfo aPlaneInfo; // ActorList field is empty
6928           aPlaneInfo.PlaneId = aPlaneId;
6929           aPlaneInfo.ViewManager = aViewManager;
6930
6931           // to make the list sorted by plane id
6932           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6933           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6934             const TPlaneInfo& aPlaneInfoRef = *anIter4;
6935             if( aPlaneInfoRef.PlaneId > aPlaneId )
6936               break;
6937           }
6938           aPlaneInfoList.insert( anIter4, aPlaneInfo );
6939         }
6940       }
6941     }
6942   }
6943
6944   // add clipping planes to actors according to the restored parameters
6945   // and update the clipping plane map
6946   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6947   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6948     int aViewId = anIter1->first;
6949     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6950
6951     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6952     if( anIter2 == aPlaneDataMap.end() )
6953       continue;
6954     const TPlaneDataList& aPlaneDataList = anIter2->second;
6955
6956     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6957     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6958       const TPlaneInfo& aPlaneInfo = *anIter3;
6959       int aPlaneId = aPlaneInfo.PlaneId;
6960       const TActorList& anActorList = aPlaneInfo.ActorList;
6961       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6962       if( !aViewManager )
6963         continue;
6964
6965       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6966       if( !aViewWindow )
6967         continue;
6968
6969       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6970
6971       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6972       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6973         const TPlaneData& aPlaneData = *anIter4;
6974         if( aPlaneData.Id == aPlaneId ) {
6975           SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6976           aPlane->myViewWindow = aViewWindow;
6977           aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6978           aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6979           if ( aPlane->PlaneMode == SMESH::Absolute ) {
6980             aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6981             aPlane->X = aPlaneData.X;
6982             aPlane->Y = aPlaneData.Y;
6983             aPlane->Z = aPlaneData.Z;
6984             aPlane->Dx = aPlaneData.Dx;
6985             aPlane->Dy = aPlaneData.Dy;
6986             aPlane->Dz = aPlaneData.Dz;
6987           }
6988           else if ( aPlane->PlaneMode == SMESH::Relative ) {
6989             aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6990             aPlane->myDistance = aPlaneData.Distance;
6991             aPlane->myAngle[0] = aPlaneData.Angle[0];
6992             aPlane->myAngle[1] = aPlaneData.Angle[1];
6993           }
6994           if( aPlane ) {
6995             if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6996               SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6997               aClippingPlaneInfo.Plane = aPlane;
6998               aClippingPlaneInfo.ActorList = anActorList;
6999               aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7000             }
7001           }
7002           break;
7003         }
7004       }
7005
7006     }
7007   }
7008
7009
7010   // update all VTK views
7011   QList<SUIT_ViewManager*> lst;
7012   getApp()->viewManagers(lst);
7013   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7014     SUIT_ViewModel* vmodel = (*it)->getViewModel();
7015     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7016       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7017       // set OpenGL clipping planes
7018       VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7019       vtkActorCollection* anAllActors = aCopy.GetActors();
7020       anAllActors->InitTraversal();
7021       while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7022         if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7023           anActor->SetOpenGLClippingPlane();
7024
7025       vtkView->getRenderer()->ResetCameraClippingRange();
7026       vtkView->Repaint();
7027     }
7028   }
7029 }
7030
7031 /*!
7032   \brief Adds preferences for dfont of VTK viewer
7033   \param label label
7034   \param pIf group identifier
7035   \param param parameter
7036   \return identifier of preferences
7037 */
7038 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7039 {
7040   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7041
7042   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7043
7044   QStringList fam;
7045   fam.append( tr( "SMESH_FONT_ARIAL" ) );
7046   fam.append( tr( "SMESH_FONT_COURIER" ) );
7047   fam.append( tr( "SMESH_FONT_TIMES" ) );
7048
7049   setPreferenceProperty( tfont, "fonts", fam );
7050
7051   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7052   if ( needSize ) f = f | QtxFontEdit::Size;
7053   setPreferenceProperty( tfont, "features", f );
7054
7055   return tfont;
7056 }
7057
7058 /*!
7059   \brief Actions after hypothesis edition
7060   Updates object browser after hypothesis edition
7061 */
7062 void SMESHGUI::onHypothesisEdit( int result )
7063 {
7064   if( result == 1 )
7065     SMESHGUI::Modified();
7066   updateObjBrowser( true );
7067 }
7068
7069 /*!
7070   \brief Actions after choosing menu of control modes
7071   Updates control mode actions according to current selection
7072 */
7073 void SMESHGUI::onUpdateControlActions()
7074 {
7075   SALOME_ListIO selected;
7076   if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7077     aSel->selectedObjects( selected );
7078
7079   SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7080   if ( selected.Extent() ) {
7081     if ( selected.First()->hasEntry() ) {
7082       if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7083         aControl = anActor->GetControlMode();
7084         SALOME_ListIteratorOfListIO it(selected);
7085         for ( it.Next(); it.More(); it.Next() ) {
7086           Handle(SALOME_InteractiveObject) anIO = it.Value();
7087           if ( anIO->hasEntry() ) {
7088             if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7089               if ( aControl != anActor->GetControlMode() ) {
7090                 aControl = SMESH_Actor::eNone;
7091                 break;
7092               }
7093             }
7094           }
7095         }
7096       }
7097     }
7098   }
7099
7100   int anAction = ActionToControl( aControl, true );
7101   if ( anAction)
7102     action( anAction )->setChecked( true );
7103   else {
7104     QMenu* send = (QMenu*)sender();
7105     QList<QAction*> actions = send->actions();
7106     for ( int i = 0; i < actions.size(); i++ )
7107       actions[i]->setChecked( false );
7108   }
7109 }
7110
7111
7112 /*!
7113   \brief Signal handler closing(SUIT_ViewWindow*) of a view
7114   \param pview view being closed
7115 */
7116 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7117 #ifndef DISABLE_PLOT2DVIEWER
7118   //Crear all Plot2d Viewers if need.
7119   SMESH::ClearPlot2Viewers(pview);
7120 #endif
7121   EmitSignalCloseView();
7122 }
7123
7124 void SMESHGUI::message( const QString& msg )
7125 {
7126   // dispatch message
7127   QStringList data = msg.split("/");
7128   if ( data.count() > 0 ) {
7129     if ( data.first() == "mesh_loading" ) {
7130       // get mesh entry
7131       QString entry = data.count() > 1 ? data[1] : QString();
7132       if ( entry.isEmpty() )
7133         return;
7134       // get study
7135       _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7136       // get mesh name
7137       _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7138       QString name;
7139       if ( obj )
7140         name = SMESH::fromUtf8(obj->GetName());
7141       if ( name.isEmpty() )
7142         return;
7143
7144       if ( data.last() == "stop" )
7145         application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7146       else
7147         application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7148       QApplication::processEvents();
7149     }
7150   }
7151 }
7152
7153 /*!
7154   \brief Connects or disconnects signals about activating and cloning view on the module slots
7155   \param pview view which is connected/disconnected
7156 */
7157 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7158   if(!pview)
7159     return;
7160
7161   SUIT_ViewManager* viewMgr = pview->getViewManager();
7162   if ( viewMgr ) {
7163     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7164                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7165
7166     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7167              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7168   }
7169 }
7170
7171 /*!
7172   \brief Return \c true if object can be renamed
7173 */
7174 bool SMESHGUI::renameAllowed( const QString& entry) const {
7175   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7176   if( !anApp )
7177     return false;
7178
7179   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7180   if( !appStudy )
7181     return false;
7182
7183   SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7184
7185   if(!obj)
7186     return false;
7187
7188   if(appStudy->isComponent(entry) || obj->isReference())
7189     return false;
7190
7191   // check type to prevent renaming of inappropriate objects
7192   int aType = SMESHGUI_Selection::type(qPrintable(entry));
7193   if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7194       aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7195       aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7196       aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7197       aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7198     return true;
7199
7200   return false;
7201 }
7202
7203 /*!
7204   Rename object by entry.
7205   \param entry entry of the object
7206   \param name new name of the object
7207   \brief Return \c true if rename operation finished successfully, \c false otherwise.
7208 */
7209 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7210
7211   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7212   if( !anApp )
7213     return false;
7214
7215   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7216
7217   if(!appStudy)
7218     return false;
7219
7220   _PTR(Study) aStudy = appStudy->studyDS();
7221
7222   if(!aStudy)
7223     return false;
7224
7225   bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7226   if ( aLocked ) {
7227     SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7228     return false;
7229   }
7230
7231
7232   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7233   _PTR(GenericAttribute) anAttr;
7234   _PTR(AttributeName) aName;
7235   if ( obj ) {
7236     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7237       aName = anAttr;
7238       // check type to prevent renaming of inappropriate objects
7239       int aType = SMESHGUI_Selection::type( qPrintable(entry));
7240       if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7241           aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7242           aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7243           aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7244           aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7245         if ( !name.isEmpty() ) {
7246           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7247
7248           // update name of group object and its actor
7249           Handle(SALOME_InteractiveObject) IObject =
7250             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7251
7252           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7253           if( !aGroupObject->_is_nil() ) {
7254             aGroupObject->SetName( qUtf8Printable(name) );
7255             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7256               anActor->setName( qUtf8Printable(name) );
7257           }
7258           return true;
7259         }
7260       }
7261     }
7262   }
7263   return false;
7264 }
7265
7266 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7267 {
7268   static QList<QColor> colors;
7269
7270   if ( colors.isEmpty() ) {
7271
7272     for (int s = 0; s < 2 ; s++)
7273     {
7274       for (int v = 100; v >= 40; v = v - 20)
7275       {
7276         for (int h = 0; h < 359 ; h = h + 60)
7277         {
7278           colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7279         }
7280       }
7281     }
7282   }
7283   static int currentColor = randomize( colors.size() );
7284
7285   SALOMEDS::Color color;
7286   color.R = (double)colors[currentColor].red()   / 255.0;
7287   color.G = (double)colors[currentColor].green() / 255.0;
7288   color.B = (double)colors[currentColor].blue()  / 255.0;
7289
7290   currentColor = (currentColor+1) % colors.count();
7291
7292   return color;
7293 }