src/SMESHGUI/SMESHGUI.cxx

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