src/SMESHGUI/SMESHGUI.cxx

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