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     startOperation( theCommandID );
2875     break;
2876   case SMESHOp::OpCopyMesh:
2877     {
2878       if (isStudyLocked()) break;
2879       EmitSignalDeactivateDialog();
2880       ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2881     }
2882     break;
2883   case SMESHOp::OpBuildCompoundMesh:
2884     {
2885       if (isStudyLocked()) break;
2886       EmitSignalDeactivateDialog();
2887       ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2888     }
2889     break;
2890
2891   case SMESHOp::OpDiagonalInversion:
2892   case SMESHOp::OpUnionOfTwoTriangle:
2893     {
2894       if ( !vtkwnd )
2895       {
2896         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2897         break;
2898       }
2899
2900       if ( isStudyLocked() )
2901         break;
2902       if ( warnOnGeomModif() )
2903         break; // action forbiden as geometry modified
2904
2905       /*Standard_Boolean aRes;
2906       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2907       if ( aMesh->_is_nil() )
2908       {
2909         SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2910           tr( "SMESH_BAD_SELECTION" ) );
2911         break;
2912       }
2913       */
2914       EmitSignalDeactivateDialog();
2915       if ( theCommandID == SMESHOp::OpDiagonalInversion )
2916         ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2917       else
2918         ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2919       break;
2920     }
2921   case SMESHOp::OpOrientation:
2922   case SMESHOp::OpUnionOfTriangles:
2923   case SMESHOp::OpCuttingOfQuadrangles:
2924   case SMESHOp::OpSplitVolumes:
2925     {
2926       if ( !vtkwnd )
2927       {
2928         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2929         break;
2930       }
2931
2932       if ( isStudyLocked() )
2933         break;
2934       if ( warnOnGeomModif() )
2935         break; // action forbiden as geometry modified
2936
2937       EmitSignalDeactivateDialog();
2938       SMESHGUI_MultiEditDlg* aDlg = NULL;
2939       if ( theCommandID == SMESHOp::OpOrientation )
2940         aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2941       else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2942         aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2943       else if ( theCommandID == SMESHOp::OpSplitVolumes )
2944         aDlg = new SMESHGUI_SplitVolumesDlg(this);
2945       else
2946         aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2947
2948       aDlg->show();
2949       break;
2950     }
2951   case SMESHOp::OpSmoothing:
2952     {
2953       if(isStudyLocked()) break;
2954       if ( warnOnGeomModif() )
2955         break; // action forbiden as geometry modified
2956       if( vtkwnd ) {
2957         EmitSignalDeactivateDialog();
2958         ( new SMESHGUI_SmoothingDlg( this ) )->show();
2959       }
2960       else {
2961         SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2962       }
2963       break;
2964     }
2965   case SMESHOp::OpExtrusion:
2966     {
2967       if (isStudyLocked()) break;
2968       if ( warnOnGeomModif() )
2969         break; // action forbiden as geometry modified
2970       if (vtkwnd) {
2971         EmitSignalDeactivateDialog();
2972         ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2973       } else {
2974         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2975       }
2976       break;
2977     }
2978   case SMESHOp::OpExtrusionAlongAPath:
2979     {
2980       if (isStudyLocked()) break;
2981       if ( warnOnGeomModif() )
2982         break; // action forbiden as geometry modified
2983       if (vtkwnd) {
2984         EmitSignalDeactivateDialog();
2985         ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2986       } else {
2987         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2988       }
2989       break;
2990     }
2991   case SMESHOp::OpRevolution:
2992     {
2993       if(isStudyLocked()) break;
2994       if ( warnOnGeomModif() )
2995         break; // action forbiden as geometry modified
2996       if( vtkwnd ) {
2997         EmitSignalDeactivateDialog();
2998         ( new SMESHGUI_RevolutionDlg( this ) )->show();
2999       }
3000       else {
3001         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3002       }
3003       break;
3004     }
3005   case SMESHOp::OpPatternMapping:
3006     {
3007       if ( isStudyLocked() )
3008         break;
3009       if ( warnOnGeomModif() )
3010         break; // action forbiden as geometry modified
3011       if ( vtkwnd )
3012       {
3013         EmitSignalDeactivateDialog();
3014         ( new SMESHGUI_MeshPatternDlg( this ) )->show();
3015       }
3016       else {
3017         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3018       }
3019       break;
3020     }
3021
3022   // Adaptation - begin
3023   case SMESHOp::OpUniformRefinement:
3024   case SMESHOp::OpHONewCase:
3025   case SMESHOp::OpHOCaseFollow:
3026   case SMESHOp::OpHONewIter:
3027   case SMESHOp::OpHOIterCompute:
3028   case SMESHOp::OpHOIterComputePublish:
3029   case SMESHOp::OpHOEdit:
3030   case SMESHOp::OpHODelete:
3031   case SMESHOp::OpMGAdapt:
3032     {
3033       SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3034       SMESHGUI_AdaptDlg *aDlg = new SMESHGUI_AdaptDlg( this, theCommandID, aMesh);
3035       aDlg->show();
3036     }
3037   // Adaptation - end
3038
3039   case SMESHOp::OpSplitBiQuadratic:
3040   case SMESHOp::OpConvertMeshToQuadratic:
3041   case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3042   case SMESHOp::OpReorientFaces:
3043   case SMESHOp::OpCreateGeometryGroup:
3044     {
3045       if ( warnOnGeomModif() )
3046         break; // action forbiden as geometry modified
3047       startOperation( theCommandID );
3048       break;
3049     }
3050   case SMESHOp::OpCreateGroup:
3051     {
3052       if ( !vtkwnd )
3053       {
3054         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3055         break;
3056       }
3057
3058       if(isStudyLocked()) break;
3059       if ( warnOnGeomModif() )
3060         break; // action forbiden as geometry modified
3061       EmitSignalDeactivateDialog();
3062       SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3063
3064       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3065       SALOME_ListIO selected;
3066       if( aSel )
3067         aSel->selectedObjects( selected );
3068
3069       int nbSel = selected.Extent();
3070       if (nbSel == 1) {
3071         // check if mesh is selected
3072         aMesh = SMESH::GetMeshByIO( selected.First() );
3073       }
3074       SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3075       aDlg->show();
3076       break;
3077     }
3078
3079   case SMESHOp::OpConstructGroup:
3080     {
3081       if ( !vtkwnd )
3082       {
3083         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3084         break;
3085       }
3086
3087       if(isStudyLocked()) break;
3088       if ( warnOnGeomModif() )
3089         break; // action forbiden as geometry modified
3090       EmitSignalDeactivateDialog();
3091
3092       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3093       SALOME_ListIO selected;
3094       if( aSel )
3095         aSel->selectedObjects( selected );
3096
3097       int nbSel = selected.Extent();
3098       if (nbSel == 1) {
3099         // check if submesh is selected
3100         Handle(SALOME_InteractiveObject) IObject = selected.First();
3101         if (IObject->hasEntry()) {
3102           _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3103           if( aSObj ) {
3104             SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3105             if (!aSubMesh->_is_nil()) {
3106               try {
3107                 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3108                 // get submesh elements list by types
3109                 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3110                 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3111                 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3112                 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3113                 // create group for each type o elements
3114                 QString aName = IObject->getName();
3115                 QStringList anEntryList;
3116                 if (aNodes->length() > 0) {
3117                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3118                   aGroup->Add(aNodes.inout());
3119                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3120                     anEntryList.append( aSObject->GetID().c_str() );
3121                 }
3122                 if (aEdges->length() > 0) {
3123                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3124                   aGroup->Add(aEdges.inout());
3125                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3126                     anEntryList.append( aSObject->GetID().c_str() );
3127                 }
3128                 if (aFaces->length() > 0) {
3129                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3130                   aGroup->Add(aFaces.inout());
3131                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3132                     anEntryList.append( aSObject->GetID().c_str() );
3133                 }
3134                 if (aVolumes->length() > 0) {
3135                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3136                   aGroup->Add(aVolumes.inout());
3137                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3138                     anEntryList.append( aSObject->GetID().c_str() );
3139                 }
3140                 updateObjBrowser();
3141                 anApp->browseObjects( anEntryList );
3142               }
3143               catch(const SALOME::SALOME_Exception & S_ex){
3144                 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3145               }
3146             }
3147           }
3148         }
3149       }
3150       else if(nbSel==0) {
3151         SUIT_MessageBox::warning(desktop(),
3152                                  tr("SMESH_WRN_WARNING"),
3153                                  tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3154       }
3155       break;
3156     }
3157
3158   case SMESHOp::OpEditGroup:
3159     {
3160       if ( !vtkwnd )
3161       {
3162         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3163         break;
3164       }
3165
3166       if(isStudyLocked()) break;
3167       if ( warnOnGeomModif() )
3168         break; // action forbiden as geometry modified
3169       EmitSignalDeactivateDialog();
3170
3171       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3172       SALOME_ListIO selected;
3173       if( aSel )
3174         aSel->selectedObjects( selected );
3175
3176       SALOME_ListIteratorOfListIO It (selected);
3177       int nbSelectedGroups = 0;
3178       for ( ; It.More(); It.Next() )
3179       {
3180         SMESH::SMESH_GroupBase_var aGroup =
3181           SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3182         if (!aGroup->_is_nil()) {
3183           nbSelectedGroups++;
3184           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3185           aDlg->show();
3186         }
3187       }
3188       if (nbSelectedGroups == 0)
3189         {
3190           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3191           aDlg->show();
3192         }
3193       break;
3194     }
3195
3196   case SMESHOp::OpAddElemGroupPopup:     // Add elements to group
3197     {
3198       if(isStudyLocked()) break;
3199       if (myState == 800) {
3200         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3201         if (aDlg) aDlg->onAdd();
3202       }
3203       break;
3204     }
3205
3206   case SMESHOp::OpRemoveElemGroupPopup:  // Remove elements from group
3207     {
3208       if(isStudyLocked()) break;
3209       if (myState == 800) {
3210         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3211         if (aDlg) aDlg->onRemove();
3212       }
3213       break;
3214     }
3215
3216   case SMESHOp::OpEditGeomGroupAsGroup:
3217     {
3218       if ( !vtkwnd )
3219       {
3220         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3221         break;
3222       }
3223
3224       if(isStudyLocked()) break;
3225       EmitSignalDeactivateDialog();
3226
3227       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3228       SALOME_ListIO selected;
3229       if( aSel )
3230         aSel->selectedObjects( selected );
3231
3232       SALOME_ListIteratorOfListIO It (selected);
3233       for ( ; It.More(); It.Next() )
3234       {
3235         SMESH::SMESH_GroupOnGeom_var aGroup =
3236           SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3237         if (!aGroup->_is_nil()) {
3238           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3239           aDlg->show();
3240         }
3241         else
3242         {
3243           SMESH::SMESH_GroupOnFilter_var aGroup =
3244             SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3245           if (!aGroup->_is_nil()) {
3246             SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3247             aDlg->show();
3248           }
3249         }
3250       }
3251       break;
3252     }
3253
3254     case SMESHOp::OpUnionGroups:
3255     case SMESHOp::OpIntersectGroups:
3256     case SMESHOp::OpCutGroups:
3257     {
3258       if ( !vtkwnd )
3259       {
3260         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3261         break;
3262       }
3263
3264       if ( isStudyLocked() )
3265         break;
3266       if ( warnOnGeomModif() )
3267         break; // action forbiden as geometry modified
3268
3269       EmitSignalDeactivateDialog();
3270
3271       SMESHGUI_GroupOpDlg* aDlg = 0;
3272       if ( theCommandID == SMESHOp::OpUnionGroups )
3273         aDlg = new SMESHGUI_UnionGroupsDlg( this );
3274       else if ( theCommandID == SMESHOp::OpIntersectGroups )
3275         aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3276       else
3277         aDlg = new SMESHGUI_CutGroupsDlg( this );
3278
3279       aDlg->show();
3280
3281       break;
3282     }
3283
3284     case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3285     {
3286       if ( isStudyLocked() )
3287         break;
3288       if ( warnOnGeomModif() )
3289         break; // action forbiden as geometry modified
3290
3291       EmitSignalDeactivateDialog();
3292       SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3293       aDlg->show();
3294
3295       break;
3296     }
3297
3298     case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3299     {
3300       if ( isStudyLocked() )
3301         break;
3302       if ( warnOnGeomModif() )
3303         break; // action forbiden as geometry modified
3304
3305       EmitSignalDeactivateDialog();
3306       SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3307       aDlg->show();
3308
3309       break;
3310     }
3311
3312     case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3313     {
3314       if ( !vtkwnd )
3315       {
3316         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3317         break;
3318       }
3319
3320       if ( isStudyLocked() )
3321         break;
3322
3323       EmitSignalDeactivateDialog();
3324
3325       ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3326       break;
3327     }
3328
3329   case SMESHOp::OpMeshInformation:
3330   case SMESHOp::OpWhatIs:
3331     {
3332       int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3333       EmitSignalDeactivateDialog();
3334       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3335       SALOME_ListIO selected;
3336       if( aSel )
3337         aSel->selectedObjects( selected );
3338
3339       if ( selected.Extent() > 1 ) { // a dlg for each IO
3340         SALOME_ListIteratorOfListIO It( selected );
3341         for ( ; It.More(); It.Next() ) {
3342           SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3343           dlg->showInfo( It.Value() );
3344           dlg->show();
3345         }
3346       }
3347       else {
3348         SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3349         dlg->show();
3350       }
3351       break;
3352     }
3353
3354   case SMESHOp::OpFindElementByPoint:
3355     {
3356       startOperation( theCommandID );
3357       break;
3358     }
3359
3360   case SMESHOp::OpEditHypothesis:
3361     {
3362       if(isStudyLocked()) break;
3363       if ( warnOnGeomModif() )
3364         break; // action forbiden as geometry modified
3365
3366       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3367       SALOME_ListIO selected;
3368       if( aSel )
3369         aSel->selectedObjects( selected );
3370
3371       int nbSel = selected.Extent();
3372
3373       if (nbSel == 1) {
3374         Handle(SALOME_InteractiveObject) anIObject = selected.First();
3375         SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3376
3377         if ( !aHypothesis->_is_nil() )
3378         {
3379           SMESHGUI_GenericHypothesisCreator* aCreator =
3380             SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3381           if (aCreator)
3382           {
3383             // set geometry of mesh and sub-mesh to aCreator
3384             aSel->selectedObjects( selected, "",  /*convertReferences=*/false);
3385             if ( selected.Extent() == 1 )
3386             {
3387               QString subGeomID, meshGeomID;
3388               Handle(SALOME_InteractiveObject) hypIO = selected.First();
3389               if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3390               {
3391                 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3392                 aCreator->setShapeEntry( subGeomID );
3393                 aCreator->setMainShapeEntry( meshGeomID );
3394               }
3395             }
3396
3397             aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3398           }
3399           else
3400           {
3401             // report error
3402           }
3403         }
3404       }
3405       break;
3406     }
3407   case SMESHOp::OpUnassign:                      // REMOVE HYPOTHESIS / ALGORITHMS
3408     {
3409       if(isStudyLocked()) break;
3410       if ( warnOnGeomModif() )
3411         break; // action forbiden as geometry modified
3412       SUIT_OverrideCursor wc;
3413
3414       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3415       SALOME_ListIO selected;
3416       if( aSel )
3417         aSel->selectedObjects( selected, QString::null, false );
3418
3419       SALOME_ListIteratorOfListIO It(selected);
3420       for (int i = 0; It.More(); It.Next(), i++) {
3421         Handle(SALOME_InteractiveObject) IObject = It.Value();
3422         SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3423       }
3424       SALOME_ListIO l1;
3425       aSel->setSelectedObjects( l1 );
3426       updateObjBrowser();
3427       break;
3428     }
3429
3430   case SMESHOp::OpElem0D:
3431   case SMESHOp::OpBall:
3432   case SMESHOp::OpEdge:
3433   case SMESHOp::OpTriangle:
3434   case SMESHOp::OpQuadrangle:
3435   case SMESHOp::OpPolygon:
3436   case SMESHOp::OpTetrahedron:
3437   case SMESHOp::OpHexahedron:
3438   case SMESHOp::OpPentahedron:
3439   case SMESHOp::OpPyramid:
3440   case SMESHOp::OpHexagonalPrism:
3441     {
3442       if(isStudyLocked()) break;
3443       if ( warnOnGeomModif() )
3444         break; // action forbiden as geometry modified
3445       if ( vtkwnd ) {
3446         EmitSignalDeactivateDialog();
3447         SMDSAbs_EntityType type = SMDSEntity_Edge;
3448         switch (theCommandID) {
3449         case SMESHOp::OpElem0D: type = SMDSEntity_0D;                      break;
3450         case SMESHOp::OpBall: type = SMDSEntity_Ball;                      break;
3451         case SMESHOp::OpTriangle: type = SMDSEntity_Triangle;              break;
3452         case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle;          break;
3453         case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra;              break;
3454         case SMESHOp::OpPolygon: type = SMDSEntity_Polygon;                break;
3455         case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa;                break;
3456         case SMESHOp::OpPentahedron: type = SMDSEntity_Penta;              break;
3457         case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid;                break;
3458         case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3459         default:;
3460         }
3461         ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3462       }
3463       else {
3464         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3465       }
3466       break;
3467     }
3468   case SMESHOp::OpPolyhedron:
3469     {
3470       if(isStudyLocked()) break;
3471       if ( warnOnGeomModif() )
3472         break; // action forbiden as geometry modified
3473       if ( vtkwnd ) {
3474         EmitSignalDeactivateDialog();
3475         ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3476       }
3477       else {
3478         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3479       }
3480       break;
3481     }
3482   case SMESHOp::OpQuadraticEdge:
3483   case SMESHOp::OpQuadraticTriangle:
3484   case SMESHOp::OpBiQuadraticTriangle:
3485   case SMESHOp::OpQuadraticQuadrangle:
3486   case SMESHOp::OpBiQuadraticQuadrangle:
3487   case SMESHOp::OpQuadraticPolygon:
3488   case SMESHOp::OpQuadraticTetrahedron:
3489   case SMESHOp::OpQuadraticPyramid:
3490   case SMESHOp::OpQuadraticPentahedron:
3491   case SMESHOp::OpBiQuadraticPentahedron:
3492   case SMESHOp::OpQuadraticHexahedron:
3493   case SMESHOp::OpTriQuadraticHexahedron:
3494     {
3495       if(isStudyLocked()) break;
3496       if ( warnOnGeomModif() )
3497         break; // action forbiden as geometry modified
3498       if ( vtkwnd ) {
3499         EmitSignalDeactivateDialog();
3500         SMDSAbs_EntityType type = SMDSEntity_Last;
3501
3502         switch (theCommandID) {
3503         case SMESHOp::OpQuadraticEdge:          type = SMDSEntity_Quad_Edge; break;
3504         case SMESHOp::OpQuadraticTriangle:      type = SMDSEntity_Quad_Triangle; break;
3505         case SMESHOp::OpBiQuadraticTriangle:    type = SMDSEntity_BiQuad_Triangle; break;
3506         case SMESHOp::OpQuadraticQuadrangle:    type = SMDSEntity_Quad_Quadrangle; break;
3507         case SMESHOp::OpBiQuadraticQuadrangle:  type = SMDSEntity_BiQuad_Quadrangle; break;
3508         case SMESHOp::OpQuadraticPolygon:       type = SMDSEntity_Quad_Polygon; break;
3509         case SMESHOp::OpQuadraticTetrahedron:   type = SMDSEntity_Quad_Tetra; break;
3510         case SMESHOp::OpQuadraticPyramid:       type = SMDSEntity_Quad_Pyramid; break;
3511         case SMESHOp::OpQuadraticPentahedron:   type = SMDSEntity_Quad_Penta; break;
3512         case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3513         case SMESHOp::OpQuadraticHexahedron:    type = SMDSEntity_Quad_Hexa; break;
3514         case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3515         default: break;
3516         }
3517         if ( type != SMDSEntity_Last )
3518           ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3519       }
3520       else {
3521         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3522                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3523       }
3524       break;
3525     }
3526   case SMESHOp::OpRemoveNodes:
3527     {
3528       if(isStudyLocked()) break;
3529       if ( warnOnGeomModif() )
3530         break; // action forbiden as geometry modified
3531       if ( vtkwnd ) {
3532         EmitSignalDeactivateDialog();
3533         ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3534       }
3535       else {
3536         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3537                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3538       }
3539       break;
3540     }
3541   case SMESHOp::OpRemoveElements:                                    // REMOVES ELEMENTS
3542     {
3543       if(isStudyLocked()) break;
3544       if ( warnOnGeomModif() )
3545         break; // action forbiden as geometry modified
3546       if( vtkwnd ) {
3547         EmitSignalDeactivateDialog();
3548         ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3549       }
3550       else
3551         {
3552           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3553                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3554         }
3555       break;
3556     }
3557   case SMESHOp::OpClearMesh: {
3558
3559     if(isStudyLocked()) break;
3560     if ( warnOnGeomModif() )
3561       break; // action forbiden as geometry modified
3562
3563     SALOME_ListIO selected;
3564     if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3565       aSel->selectedObjects( selected );
3566
3567     SUIT_OverrideCursor wc;
3568     SALOME_ListIteratorOfListIO It (selected);
3569     for ( ; It.More(); It.Next() )
3570     {
3571       Handle(SALOME_InteractiveObject) IOS = It.Value();
3572       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3573       if ( aMesh->_is_nil()) continue;
3574       try {
3575         aMesh->Clear();
3576         if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3577           SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3578         _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3579         // hide groups and submeshes
3580         _PTR(ChildIterator) anIter =
3581           SMESH::getStudy()->NewChildIterator( aMeshSObj );
3582         for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3583         {
3584           _PTR(SObject) so = anIter->Value();
3585           SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3586         }
3587       }
3588       catch (const SALOME::SALOME_Exception& S_ex){
3589         wc.suspend();
3590         SalomeApp_Tools::QtCatchCorbaException(S_ex);
3591         wc.resume();
3592       }
3593     }
3594     SMESH::UpdateView();
3595     updateObjBrowser();
3596     break;
3597   }
3598   case SMESHOp::OpRemoveOrphanNodes:
3599     {
3600       if(isStudyLocked()) break;
3601       if ( warnOnGeomModif() )
3602         break; // action forbiden as geometry modified
3603       SALOME_ListIO selected;
3604       if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3605         aSel->selectedObjects( selected );
3606       if ( selected.Extent() == 1 ) {
3607         Handle(SALOME_InteractiveObject) anIO = selected.First();
3608         SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3609         if ( !aMesh->_is_nil() ) {
3610           bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3611                                                     tr( "SMESH_WARNING" ),
3612                                                     tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3613                                                     SUIT_MessageBox::Yes |
3614                                                     SUIT_MessageBox::No,
3615                                                     SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3616           if( confirm ) {
3617             try {
3618               SUIT_OverrideCursor wc;
3619               SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3620               int removed = aMeshEditor->RemoveOrphanNodes();
3621               SUIT_MessageBox::information(SMESHGUI::desktop(),
3622                                            tr("SMESH_INFORMATION"),
3623                                            tr("NB_NODES_REMOVED").arg(removed));
3624               if ( removed > 0 ) {
3625                 SMESH::UpdateView();
3626                 SMESHGUI::Modified();
3627               }
3628             }
3629             catch (const SALOME::SALOME_Exception& S_ex) {
3630               SalomeApp_Tools::QtCatchCorbaException(S_ex);
3631             }
3632             catch (...) {
3633             }
3634           }
3635         }
3636       }
3637       break;
3638     }
3639   case SMESHOp::OpRenumberingNodes:
3640     {
3641       if(isStudyLocked()) break;
3642       if ( warnOnGeomModif() )
3643         break; // action forbiden as geometry modified
3644       if( vtkwnd ) {
3645         EmitSignalDeactivateDialog();
3646         ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3647       }
3648       else
3649         {
3650           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3651                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3652         }
3653       break;
3654     }
3655   case SMESHOp::OpRenumberingElements:
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, 1 ) )->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::OpTranslation:
3672     {
3673       if(isStudyLocked()) break;
3674       if ( warnOnGeomModif() )
3675         break; // action forbiden as geometry modified
3676       if ( vtkwnd ) {
3677         EmitSignalDeactivateDialog();
3678         ( new SMESHGUI_TranslationDlg( this ) )->show();
3679       }
3680       else {
3681         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3682                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3683       }
3684       break;
3685     }
3686   case SMESHOp::OpRotation:
3687     {
3688       if(isStudyLocked()) break;
3689       if ( warnOnGeomModif() )
3690         break; // action forbiden as geometry modified
3691       if( vtkwnd ) {
3692         EmitSignalDeactivateDialog();
3693         ( new SMESHGUI_RotationDlg( this ) )->show();
3694       }
3695       else {
3696         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3697                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3698       }
3699       break;
3700     }
3701   case SMESHOp::OpSymmetry:
3702     {
3703       if(isStudyLocked()) break;
3704       if ( warnOnGeomModif() )
3705         break; // action forbiden as geometry modified
3706       if(vtkwnd) {
3707         EmitSignalDeactivateDialog();
3708         ( new SMESHGUI_SymmetryDlg( this ) )->show();
3709       }
3710       else {
3711         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3712                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3713       }
3714       break;
3715     }
3716   case SMESHOp::OpScale:
3717     {
3718       if(isStudyLocked()) break;
3719       if ( warnOnGeomModif() )
3720         break; // action forbiden as geometry modified
3721       if ( vtkwnd ) {
3722         EmitSignalDeactivateDialog();
3723         ( new SMESHGUI_ScaleDlg( this ) )->show();
3724       }
3725       else {
3726         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3727                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3728       }
3729       break;
3730     }
3731
3732   case SMESHOp::OpOffset:
3733     {
3734       if(isStudyLocked()) break;
3735       if ( warnOnGeomModif() )
3736         break; // action forbiden as geometry modified
3737       if ( vtkwnd ) {
3738         EmitSignalDeactivateDialog();
3739         ( new SMESHGUI_OffsetDlg( 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::OpSewing:
3749     {
3750       if(isStudyLocked()) break;
3751       if ( warnOnGeomModif() )
3752         break; // action forbiden as geometry modified
3753       if(vtkwnd) {
3754         EmitSignalDeactivateDialog();
3755         ( new SMESHGUI_SewingDlg( 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   case SMESHOp::OpMergeNodes:
3764     {
3765       if(isStudyLocked()) break;
3766       if ( warnOnGeomModif() )
3767         break; // action forbiden as geometry modified
3768       if(vtkwnd) {
3769         EmitSignalDeactivateDialog();
3770         ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3771       }
3772       else {
3773         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3774                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3775       }
3776       break;
3777     }
3778   case SMESHOp::OpMergeElements:
3779     {
3780       if (isStudyLocked()) break;
3781       if ( warnOnGeomModif() )
3782         break; // action forbiden as geometry modified
3783       if (vtkwnd) {
3784         EmitSignalDeactivateDialog();
3785         ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3786       } else {
3787         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3788                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3789       }
3790       break;
3791     }
3792
3793   case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3794     if ( warnOnGeomModif() )
3795       break; // action forbiden as geometry modified
3796     startOperation( SMESHOp::OpMoveNode );
3797     break;
3798
3799   case SMESHOp::OpDuplicateNodes:
3800     {
3801       if(isStudyLocked()) break;
3802       if ( warnOnGeomModif() )
3803         break; // action forbiden as geometry modified
3804       if ( vtkwnd ) {
3805         EmitSignalDeactivateDialog();
3806         ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3807       }
3808       else {
3809         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3810                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3811       }
3812       break;
3813     }
3814
3815   case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3816     if ( warnOnGeomModif() )
3817       break; // action forbiden as geometry modified
3818     startOperation( SMESHOp::OpElem0DOnElemNodes );
3819     break;
3820
3821   case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3822   {
3823     static QList<int> aTypes;
3824     if ( aTypes.isEmpty() )
3825     {
3826       aTypes.append( SMESH::NODE );
3827       aTypes.append( SMESH::EDGE );
3828       aTypes.append( SMESH::FACE );
3829       aTypes.append( SMESH::VOLUME );
3830     }
3831     if (!myFilterLibraryDlg)
3832       myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3833     else if (myFilterLibraryDlg->isHidden())
3834       myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3835     myFilterLibraryDlg->raise();
3836   }
3837   break;
3838   // CONTROLS
3839   case SMESHOp::OpFreeNode:
3840   case SMESHOp::OpEqualNode:
3841   case SMESHOp::OpNodeConnectivityNb:
3842   case SMESHOp::OpFreeEdge:
3843   case SMESHOp::OpFreeBorder:
3844   case SMESHOp::OpLength:
3845   case SMESHOp::OpConnection:
3846   case SMESHOp::OpEqualEdge:
3847   case SMESHOp::OpFreeFace:
3848   case SMESHOp::OpBareBorderFace:
3849   case SMESHOp::OpOverConstrainedFace:
3850   case SMESHOp::OpLength2D:
3851   case SMESHOp::OpDeflection2D:
3852   case SMESHOp::OpConnection2D:
3853   case SMESHOp::OpArea:
3854   case SMESHOp::OpTaper:
3855   case SMESHOp::OpAspectRatio:
3856   case SMESHOp::OpMinimumAngle:
3857   case SMESHOp::OpWarpingAngle:
3858   case SMESHOp::OpSkew:
3859   case SMESHOp::OpMaxElementLength2D:
3860   case SMESHOp::OpEqualFace:
3861   case SMESHOp::OpAspectRatio3D:
3862   case SMESHOp::OpVolume:
3863   case SMESHOp::OpMaxElementLength3D:
3864   case SMESHOp::OpBareBorderVolume:
3865   case SMESHOp::OpOverConstrainedVolume:
3866   case SMESHOp::OpEqualVolume:
3867     if ( vtkwnd ) {
3868
3869       LightApp_SelectionMgr* mgr = selectionMgr();
3870       SALOME_ListIO selected; mgr->selectedObjects( selected );
3871
3872       if( !selected.IsEmpty() ) {
3873         SUIT_OverrideCursor wc;
3874         ::Control( theCommandID );
3875         break;
3876       }
3877       SUIT_MessageBox::warning(desktop(),
3878                                tr( "SMESH_WRN_WARNING" ),
3879                                tr( "SMESH_BAD_SELECTION" ) );
3880       break;
3881     }
3882     else {
3883       SUIT_MessageBox::warning(desktop(),
3884                                tr( "SMESH_WRN_WARNING" ),
3885                                tr( "NOT_A_VTK_VIEWER" ) );
3886     }
3887     break;
3888   case SMESHOp::OpOverallMeshQuality:
3889     OverallMeshQuality();
3890     break;
3891   case SMESHOp::OpNumberingNodes:
3892     {
3893       SUIT_OverrideCursor wc;
3894       LightApp_SelectionMgr* mgr = selectionMgr();
3895       SALOME_ListIO selected; mgr->selectedObjects( selected );
3896
3897       SALOME_ListIteratorOfListIO it(selected);
3898       for( ; it.More(); it.Next()) {
3899         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3900         if(anIObject->hasEntry()) {
3901           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3902             anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3903           }
3904         }
3905       }
3906       break;
3907     }
3908   case SMESHOp::OpNumberingElements:
3909     {
3910       SUIT_OverrideCursor wc;
3911       LightApp_SelectionMgr* mgr = selectionMgr();
3912       SALOME_ListIO selected; mgr->selectedObjects( selected );
3913
3914       SALOME_ListIteratorOfListIO it(selected);
3915       for( ; it.More(); it.Next()) {
3916         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3917         if(anIObject->hasEntry())
3918           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3919             anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3920           }
3921       }
3922       break;
3923     }
3924   case SMESHOp::OpPropertiesLength:
3925   case SMESHOp::OpPropertiesArea:
3926   case SMESHOp::OpPropertiesVolume:
3927   case SMESHOp::OpMinimumDistance:
3928   case SMESHOp::OpBoundingBox:
3929   case SMESHOp::OpAngle:
3930     {
3931       int page = SMESHGUI_MeasureDlg::MinDistance;
3932       if ( theCommandID == SMESHOp::OpBoundingBox )
3933         page = SMESHGUI_MeasureDlg::BoundingBox;
3934       else if ( theCommandID == SMESHOp::OpPropertiesLength )
3935         page = SMESHGUI_MeasureDlg::Length;
3936       else if ( theCommandID == SMESHOp::OpPropertiesArea )
3937         page = SMESHGUI_MeasureDlg::Area;
3938       else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3939         page = SMESHGUI_MeasureDlg::Volume;
3940       else if ( theCommandID == SMESHOp::OpAngle )
3941         page = SMESHGUI_MeasureDlg::Angle;
3942
3943       EmitSignalDeactivateDialog();
3944       SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3945       dlg->show();
3946       break;
3947     }
3948   case SMESHOp::OpSortChild:
3949     ::sortChildren();
3950     break;
3951   case SMESHOp::OpBreakLink:
3952     ::breakShaperLink();
3953     break;
3954
3955   }
3956
3957   anApp->updateActions(); //SRN: To update a Save button in the toolbar
3958   //updateObjBrowser();
3959   return true;
3960 }
3961
3962 //=============================================================================
3963 /*!
3964  *
3965  */
3966 //=============================================================================
3967 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3968 {
3969   return false;
3970 }
3971
3972 //=============================================================================
3973 /*!
3974  *
3975  */
3976 //=============================================================================
3977 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3978 {
3979   return true;
3980 }
3981
3982 //=============================================================================
3983 /*!
3984  *
3985  */
3986 //=============================================================================
3987 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3988 {
3989   return true;
3990 }
3991
3992 //=============================================================================
3993 /*! Method:  BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3994  *  Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3995  */
3996 //=============================================================================
3997 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3998                                   SUIT_ViewWindow* wnd )
3999 {
4000   if(theIO->hasEntry()){
4001     //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
4002     SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
4003   }
4004 }
4005
4006 //=======================================================================
4007 // function : createSMESHAction
4008 // purpose  :
4009 //=======================================================================
4010 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
4011                                   const int key, const bool toggle, const QString& shortcutAction  )
4012 {
4013   QIcon icon;
4014   QWidget* parent = application()->desktop();
4015   SUIT_ResourceMgr* resMgr = resourceMgr();
4016   QPixmap pix;
4017   if ( !icon_id.isEmpty() )
4018     pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4019   else
4020     pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
4021   if ( !pix.isNull() )
4022     icon = QIcon( pix );
4023
4024   QString tooltip    = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4025           menu       = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4026           status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4027
4028   createAction( id, tooltip, icon, menu, status_bar, key, parent,
4029                 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4030 }
4031
4032 //=======================================================================
4033 // function : createPopupItem
4034 // purpose  :
4035 //=======================================================================
4036 void SMESHGUI::createPopupItem( const int id,
4037                                 const QString& clients,
4038                                 const QString& types,
4039                                 const QString& theRule,
4040                                 const int pId )
4041 {
4042   if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4043     popupMgr()->insert( action( id ), pId, 0 );
4044
4045   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
4046   QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4047   QString rule = "(%1) and (%2) and (%3)";
4048   rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4049   if( clients.isEmpty() )
4050     rule = rule.arg( QString( "true" ) );
4051   else
4052     rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4053   rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4054   rule += theRule;
4055
4056   bool cont = myRules.contains( id );
4057   if( cont )
4058     rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4059
4060   popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4061   myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4062 }
4063
4064 //=======================================================================
4065 // function : initialize
4066 // purpose  :
4067 //=======================================================================
4068 void SMESHGUI::initialize( CAM_Application* app )
4069 {
4070   SalomeApp_Module::initialize( app );
4071
4072 //   SUIT_ResourceMgr* mgr = app->resourceMgr();
4073 //   if ( mgr )
4074   /* Automatic Update flag */
4075 //     myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4076
4077   // ----- create actions --------------
4078
4079   //createSMESHAction(  SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4080   createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4081   createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4082   createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL"  );
4083 #ifdef WITH_CGNS
4084   createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4085 #endif
4086   createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
4087   createSMESHAction( SMESHOp::OpImportGMF,  "IMPORT_GMF"  );
4088   createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4089   createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4090   createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL"  );
4091 #ifdef WITH_CGNS
4092   createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4093 #endif
4094   createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
4095   createSMESHAction( SMESHOp::OpPopupImportGMF,  "IMPORT_GMF"  );
4096
4097   createSMESHAction( SMESHOp::OpExportDAT,  "DAT" );
4098   createSMESHAction( SMESHOp::OpExportMED,  "MED" );
4099   createSMESHAction( SMESHOp::OpExportUNV,  "UNV" );
4100   createSMESHAction( SMESHOp::OpExportSTL,  "STL" );
4101 #ifdef WITH_CGNS
4102   createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4103 #endif
4104   createSMESHAction( SMESHOp::OpExportSAUV,     "SAUV");
4105   createSMESHAction( SMESHOp::OpExportGMF,      "GMF" );
4106   createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4107   createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4108   createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4109   createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4110 #ifdef WITH_CGNS
4111   createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4112 #endif
4113   createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
4114   createSMESHAction( SMESHOp::OpPopupExportGMF,  "GMF" );
4115   createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4116   createSMESHAction( SMESHOp::OpDelete,          "DELETE", "ICON_DELETE", Qt::Key_Delete );
4117   createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4118   createSMESHAction( SMESHOp::OpCreateMesh,           "CREATE_MESH",             "ICON_DLG_INIT_MESH" );
4119   createSMESHAction( SMESHOp::OpCreateSubMesh,        "CREATE_SUBMESH",          "ICON_DLG_ADD_SUBMESH" );
4120   createSMESHAction( SMESHOp::OpEditMeshOrSubMesh,    "EDIT_MESHSUBMESH",        "ICON_DLG_EDIT_MESH" );
4121   createSMESHAction( SMESHOp::OpEditMesh,             "EDIT_MESH",               "ICON_DLG_EDIT_MESH" );
4122   createSMESHAction( SMESHOp::OpEditSubMesh,          "EDIT_SUBMESH",            "ICON_DLG_EDIT_MESH" );
4123   createSMESHAction( SMESHOp::OpBuildCompoundMesh,    "BUILD_COMPOUND",          "ICON_BUILD_COMPOUND" );
4124   createSMESHAction( SMESHOp::OpCopyMesh,             "COPY_MESH",               "ICON_COPY_MESH" );
4125   createSMESHAction( SMESHOp::OpCompute,              "COMPUTE",                 "ICON_COMPUTE" );
4126   createSMESHAction( SMESHOp::OpComputeSubMesh,       "COMPUTE_SUBMESH",         "ICON_COMPUTE" );
4127   createSMESHAction( SMESHOp::OpPreCompute,           "PRECOMPUTE",              "ICON_PRECOMPUTE" );
4128   createSMESHAction( SMESHOp::OpEvaluate,             "EVALUATE",                "ICON_EVALUATE" );
4129   createSMESHAction( SMESHOp::OpMeshOrder,            "MESH_ORDER",              "ICON_MESH_ORDER");
4130   createSMESHAction( SMESHOp::OpCreateGroup,          "CREATE_GROUP",            "ICON_CREATE_GROUP" );
4131   createSMESHAction( SMESHOp::OpCreateGeometryGroup,  "CREATE_GEO_GROUP",        "ICON_CREATE_GEO_GROUP" );
4132   createSMESHAction( SMESHOp::OpConstructGroup,       "CONSTRUCT_GROUP",         "ICON_CONSTRUCT_GROUP" );
4133   createSMESHAction( SMESHOp::OpEditGroup,            "EDIT_GROUP",              "ICON_EDIT_GROUP" );
4134   createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4135   createSMESHAction( SMESHOp::OpUnionGroups,          "UN_GROUP",                "ICON_UNION" );
4136   createSMESHAction( SMESHOp::OpIntersectGroups,      "INT_GROUP",               "ICON_INTERSECT" );
4137   createSMESHAction( SMESHOp::OpCutGroups,            "CUT_GROUP",               "ICON_CUT" );
4138   createSMESHAction( SMESHOp::OpGroupUnderlyingElem,  "UNDERLYING_ELEMS",        "ICON_UNDERLYING_ELEMS" );
4139   createSMESHAction( SMESHOp::OpFaceGroupsByEdges,    "FACE_GROUPS_BY_EDGES",    "ICON_FACE_GROUPS_BY_EDGES" );
4140   createSMESHAction( SMESHOp::OpAddElemGroupPopup,    "ADD_TO_GROUP" );
4141   createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4142   createSMESHAction( SMESHOp::OpDeleteGroup,          "DEL_GROUP",               "ICON_DEL_GROUP" );
4143   createSMESHAction( SMESHOp::OpMeshInformation ,     "ADV_INFO",                "ICON_ADV_INFO" );
4144   //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO",        "ICON_STD_INFO" );
4145   //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS",         "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4146   createSMESHAction( SMESHOp::OpFindElementByPoint,   "FIND_ELEM",               "ICON_FIND_ELEM" );
4147   //update
4148   createSMESHAction( SMESHOp::OpFreeNode,              "FREE_NODE",               "ICON_FREE_NODE",     0, true );
4149   createSMESHAction( SMESHOp::OpEqualNode,             "EQUAL_NODE",              "ICON_EQUAL_NODE",    0, true );
4150   createSMESHAction( SMESHOp::OpNodeConnectivityNb,    "NODE_CONNECTIVITY_NB",    "ICON_NODE_CONN_NB",    0, true );
4151   createSMESHAction( SMESHOp::OpFreeEdge,              "FREE_EDGE",               "ICON_FREE_EDGE",     0, true );
4152   createSMESHAction( SMESHOp::OpFreeBorder,            "FREE_BORDER",             "ICON_FREE_EDGE_2D",  0, true );
4153   createSMESHAction( SMESHOp::OpLength,                "LENGTH",                  "ICON_LENGTH",        0, true );
4154   createSMESHAction( SMESHOp::OpConnection,            "CONNECTION",              "ICON_CONNECTION",    0, true );
4155   createSMESHAction( SMESHOp::OpEqualEdge,             "EQUAL_EDGE",              "ICON_EQUAL_EDGE",    0, true );
4156   createSMESHAction( SMESHOp::OpFreeFace,              "FREE_FACES",              "ICON_FREE_FACES",    0, true );
4157   createSMESHAction( SMESHOp::OpBareBorderFace,        "BARE_BORDER_FACE",        "ICON_BARE_BORDER_FACE",        0, true );
4158   createSMESHAction( SMESHOp::OpOverConstrainedFace,   "OVER_CONSTRAINED_FACE",   "ICON_OVER_CONSTRAINED_FACE",   0, true );
4159   createSMESHAction( SMESHOp::OpLength2D,              "LENGTH_2D",               "ICON_LENGTH_2D",     0, true );
4160   createSMESHAction( SMESHOp::OpDeflection2D,          "DEFLECTION_2D",           "ICON_DEFLECTION_2D", 0, true );
4161   createSMESHAction( SMESHOp::OpConnection2D,          "CONNECTION_2D",           "ICON_CONNECTION_2D", 0, true );
4162   createSMESHAction( SMESHOp::OpArea,                  "AREA",                    "ICON_AREA",          0, true );
4163   createSMESHAction( SMESHOp::OpTaper,                 "TAPER",                   "ICON_TAPER",         0, true );
4164   createSMESHAction( SMESHOp::OpAspectRatio,           "ASPECT",                  "ICON_ASPECT",        0, true );
4165   createSMESHAction( SMESHOp::OpMinimumAngle,          "MIN_ANG",                 "ICON_ANGLE",         0, true );
4166   createSMESHAction( SMESHOp::OpWarpingAngle,          "WARP",                    "ICON_WARP",          0, true );
4167   createSMESHAction( SMESHOp::OpSkew,                  "SKEW",                    "ICON_SKEW",          0, true );
4168   createSMESHAction( SMESHOp::OpMaxElementLength2D,    "MAX_ELEMENT_LENGTH_2D",   "ICON_MAX_ELEMENT_LENGTH_2D",   0, true );
4169   createSMESHAction( SMESHOp::OpEqualFace,             "EQUAL_FACE",              "ICON_EQUAL_FACE",    0, true );
4170   createSMESHAction( SMESHOp::OpAspectRatio3D,         "ASPECT_3D",               "ICON_ASPECT_3D",     0, true );
4171   createSMESHAction( SMESHOp::OpVolume,                "VOLUME_3D",               "ICON_VOLUME_3D",     0, true );
4172   createSMESHAction( SMESHOp::OpMaxElementLength3D,    "MAX_ELEMENT_LENGTH_3D",   "ICON_MAX_ELEMENT_LENGTH_3D",   0, true );
4173   createSMESHAction( SMESHOp::OpBareBorderVolume,      "BARE_BORDER_VOLUME",      "ICON_BARE_BORDER_VOLUME",      0, true );
4174   createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4175   createSMESHAction( SMESHOp::OpEqualVolume,           "EQUAL_VOLUME",            "ICON_EQUAL_VOLUME",  0, true );
4176   createSMESHAction( SMESHOp::OpOverallMeshQuality,    "OVERALL_MESH_QUALITY",    "ICON_OVL_MESH_QUALITY" );
4177
4178   createSMESHAction( SMESHOp::OpNode,                   "NODE",            "ICON_DLG_NODE" );
4179   createSMESHAction( SMESHOp::OpElem0D,                 "ELEM0D",          "ICON_DLG_ELEM0D" );
4180   createSMESHAction( SMESHOp::OpElem0DOnElemNodes,      "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4181   createSMESHAction( SMESHOp::OpBall,                   "BALL",            "ICON_DLG_BALL" );
4182   createSMESHAction( SMESHOp::OpEdge,                   "EDGE",            "ICON_DLG_EDGE" );
4183   createSMESHAction( SMESHOp::OpTriangle,               "TRIANGLE",        "ICON_DLG_TRIANGLE" );
4184   createSMESHAction( SMESHOp::OpQuadrangle,             "QUAD",            "ICON_DLG_QUADRANGLE" );
4185   createSMESHAction( SMESHOp::OpPolygon,                "POLYGON",         "ICON_DLG_POLYGON" );
4186   createSMESHAction( SMESHOp::OpTetrahedron,            "TETRA",           "ICON_DLG_TETRAS" );
4187   createSMESHAction( SMESHOp::OpHexahedron,             "HEXA",            "ICON_DLG_HEXAS" );
4188   createSMESHAction( SMESHOp::OpPentahedron,            "PENTA",           "ICON_DLG_PENTA" );
4189   createSMESHAction( SMESHOp::OpPyramid ,               "PYRAMID",         "ICON_DLG_PYRAMID" );
4190   createSMESHAction( SMESHOp::OpHexagonalPrism,         "OCTA",            "ICON_DLG_OCTA" );
4191   createSMESHAction( SMESHOp::OpPolyhedron,             "POLYHEDRON",      "ICON_DLG_POLYHEDRON" );
4192   createSMESHAction( SMESHOp::OpQuadraticEdge,          "QUADRATIC_EDGE",          "ICON_DLG_QUADRATIC_EDGE" );
4193   createSMESHAction( SMESHOp::OpQuadraticTriangle,      "QUADRATIC_TRIANGLE",      "ICON_DLG_QUADRATIC_TRIANGLE" );
4194   createSMESHAction( SMESHOp::OpBiQuadraticTriangle,    "BIQUADRATIC_TRIANGLE",    "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4195   createSMESHAction( SMESHOp::OpQuadraticQuadrangle,    "QUADRATIC_QUADRANGLE",    "ICON_DLG_QUADRATIC_QUADRANGLE" );
4196   createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle,  "BIQUADRATIC_QUADRANGLE",  "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4197   createSMESHAction( SMESHOp::OpQuadraticPolygon,       "QUADRATIC_POLYGON",       "ICON_DLG_QUADRATIC_POLYGON" );
4198   createSMESHAction( SMESHOp::OpQuadraticTetrahedron,   "QUADRATIC_TETRAHEDRON",   "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4199   createSMESHAction( SMESHOp::OpQuadraticPyramid,       "QUADRATIC_PYRAMID",       "ICON_DLG_QUADRATIC_PYRAMID" );
4200   createSMESHAction( SMESHOp::OpQuadraticPentahedron,   "QUADRATIC_PENTAHEDRON",   "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4201   createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4202   createSMESHAction( SMESHOp::OpQuadraticHexahedron,    "QUADRATIC_HEXAHEDRON",    "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4203   createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4204
4205   createSMESHAction( SMESHOp::OpRemoveNodes,       "REMOVE_NODES",          "ICON_DLG_REM_NODE" );
4206   createSMESHAction( SMESHOp::OpRemoveElements,    "REMOVE_ELEMENTS",       "ICON_DLG_REM_ELEMENT" );
4207   createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES",   "ICON_DLG_REM_ORPHAN_NODES" );
4208   createSMESHAction( SMESHOp::OpClearMesh,         "CLEAR_MESH",            "ICON_CLEAR_MESH" );
4209
4210   //createSMESHAction( SMESHOp::OpRenumberingNodes,    "RENUM_NODES",     "ICON_DLG_RENUMBERING_NODES" );
4211   //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS",  "ICON_DLG_RENUMBERING_ELEMENTS" );
4212
4213   createSMESHAction( SMESHOp::OpTranslation,            "TRANS",           "ICON_SMESH_TRANSLATION_VECTOR" );
4214   createSMESHAction( SMESHOp::OpRotation,               "ROT",             "ICON_DLG_MESH_ROTATION" );
4215   createSMESHAction( SMESHOp::OpSymmetry,               "SYM",             "ICON_SMESH_SYMMETRY_PLANE" );
4216   createSMESHAction( SMESHOp::OpScale,                  "SCALE",           "ICON_DLG_MESH_SCALE" );
4217   createSMESHAction( SMESHOp::OpOffset,                 "OFFSET",          "ICON_DLG_MESH_OFFSET" );
4218   createSMESHAction( SMESHOp::OpSewing,                 "SEW",             "ICON_SMESH_SEWING_FREEBORDERS" );
4219   createSMESHAction( SMESHOp::OpMergeNodes,             "MERGE",           "ICON_SMESH_MERGE_NODES" );
4220   createSMESHAction( SMESHOp::OpMergeElements,          "MERGE_ELEMENTS",  "ICON_DLG_MERGE_ELEMENTS" );
4221   createSMESHAction( SMESHOp::OpMoveNode,               "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4222   createSMESHAction( SMESHOp::OpDuplicateNodes,         "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4223   createSMESHAction( SMESHOp::OpDiagonalInversion,      "INV",             "ICON_DLG_MESH_DIAGONAL" );
4224   createSMESHAction( SMESHOp::OpUnionOfTwoTriangle,     "UNION2",          "ICON_UNION2TRI" );
4225   createSMESHAction( SMESHOp::OpOrientation,            "ORIENT",          "ICON_DLG_MESH_ORIENTATION" );
4226   createSMESHAction( SMESHOp::OpReorientFaces,          "REORIENT_2D",     "ICON_REORIENT_2D" );
4227   createSMESHAction( SMESHOp::OpUnionOfTriangles,       "UNION",           "ICON_UNIONTRI" );
4228   createSMESHAction( SMESHOp::OpCuttingOfQuadrangles,   "CUT",             "ICON_CUTQUAD" );
4229   createSMESHAction( SMESHOp::OpSplitVolumes,           "SPLIT_TO_TETRA",  "ICON_SPLIT_TO_TETRA" );
4230   createSMESHAction( SMESHOp::OpSplitBiQuadratic,       "SPLIT_BIQUAD",    "ICON_SPLIT_BIQUAD" );
4231   createSMESHAction( SMESHOp::OpSmoothing,              "SMOOTH",          "ICON_DLG_SMOOTHING" );
4232   createSMESHAction( SMESHOp::OpExtrusion,              "EXTRUSION",       "ICON_EXTRUSION" );
4233   createSMESHAction( SMESHOp::OpExtrusionAlongAPath,    "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4234   createSMESHAction( SMESHOp::OpRevolution,             "REVOLUTION",      "ICON_REVOLUTION" );
4235   createSMESHAction( SMESHOp::OpPatternMapping,         "MAP",             "ICON_MAP" );
4236   createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD",    "ICON_CONV_TO_QUAD" );
4237   createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D",      "ICON_2D_FROM_3D" );
4238
4239   createSMESHAction( SMESHOp::OpReset,               "RESET" );
4240   createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4241   createSMESHAction( SMESHOp::OpShowScalarBar,       "SHOW_SCALAR_BAR","",0, true  );
4242   createSMESHAction( SMESHOp::OpSaveDistribution,    "SAVE_DISTRIBUTION" );
4243   createSMESHAction( SMESHOp::OpShowDistribution,    "SHOW_DISTRIBUTION","",0, true );
4244 #ifndef DISABLE_PLOT2DVIEWER
4245   createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4246 #endif
4247   createSMESHAction( SMESHOp::OpDMWireframe,  "WIRE",    "ICON_WIRE", 0, true );
4248   createSMESHAction( SMESHOp::OpDMShading,    "SHADE",   "ICON_SHADE", 0, true );
4249   createSMESHAction( SMESHOp::OpDMNodes,      "NODES",   "ICON_POINTS", 0, true );
4250   createSMESHAction( SMESHOp::OpDMShrink,     "SHRINK",  "ICON_SHRINK", 0, true );
4251   createSMESHAction( SMESHOp::OpUpdate,       "UPDATE",  "ICON_UPDATE" );
4252   createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4253   createSMESHAction( SMESHOp::OpDEEdges,      "EDGES",   "ICON_DLG_EDGE", 0, true );
4254   createSMESHAction( SMESHOp::OpDEFaces,      "FACES",   "ICON_DLG_TRIANGLE", 0, true );
4255   createSMESHAction( SMESHOp::OpDEVolumes,    "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4256   createSMESHAction( SMESHOp::OpDEBalls,      "BALLS",   "ICON_DLG_BALL", 0, true );
4257   createSMESHAction( SMESHOp::OpDEChoose,     "CHOOSE",  "ICON_DLG_CHOOSE", 0, false );
4258   createSMESHAction( SMESHOp::OpDEAllEntity,  "ALL",     "ICON_DLG_CHOOSE_ALL", 0, false );
4259   createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4260
4261   createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4262   createSMESHAction( SMESHOp::OpRepresentationArcs,  "ARC_REPRESENTATION", "", 0, true );
4263
4264   createSMESHAction( SMESHOp::OpEditHypothesis,    "EDIT_HYPO" );
4265   createSMESHAction( SMESHOp::OpUnassign,          "UNASSIGN" );
4266   createSMESHAction( SMESHOp::OpNumberingNodes,    "NUM_NODES", "", 0, true );
4267   createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4268   createSMESHAction( SMESHOp::OpProperties,   "COLORS" );
4269   createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4270   createSMESHAction( SMESHOp::OpClipping,     "CLIP" );
4271   createSMESHAction( SMESHOp::OpAutoColor,        "AUTO_COLOR" );
4272   createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4273
4274 // Mesh adaptation
4275   createSMESHAction( SMESHOp::OpUniformRefinement,    "REF_ALL",                 "ICON_REF_ALL" );
4276   createSMESHAction( SMESHOp::OpHONewCase,            "HOMARD_CREATE_CASE",      "ICON_HOMARD_CREATE_CASE" );
4277   createSMESHAction( SMESHOp::OpHOCaseFollow,         "HOMARD_FOLLOW_ITERATION", "ICON_HOMARD_FOLLOW_ITERATION" );
4278   createSMESHAction( SMESHOp::OpHONewIter,            "HOMARD_NEW_ITERATION",    "ICON_HOMARD_NEW_ITERATION" );
4279   createSMESHAction( SMESHOp::OpHOIterCompute,        "HOMARD_COMPUTE",          "ICON_HOMARD_COMPUTE" );
4280   createSMESHAction( SMESHOp::OpHOIterComputePublish, "HOMARD_COMPUTE_PUBLISH",  "ICON_HOMARD_COMPUTE_PUBLISH" );
4281   createSMESHAction( SMESHOp::OpHOEdit,               "EDIT",                    "ICON_DLG_EDIT_MESH" );
4282   createSMESHAction( SMESHOp::OpHODelete,             "DELETE",                  "ICON_DELETE" );
4283   createSMESHAction( SMESHOp::OpMGAdapt,              "MG_ADAPT",                "ICON_MG_ADAPT" );
4284
4285   createSMESHAction( SMESHOp::OpMinimumDistance,  "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4286   createSMESHAction( SMESHOp::OpBoundingBox,      "MEASURE_BND_BOX",  "ICON_MEASURE_BND_BOX" );
4287   createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH",   "ICON_MEASURE_LENGTH" );
4288   createSMESHAction( SMESHOp::OpPropertiesArea,   "MEASURE_AREA",     "ICON_MEASURE_AREA" );
4289   createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME",   "ICON_MEASURE_VOLUME" );
4290   createSMESHAction( SMESHOp::OpAngle,            "MEASURE_ANGLE",    "ICON_MEASURE_ANGLE" );
4291
4292   createSMESHAction( SMESHOp::OpHide,     "HIDE", "ICON_HIDE" );
4293   createSMESHAction( SMESHOp::OpShow,     "SHOW", "ICON_SHOW" );
4294   createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4295
4296   createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4297
4298   createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4299
4300   QList<int> aCtrlActions;
4301   aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4302                << SMESHOp::OpNodeConnectivityNb                                         // node controls
4303                << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4304                << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge    // edge controls
4305                << SMESHOp::OpDeflection2D
4306                << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4307                << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4308                << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4309                << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4310                << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace                // face controls
4311                << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4312                << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4313                << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume;           // volume controls
4314   QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4315   aCtrlGroup->setExclusive( true );
4316   for( int i = 0; i < aCtrlActions.size(); i++ )
4317     aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4318
4319   // ----- create menu --------------
4320   int fileId    = createMenu( tr( "MEN_FILE" ),    -1,  1 ),
4321       editId    = createMenu( tr( "MEN_EDIT" ),    -1,  3 ),
4322       toolsId   = createMenu( tr( "MEN_TOOLS" ),   -1,  5, 50 ),
4323       meshId    = createMenu( tr( "MEN_MESH" ),    -1, 70, 10 ),
4324       ctrlId    = createMenu( tr( "MEN_CTRL" ),    -1, 60, 10 ),
4325       modifyId  = createMenu( tr( "MEN_MODIFY" ),  -1, 40, 10 ),
4326       adaptId   = createMenu( tr( "MEN_ADAPT" ),   -1, 80, 10 ),
4327       measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4328       viewId    = createMenu( tr( "MEN_VIEW" ),    -1,  2 );
4329
4330   createMenu( separator(), fileId );
4331
4332   QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4333   QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4334   int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4335       exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4336       nodeId   = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4337       edgeId   = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4338       faceId   = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4339       volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4340       addId    = createMenu( tr( "MEN_ADD" ),    modifyId, 402 ),
4341       removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4342     //renumId  = createMenu( tr( "MEN_RENUM" ),  modifyId, 404 ),
4343       transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4344       refHomardId = createMenu( tr( "MEN_REF_HOMARD" ), adaptId, -1, 10 ),
4345       basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4346
4347   //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4348   createMenu( SMESHOp::OpImportUNV,  importId, -1 );
4349   createMenu( SMESHOp::OpImportMED,  importId, -1 );
4350   createMenu( SMESHOp::OpImportSTL,  importId, -1 );
4351 #ifdef WITH_CGNS
4352   createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4353 #endif
4354   createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4355   createMenu( SMESHOp::OpImportGMF,  importId, -1 );
4356   createMenu( SMESHOp::OpExportDAT,  exportId, -1 );
4357   createMenu( SMESHOp::OpExportMED,  exportId, -1 );
4358   createMenu( SMESHOp::OpExportUNV,  exportId, -1 );
4359   createMenu( SMESHOp::OpExportSTL,  exportId, -1 );
4360 #ifdef WITH_CGNS
4361   createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4362 #endif
4363   createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4364   createMenu( SMESHOp::OpExportGMF,  exportId, -1 );
4365   createMenu( separator(), fileId, 10 );
4366
4367   createMenu( SMESHOp::OpDelete, editId, -1 );
4368
4369   createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4370
4371   createMenu( SMESHOp::OpCreateMesh,           meshId, -1 ); // "Mesh" menu
4372   createMenu( SMESHOp::OpCreateSubMesh,        meshId, -1 );
4373   createMenu( SMESHOp::OpEditMeshOrSubMesh,    meshId, -1 );
4374   createMenu( SMESHOp::OpBuildCompoundMesh,    meshId, -1 );
4375   createMenu( SMESHOp::OpCopyMesh,             meshId, -1 );
4376   createMenu( separator(),                     meshId, -1 );
4377   createMenu( SMESHOp::OpCompute,              meshId, -1 );
4378   createMenu( SMESHOp::OpPreCompute,           meshId, -1 );
4379   createMenu( SMESHOp::OpEvaluate,             meshId, -1 );
4380   createMenu( SMESHOp::OpMeshOrder,            meshId, -1 );
4381   createMenu( separator(),                     meshId, -1 );
4382   createMenu( SMESHOp::OpCreateGroup,          meshId, -1 );
4383   createMenu( SMESHOp::OpCreateGeometryGroup,  meshId, -1 );
4384   createMenu( SMESHOp::OpConstructGroup,       meshId, -1 );
4385   createMenu( SMESHOp::OpEditGroup,            meshId, -1 );
4386   createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4387   createMenu( separator(),                     meshId, -1 );
4388   createMenu( SMESHOp::OpUnionGroups,          meshId, -1 );
4389   createMenu( SMESHOp::OpIntersectGroups,      meshId, -1 );
4390   createMenu( SMESHOp::OpCutGroups,            meshId, -1 );
4391   createMenu( separator(),                     meshId, -1 );
4392   createMenu( SMESHOp::OpGroupUnderlyingElem,  meshId, -1 );
4393   createMenu( SMESHOp::OpFaceGroupsByEdges,    meshId, -1 );
4394   createMenu( separator(),                     meshId, -1 );
4395   createMenu( SMESHOp::OpMeshInformation,      meshId, -1 );
4396   //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4397   //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4398   createMenu( SMESHOp::OpFindElementByPoint,   meshId, -1 );
4399   createMenu( separator(),                     meshId, -1 );
4400
4401   createMenu( SMESHOp::OpFreeNode,              nodeId,   -1 );
4402   createMenu( SMESHOp::OpEqualNode,             nodeId,   -1 );
4403   //createMenu( SMESHOp::OpNodeConnectivityNb,    nodeId,   -1 );
4404   createMenu( SMESHOp::OpFreeBorder,            edgeId,   -1 );
4405   createMenu( SMESHOp::OpLength,                edgeId,   -1 );
4406   createMenu( SMESHOp::OpConnection,            edgeId,   -1 );
4407   createMenu( SMESHOp::OpEqualEdge,             edgeId,   -1 );
4408   createMenu( SMESHOp::OpFreeEdge,              faceId,   -1 );
4409   createMenu( SMESHOp::OpFreeFace,              faceId,   -1 );
4410   createMenu( SMESHOp::OpBareBorderFace,        faceId,   -1 );
4411   createMenu( SMESHOp::OpOverConstrainedFace,   faceId,   -1 );
4412   createMenu( SMESHOp::OpLength2D,              faceId,   -1 );
4413   createMenu( SMESHOp::OpConnection2D,          faceId,   -1 );
4414   createMenu( SMESHOp::OpArea,                  faceId,   -1 );
4415   createMenu( SMESHOp::OpTaper,                 faceId,   -1 );
4416   createMenu( SMESHOp::OpAspectRatio,           faceId,   -1 );
4417   createMenu( SMESHOp::OpMinimumAngle,          faceId,   -1 );
4418   createMenu( SMESHOp::OpWarpingAngle,          faceId,   -1 );
4419   createMenu( SMESHOp::OpSkew,                  faceId,   -1 );
4420   createMenu( SMESHOp::OpMaxElementLength2D,    faceId,   -1 );
4421   createMenu( SMESHOp::OpEqualFace,             faceId,   -1 );
4422   createMenu( SMESHOp::OpDeflection2D,          faceId,   -1 );
4423   createMenu( SMESHOp::OpAspectRatio3D,         volumeId, -1 );
4424   createMenu( SMESHOp::OpVolume,                volumeId, -1 );
4425   createMenu( SMESHOp::OpMaxElementLength3D,    volumeId, -1 );
4426   createMenu( SMESHOp::OpBareBorderVolume,      volumeId, -1 );
4427   createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4428   createMenu( SMESHOp::OpEqualVolume,           volumeId, -1 );
4429   createMenu( separator(),                      ctrlId,   -1 );
4430   createMenu( SMESHOp::OpReset,                 ctrlId,   -1 );
4431   createMenu( separator(),                      ctrlId,   -1 );
4432   createMenu( SMESHOp::OpOverallMeshQuality,    ctrlId,   -1 );
4433
4434   createMenu( SMESHOp::OpNode,                   addId, -1 );
4435   createMenu( SMESHOp::OpElem0D,                 addId, -1 );
4436   createMenu( SMESHOp::OpElem0DOnElemNodes,      addId, -1 );
4437   createMenu( SMESHOp::OpBall,                   addId, -1 );
4438   createMenu( SMESHOp::OpEdge,                   addId, -1 );
4439   createMenu( SMESHOp::OpTriangle,               addId, -1 );
4440   createMenu( SMESHOp::OpQuadrangle,             addId, -1 );
4441   createMenu( SMESHOp::OpPolygon,                addId, -1 );
4442   createMenu( SMESHOp::OpTetrahedron,            addId, -1 );
4443   createMenu( SMESHOp::OpHexahedron,             addId, -1 );
4444   createMenu( SMESHOp::OpPentahedron,            addId, -1 );
4445   createMenu( SMESHOp::OpPyramid,                addId, -1 );
4446   createMenu( SMESHOp::OpHexagonalPrism,         addId, -1 );
4447   createMenu( SMESHOp::OpPolyhedron,             addId, -1 );
4448   createMenu( separator(),                       addId, -1 );
4449   createMenu( SMESHOp::OpQuadraticEdge,          addId, -1 );
4450   createMenu( SMESHOp::OpQuadraticTriangle,      addId, -1 );
4451   createMenu( SMESHOp::OpBiQuadraticTriangle ,   addId, -1 );
4452   createMenu( SMESHOp::OpQuadraticQuadrangle,    addId, -1 );
4453   createMenu( SMESHOp::OpBiQuadraticQuadrangle,  addId, -1 );
4454   createMenu( SMESHOp::OpQuadraticPolygon,       addId, -1 );
4455   createMenu( SMESHOp::OpQuadraticTetrahedron,   addId, -1 );
4456   createMenu( SMESHOp::OpQuadraticPyramid,       addId, -1 );
4457   createMenu( SMESHOp::OpQuadraticPentahedron,   addId, -1 );
4458   createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4459   createMenu( SMESHOp::OpQuadraticHexahedron,    addId, -1 );
4460   createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4461
4462   createMenu( SMESHOp::OpRemoveNodes,       removeId, -1 );
4463   createMenu( SMESHOp::OpRemoveElements,    removeId, -1 );
4464   createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4465   createMenu( separator(),                  removeId, -1 );
4466   createMenu( SMESHOp::OpDeleteGroup,       removeId, -1 );
4467   createMenu( separator(),                  removeId, -1 );
4468   createMenu( SMESHOp::OpClearMesh,         removeId, -1 );
4469
4470   //createMenu( SMESHOp::OpRenumberingNodes,    renumId, -1 );
4471   //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4472
4473   createMenu( SMESHOp::OpMergeNodes,     transfId, -1 );
4474   createMenu( SMESHOp::OpMergeElements,  transfId, -1 );
4475   createMenu( SMESHOp::OpTranslation,    transfId, -1 );
4476   createMenu( SMESHOp::OpRotation,       transfId, -1 );
4477   createMenu( SMESHOp::OpSymmetry,       transfId, -1 );
4478   createMenu( SMESHOp::OpScale,          transfId, -1 );
4479   createMenu( SMESHOp::OpOffset,         transfId, -1 );
4480   createMenu( SMESHOp::OpSewing,         transfId, -1 );
4481   createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4482
4483   createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4484   createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4485   createMenu( SMESHOp::OpExtrusion,              modifyId, -1 );
4486   createMenu( SMESHOp::OpExtrusionAlongAPath,    modifyId, -1 );
4487   createMenu( SMESHOp::OpRevolution,             modifyId, -1 );
4488   createMenu( SMESHOp::OpOrientation,            modifyId, -1 );
4489   createMenu( SMESHOp::OpReorientFaces,          modifyId, -1 );
4490   createMenu( SMESHOp::OpMoveNode,               modifyId, -1 );
4491   createMenu( SMESHOp::OpDiagonalInversion,      modifyId, -1 );
4492   createMenu( SMESHOp::OpUnionOfTwoTriangle,     modifyId, -1 );
4493   createMenu( SMESHOp::OpUnionOfTriangles,       modifyId, -1 );
4494   createMenu( SMESHOp::OpCuttingOfQuadrangles,   modifyId, -1 );
4495   createMenu( SMESHOp::OpSplitVolumes,           modifyId, -1 );
4496   createMenu( SMESHOp::OpSplitBiQuadratic,       modifyId, -1 );
4497   createMenu( SMESHOp::OpSmoothing,              modifyId, -1 );
4498   createMenu( SMESHOp::OpPatternMapping,         modifyId, -1 );
4499
4500   createMenu( SMESHOp::OpUniformRefinement,    adaptId, -1 );
4501   createMenu( SMESHOp::OpHONewCase,            refHomardId, -1 );
4502   createMenu( SMESHOp::OpHOCaseFollow,         refHomardId, -1 );
4503   createMenu( separator(),                     refHomardId, -1 );
4504   createMenu( SMESHOp::OpHONewIter,            refHomardId, -1 );
4505   createMenu( SMESHOp::OpHOIterCompute,        refHomardId, -1 );
4506   createMenu( SMESHOp::OpHOIterComputePublish, refHomardId, -1 );
4507   createMenu( separator(),                     refHomardId, -1 );
4508   createMenu( SMESHOp::OpHOEdit,               refHomardId, -1 );
4509   createMenu( SMESHOp::OpHODelete,             refHomardId, -1 );
4510   createMenu( SMESHOp::OpMGAdapt,              adaptId, -1 );
4511
4512   createMenu( SMESHOp::OpMinimumDistance,  measureId,   -1 );
4513   createMenu( SMESHOp::OpBoundingBox,      measureId,   -1 );
4514   createMenu( SMESHOp::OpAngle,            measureId,   -1 );
4515   createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4516   createMenu( SMESHOp::OpPropertiesArea,   basicPropId, -1 );
4517   createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4518   createMenu( SMESHOp::OpUpdate,           viewId,      -1 );
4519
4520   connect( nodeMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4521   connect( edgeMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4522   connect( faceMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4523   connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4524
4525   // ----- create toolbars --------------
4526   int meshTb       = createTool( tr( "TB_MESH" ),      QString( "SMESHMeshToolbar" ) ),
4527       info         = createTool( tr( "TB_INFO" ),      QString( "SMESHInformationToolbar" ) ),
4528       groupTb      = createTool( tr( "TB_GROUP" ),     QString( "SMESHGroupToolbar" ) ),
4529       ctrl0dTb     = createTool( tr( "TB_CTRL0D" ),    QString( "SMESHNodeControlsToolbar" ) ),
4530       ctrl1dTb     = createTool( tr( "TB_CTRL1D" ),    QString( "SMESHEdgeControlsToolbar" ) ),
4531       ctrl2dTb     = createTool( tr( "TB_CTRL2D" ),    QString( "SMESHFaceControlsToolbar" ) ),
4532       ctrl3dTb     = createTool( tr( "TB_CTRL3D" ),    QString( "SMESHVolumeControlsToolbar" ) ),
4533       addElemTb    = createTool( tr( "TB_ADD" ),       QString( "SMESHAddElementToolbar" ) ),
4534       addNonElemTb = createTool( tr( "TB_ADDNON" ),    QString( "SMESHAddElementToolbar" ) ),
4535       remTb        = createTool( tr( "TB_REM" ),       QString( "SMESHRemoveToolbar" ) ),
4536     //renumbTb     = createTool( tr( "TB_RENUMBER" ),  QString( "SMESHRenumberingToolbar" ) ),
4537       transformTb  = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4538       modifyTb     = createTool( tr( "TB_MODIFY" ),    QString( "SMESHModificationToolbar" ) ),
4539 //       adaptTb      = createTool( tr( "TB_ADAPTATION" ),QString( "SMESHAdaptationToolbar" ) ),
4540       measuremTb   = createTool( tr( "TB_MEASUREM" ),  QString( "SMESHMeasurementsToolbar" ) ),
4541       dispModeTb   = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4542
4543   createTool( SMESHOp::OpCreateMesh,        meshTb );
4544   createTool( SMESHOp::OpCreateSubMesh,     meshTb );
4545   createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4546   createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4547   createTool( SMESHOp::OpCopyMesh,          meshTb );
4548   createTool( separator(),                  meshTb );
4549   createTool( SMESHOp::OpCompute,           meshTb );
4550   createTool( SMESHOp::OpPreCompute,        meshTb );
4551   createTool( SMESHOp::OpEvaluate,          meshTb );
4552   createTool( SMESHOp::OpMeshOrder,         meshTb );
4553
4554   createTool( SMESHOp::OpCreateGroup,         groupTb );
4555   createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4556   createTool( SMESHOp::OpConstructGroup,      groupTb );
4557   createTool( SMESHOp::OpEditGroup,           groupTb );
4558
4559   createTool( SMESHOp::OpMeshInformation,    info );
4560   //createTool( SMESHOp::OpStdInfo, meshTb );
4561   //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4562   createTool( SMESHOp::OpFindElementByPoint, info );
4563
4564   createTool( SMESHOp::OpFreeNode,  ctrl0dTb );
4565   createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4566   //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4567
4568   createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4569   createTool( SMESHOp::OpLength,     ctrl1dTb );
4570   createTool( SMESHOp::OpConnection, ctrl1dTb );
4571   createTool( SMESHOp::OpEqualEdge,  ctrl1dTb );
4572
4573   createTool( SMESHOp::OpFreeEdge,            ctrl2dTb );
4574   createTool( SMESHOp::OpFreeFace,            ctrl2dTb );
4575   createTool( SMESHOp::OpBareBorderFace,      ctrl2dTb );
4576   createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4577   createTool( SMESHOp::OpLength2D,            ctrl2dTb );
4578   createTool( SMESHOp::OpConnection2D,        ctrl2dTb );
4579   createTool( SMESHOp::OpArea,                ctrl2dTb );
4580   createTool( SMESHOp::OpTaper,               ctrl2dTb );
4581   createTool( SMESHOp::OpAspectRatio,         ctrl2dTb );
4582   createTool( SMESHOp::OpMinimumAngle,        ctrl2dTb );
4583   createTool( SMESHOp::OpWarpingAngle,        ctrl2dTb );
4584   createTool( SMESHOp::OpSkew,                ctrl2dTb );
4585   createTool( SMESHOp::OpMaxElementLength2D,  ctrl2dTb );
4586   createTool( SMESHOp::OpEqualFace,           ctrl2dTb );
4587   createTool( SMESHOp::OpDeflection2D,        ctrl2dTb );
4588
4589   createTool( SMESHOp::OpAspectRatio3D,         ctrl3dTb );
4590   createTool( SMESHOp::OpVolume,                ctrl3dTb );
4591   createTool( SMESHOp::OpMaxElementLength3D,    ctrl3dTb );
4592   createTool( SMESHOp::OpBareBorderVolume,      ctrl3dTb );
4593   createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4594   createTool( SMESHOp::OpEqualVolume,           ctrl3dTb );
4595
4596   createTool( SMESHOp::OpNode,              addElemTb );
4597   createTool( SMESHOp::OpElem0D,            addElemTb );
4598   createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4599   createTool( SMESHOp::OpBall,              addElemTb );
4600   createTool( SMESHOp::OpEdge,              addElemTb );
4601   createTool( SMESHOp::OpTriangle,          addElemTb );
4602   createTool( SMESHOp::OpQuadrangle,        addElemTb );
4603   createTool( SMESHOp::OpPolygon,           addElemTb );
4604   createTool( SMESHOp::OpTetrahedron,       addElemTb );
4605   createTool( SMESHOp::OpHexahedron,        addElemTb );
4606   createTool( SMESHOp::OpPentahedron,       addElemTb );
4607   createTool( SMESHOp::OpPyramid,           addElemTb );
4608   createTool( SMESHOp::OpHexagonalPrism,    addElemTb );
4609   createTool( SMESHOp::OpPolyhedron,        addElemTb );
4610
4611   createTool( SMESHOp::OpQuadraticEdge,          addNonElemTb );
4612   createTool( SMESHOp::OpQuadraticTriangle,      addNonElemTb );
4613   createTool( SMESHOp::OpBiQuadraticTriangle,    addNonElemTb );
4614   createTool( SMESHOp::OpQuadraticQuadrangle,    addNonElemTb );
4615   createTool( SMESHOp::OpBiQuadraticQuadrangle,  addNonElemTb );
4616   createTool( SMESHOp::OpQuadraticPolygon,       addNonElemTb );
4617   createTool( SMESHOp::OpQuadraticTetrahedron,   addNonElemTb );
4618   createTool( SMESHOp::OpQuadraticPyramid,       addNonElemTb );
4619   createTool( SMESHOp::OpQuadraticPentahedron,   addNonElemTb );
4620   createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4621   createTool( SMESHOp::OpQuadraticHexahedron,    addNonElemTb );
4622   createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4623
4624   createTool( SMESHOp::OpRemoveNodes,       remTb );
4625   createTool( SMESHOp::OpRemoveElements,    remTb );
4626   createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4627   createTool( SMESHOp::OpClearMesh,         remTb );
4628
4629   //createTool( SMESHOp::OpRenumberingNodes,    renumbTb );
4630   //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4631
4632   createTool( SMESHOp::OpMergeNodes,     transformTb );
4633   createTool( SMESHOp::OpMergeElements,  transformTb );
4634   createTool( SMESHOp::OpTranslation,    transformTb );
4635   createTool( SMESHOp::OpRotation,       transformTb );
4636   createTool( SMESHOp::OpSymmetry,       transformTb );
4637   createTool( SMESHOp::OpScale,          transformTb );
4638   createTool( SMESHOp::OpOffset,         transformTb );
4639   createTool( SMESHOp::OpSewing,         transformTb );
4640   createTool( SMESHOp::OpDuplicateNodes, transformTb );
4641
4642   createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4643   createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4644   createTool( SMESHOp::OpExtrusion,              modifyTb );
4645   createTool( SMESHOp::OpExtrusionAlongAPath,    modifyTb );
4646   createTool( SMESHOp::OpRevolution,             modifyTb );
4647   createTool( SMESHOp::OpOrientation,            modifyTb );
4648   createTool( SMESHOp::OpReorientFaces,          modifyTb );
4649   createTool( SMESHOp::OpMoveNode,               modifyTb );
4650   createTool( SMESHOp::OpDiagonalInversion,      modifyTb );
4651   createTool( SMESHOp::OpUnionOfTwoTriangle,     modifyTb );
4652   createTool( SMESHOp::OpUnionOfTriangles,       modifyTb );
4653   createTool( SMESHOp::OpCuttingOfQuadrangles,   modifyTb );
4654   createTool( SMESHOp::OpSplitVolumes,           modifyTb );
4655   createTool( SMESHOp::OpSplitBiQuadratic,       modifyTb );
4656   createTool( SMESHOp::OpSmoothing,              modifyTb );
4657   createTool( SMESHOp::OpPatternMapping,         modifyTb );
4658
4659 //   createTool( SMESHOp::OpUniformRefinement, adaptTb );
4660 //   createTool( SMESHOp::OpHOMARDRefinement,  adaptTb );
4661 //   createTool( SMESHOp::OpMGAdapt,           adaptTb );
4662
4663   createTool( SMESHOp::OpMinimumDistance, measuremTb );
4664
4665   createTool( SMESHOp::OpUpdate, dispModeTb );
4666
4667   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
4668   QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4669
4670   myRules.clear();
4671   QString
4672     OB      = "'ObjectBrowser'",
4673     View    = "'" + SVTK_Viewer::Type() + "'",
4674     pat     = "'%1'",
4675     mesh    = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4676     group   = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4677     hypo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4678     algo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4679     smesh   = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4680     elems   = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4681     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4682     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4683     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4684     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4685     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4686     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4687     subMesh      = elems,
4688     mesh_part    = mesh + " " + subMesh + " " + group,
4689     mesh_group   = mesh + " " + group,
4690     mesh_submesh = mesh + " " + subMesh,
4691     hyp_alg      = hypo + " " + algo;
4692
4693   // popup for object browser
4694   QString
4695     isInvisible("not( isVisible )"),
4696     isEmpty("numberOfNodes = 0"),
4697     isNotEmpty("numberOfNodes <> 0"),
4698
4699     // has nodes, edges, etc in VISIBLE! actor
4700     hasNodes("(numberOfNodes > 0 ) && hasActor"),
4701     hasElems("(count( elemTypes ) > 0)"),
4702     hasDifferentElems("(count( elemTypes ) > 1)"),
4703     hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4704     hasBalls("({'BallElem'} in elemTypes)"),
4705     hasElems0d("({'Elem0d'} in elemTypes)"),
4706     hasEdges("({'Edge'} in elemTypes)"),
4707     hasFaces("({'Face'} in elemTypes)"),
4708     hasVolumes("({'Volume'} in elemTypes)"),
4709     hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4710
4711   createPopupItem( SMESHOp::OpFileInformation,   OB, mesh, "&& selcount=1 && isImported" );
4712   createPopupItem( SMESHOp::OpCreateSubMesh,     OB, mesh, "&& hasGeomReference");
4713   createPopupItem( SMESHOp::OpEditMesh,          OB, mesh, "&& selcount=1" );
4714   createPopupItem( SMESHOp::OpEditSubMesh,       OB, subMesh, "&& selcount=1 && hasGeomReference" );
4715   createPopupItem( SMESHOp::OpEditGroup,         OB, group );
4716   createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4717
4718   popupMgr()->insert( separator(), -1, 0 );
4719   createPopupItem( SMESHOp::OpCompute,           OB, mesh, "&& selcount=1 && isComputable" );
4720   createPopupItem( SMESHOp::OpComputeSubMesh,    OB, subMesh, "&& selcount=1 && isComputable" );
4721   createPopupItem( SMESHOp::OpPreCompute,        OB, mesh, "&& selcount=1 && isPreComputable" );
4722   createPopupItem( SMESHOp::OpEvaluate,          OB, mesh, "&& selcount=1 && isComputable" );
4723   createPopupItem( SMESHOp::OpMeshOrder,         OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4724   createPopupItem( SMESHOp::OpUpdate,            OB, mesh_part );
4725   createPopupItem( SMESHOp::OpMeshInformation,   OB, mesh_part );
4726   createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4727   createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4728   popupMgr()->insert( separator(), -1, 0 );
4729   createPopupItem( SMESHOp::OpCreateGroup,       OB, mesh, "&& selcount=1" );
4730   createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4731   createPopupItem( SMESHOp::OpConstructGroup,    OB, subMesh );
4732   popupMgr()->insert( separator(), -1, 0 );
4733   createPopupItem( SMESHOp::OpEditHypothesis,    OB, hypo, "&& isEditableHyp");
4734   createPopupItem( SMESHOp::OpUnassign,          OB, hyp_alg );
4735   popupMgr()->insert( separator(), -1, 0 );
4736   createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4737   createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4738   popupMgr()->insert( separator(), -1, 0 );
4739   createPopupItem( SMESHOp::OpClearMesh,              OB, mesh );
4740   //popupMgr()->insert( separator(), -1, 0 );
4741 //   createPopupItem( SMESHOp::OpUniformRefinement, OB, mesh );
4742 //   createPopupItem( SMESHOp::OpHOMARDRefinement,  OB, mesh );
4743 //   createPopupItem( SMESHOp::OpMGAdapt,           OB, mesh );
4744
4745   QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4746   QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4747   QString only_one_2D        = only_one_non_empty + " && dim>1";
4748
4749   int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 );        // EXPORT submenu
4750   createPopupItem( SMESHOp::OpPopupExportMED,  OB, mesh_group, multiple_non_empty, anId );
4751   createPopupItem( SMESHOp::OpPopupExportUNV,  OB, mesh_group, only_one_non_empty, anId );
4752   createPopupItem( SMESHOp::OpPopupExportSTL,  OB, mesh_group, only_one_2D, anId );
4753 #ifdef WITH_CGNS
4754   createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4755 #endif
4756   createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4757   createPopupItem( SMESHOp::OpPopupExportGMF,  OB, mesh_group, only_one_non_empty, anId );
4758   createPopupItem( SMESHOp::OpPopupExportDAT,  OB, mesh_group, only_one_non_empty, anId );
4759   createPopupItem( SMESHOp::OpDelete,          OB, mesh_part + " " + hyp_alg );
4760   createPopupItem( SMESHOp::OpDeleteGroup,     OB, group );
4761
4762   anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 );        // IMPORT submenu
4763   createPopupItem( SMESHOp::OpPopupImportMED,  OB, smesh, "", anId );
4764   createPopupItem( SMESHOp::OpPopupImportUNV,  OB, smesh, "", anId );
4765   createPopupItem( SMESHOp::OpPopupImportSTL,  OB, smesh, "", anId );
4766 #ifdef WITH_CGNS
4767   createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4768 #endif
4769   createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4770   createPopupItem( SMESHOp::OpPopupImportGMF,  OB, smesh, "", anId );
4771   createPopupItem( SMESHOp::OpPopupImportDAT,  OB, smesh, "", anId );
4772   popupMgr()->insert( separator(), -1, 0 );
4773
4774   // popup for viewer
4775   createPopupItem( SMESHOp::OpEditGroup,            View, group );
4776   createPopupItem( SMESHOp::OpAddElemGroupPopup,    View, elems, "&& guiState = 800" );
4777   createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4778
4779   popupMgr()->insert( separator(), -1, 0 );
4780   createPopupItem( SMESHOp::OpUpdate,             View, mesh_part );
4781   createPopupItem( SMESHOp::OpMeshInformation,    View, mesh_part );
4782   createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4783   createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4784   popupMgr()->insert( separator(), -1, 0 );
4785
4786   createPopupItem( SMESHOp::OpAutoColor,        OB + " " + View, mesh, "&& (not isAutoColor)" );
4787   createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4788   popupMgr()->insert( separator(), -1, 0 );
4789
4790   QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4791   QString aType = QString( "%1type in {%2}" ).arg( lc );
4792   aType = aType.arg( mesh_part );
4793   QString aMeshInVTK = aClient + "&&" + aType;
4794
4795   aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4796   QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4797   QString aSelCount = QString( "%1 > 0" ).arg( dc );
4798
4799   //-------------------------------------------------
4800   // Numbering
4801   //-------------------------------------------------
4802   anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4803
4804   popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4805   popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4806   popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4807
4808   popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4809   popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4810   popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4811
4812   popupMgr()->insert( separator(), -1, -1 );
4813
4814   //-------------------------------------------------
4815   // Display Mode
4816   //-------------------------------------------------
4817   anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4818
4819   popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4820   popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4821   popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4822
4823   popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4824   popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4825   popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4826
4827   popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4828   popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4829   popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4830
4831   popupMgr()->insert( separator(), anId, -1 );
4832
4833   popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4834   popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4835   popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4836
4837   //-------------------------------------------------
4838   // Display Entity
4839   //-------------------------------------------------
4840   QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4841
4842   anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4843
4844   popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4845   popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4846   popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4847
4848   popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4849   popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4850   popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4851
4852   popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4853   popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4854   popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4855
4856   popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4857   popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4858   popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4859
4860   popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4861   popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4862   popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4863
4864   popupMgr()->insert( separator(), anId, -1 );
4865
4866   popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4867   popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4868
4869   popupMgr()->insert( separator(), anId, -1 );
4870
4871   popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4872   popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4873
4874
4875   //-------------------------------------------------
4876   // Representation of the 2D Quadratic elements
4877   //-------------------------------------------------
4878   anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4879   popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4880   popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4881   popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4882
4883   popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4884   popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4885   popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4886
4887   //-------------------------------------------------
4888   // Orientation of faces
4889   //-------------------------------------------------
4890   popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4891   popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4892   popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4893
4894   //-------------------------------------------------
4895   // Color / Size
4896   //-------------------------------------------------
4897   popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4898   popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4899
4900   //-------------------------------------------------
4901   // Transparency
4902   //-------------------------------------------------
4903   popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4904   popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4905
4906   //-------------------------------------------------
4907   // Controls
4908   //-------------------------------------------------
4909   QString
4910     aMeshInVtkHasNodes   = aMeshInVTK + "&&" + hasNodes,
4911     aMeshInVtkHasEdges   = aMeshInVTK + "&&" + hasEdges,
4912     aMeshInVtkHasFaces   = aMeshInVTK + "&&" + hasFaces,
4913     aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4914
4915   anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4916
4917   popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4918   popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4919
4920   popupMgr()->insert( separator(), anId, -1 );
4921
4922   int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4923
4924   popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4925   popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4926   popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4927
4928   popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4929   popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4930   popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4931
4932   // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4933   // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4934   // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4935
4936   aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4937
4938   popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4939   popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4940   popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4941
4942   popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4943   popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4944   popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4945
4946   popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4947   popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4948   popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4949   popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4950   popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4951   popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4952
4953   aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4954
4955   popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4956   popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4957   popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4958
4959   popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4960   popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4961                                        QtxPopupMgr::VisibleRule );
4962   popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4963
4964   popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4965   popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4966   popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4967
4968   popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4969   popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4970   popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4971
4972   popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4973   popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4974   popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4975
4976   popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4977   popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4978   popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4979
4980   popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4981   popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4982   popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4983
4984   popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4985   popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4986   popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4987
4988   popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4989   popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4990   popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4991
4992   popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4993   popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4994   popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4995
4996   popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4997   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4998   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4999
5000   popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
5001   popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5002   popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
5003
5004   popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
5005   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5006   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
5007
5008   popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
5009   popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5010   popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
5011
5012   popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
5013   popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
5014   popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
5015
5016   aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
5017
5018   popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D  ), aSubId, -1 );
5019   popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5020   popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
5021
5022   popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
5023   popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5024   popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
5025
5026   popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
5027   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5028   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5029
5030   popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5031   popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5032   popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5033
5034   popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5035   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5036   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5037
5038   popupMgr()->insert ( action( SMESHOp::OpEqualVolume  ), aSubId, -1 );
5039   popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5040   popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5041
5042   popupMgr()->insert( separator(), anId, -1 );
5043
5044   popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5045   popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5046   popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5047   popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5048   popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5049
5050   popupMgr()->insert( separator(), anId, -1 );
5051
5052   aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5053
5054   popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5055   popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5056
5057   popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5058   popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5059   popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5060
5061 #ifndef DISABLE_PLOT2DVIEWER
5062   popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5063   popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5064 #endif
5065
5066   //-------------------------------------------------
5067   // Show / Hide
5068   //-------------------------------------------------
5069   popupMgr()->insert( separator(), -1, -1 );
5070   QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5071     aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5072   popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5073   popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5074
5075   popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5076   popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5077
5078   popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5079   popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5080
5081   popupMgr()->insert( separator(), -1, -1 );
5082
5083   //-------------------------------------------------
5084   // Clipping
5085   //-------------------------------------------------
5086   popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5087   popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5088
5089   popupMgr()->insert( separator(), -1, -1 );
5090
5091   popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5092   popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5093   popupMgr()->insert( separator(), -1, -1 );
5094
5095   popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5096   popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5097
5098   connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5099            this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5100
5101   connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5102            this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5103 }
5104
5105 //================================================================================
5106 /*!
5107  * \brief Return true if SMESH or GEOM objects are selected.
5108  * Is called form LightApp_Module::activateModule() which clear selection if
5109  * not isSelectionCompatible()
5110  */
5111 //================================================================================
5112
5113 bool SMESHGUI::isSelectionCompatible()
5114 {
5115   bool isCompatible = true;
5116   SALOME_ListIO selected;
5117   if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5118     Sel->selectedObjects( selected );
5119
5120   SALOME_ListIteratorOfListIO It( selected );
5121   for ( ; isCompatible && It.More(); It.Next())
5122     isCompatible =
5123       ( strcmp("GEOM",        It.Value()->getComponentDataType()) == 0 ) ||
5124       ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5125       ( strcmp("SMESH",       It.Value()->getComponentDataType()) == 0 );
5126
5127   return isCompatible;
5128 }
5129
5130
5131 bool SMESHGUI::reusableOperation( const int id )
5132 {
5133   // compute, evaluate and precompute are not reusable operations
5134   return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
5135 }
5136
5137 bool SMESHGUI::activateModule( SUIT_Study* study )
5138 {
5139   bool res = SalomeApp_Module::activateModule( study );
5140
5141   setMenuShown( true );
5142   setToolShown( true );
5143
5144   // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5145   PyGILState_STATE gstate = PyGILState_Ensure();
5146   PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5147   if ( !pluginsmanager ) {
5148     PyErr_Print();
5149   }
5150   else {
5151     PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5152     if ( !result )
5153       PyErr_Print();
5154     Py_XDECREF(result);
5155   }
5156   PyGILState_Release(gstate);
5157   // end of SMESH plugins loading
5158
5159   // Reset actions accelerator keys
5160   action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5161
5162   //  0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5163   GetSMESHGen()->UpdateStudy();
5164
5165   // get all view currently opened in the study and connect their signals  to
5166   // the corresponding slots of the class.
5167   SUIT_Desktop* aDesk = study->application()->desktop();
5168   if ( aDesk ) {
5169     QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5170     SUIT_ViewWindow* wnd;
5171     foreach ( wnd, wndList )
5172     {
5173       connectView( wnd );
5174
5175       // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5176       SMESH::UpdateActorsAfterUpdateStudy(wnd);
5177
5178       wnd->update();
5179     }
5180   }
5181
5182   Py_XDECREF(pluginsmanager);
5183   return res;
5184 }
5185
5186 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5187 {
5188   setMenuShown( false );
5189   setToolShown( false );
5190
5191   EmitSignalCloseAllDialogs();
5192
5193   // Unset actions accelerator keys
5194   action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5195
5196   return SalomeApp_Module::deactivateModule( study );
5197 }
5198
5199 void SMESHGUI::studyClosed( SUIT_Study* s )
5200 {
5201   if( !s )
5202     return;
5203   SMESH::RemoveVisuData();
5204   SalomeApp_Module::studyClosed( s );
5205 }
5206
5207 void SMESHGUI::OnGUIEvent()
5208 {
5209   const QObject* obj = sender();
5210   if ( !obj || !obj->inherits( "QAction" ) )
5211     return;
5212   int id = actionId((QAction*)obj);
5213   if ( id != -1 )
5214     OnGUIEvent( id );
5215 }
5216
5217 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5218 {
5219   if ( CORBA::is_nil( myComponentSMESH ) )
5220   {
5221     SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5222     return aGUI.myComponentSMESH;
5223   }
5224   return myComponentSMESH;
5225 }
5226
5227 QString SMESHGUI::engineIOR() const
5228 {
5229   CORBA::ORB_var anORB = getApp()->orb();
5230   CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5231   return QString( anIOR.in() );
5232 }
5233
5234 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5235 {
5236   SalomeApp_Module::contextMenuPopup( client, menu, title );
5237   SALOME_ListIO lst;
5238   selectionMgr()->selectedObjects( lst );
5239   if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5240     Handle(SALOME_InteractiveObject) io = lst.First();
5241     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5242     _PTR(Study) study = appStudy->studyDS();
5243     _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5244     if ( obj ) {
5245       QString aName = SMESH::fromUtf8( obj->GetName());
5246       while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5247         aName.remove(( aName.length() - 1 ), 1 );
5248       title = aName;
5249     }
5250   }
5251 }
5252
5253 LightApp_Selection* SMESHGUI::createSelection() const
5254 {
5255   return new SMESHGUI_Selection();
5256 }
5257
5258 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5259 {
5260   aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5261   aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5262 #ifndef DISABLE_PYCONSOLE
5263   aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5264 #endif
5265 }
5266
5267 void SMESHGUI::viewManagers( QStringList& list ) const
5268 {
5269   list.append( SVTK_Viewer::Type() );
5270 }
5271
5272 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5273 {
5274   if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5275     SMESH::UpdateSelectionProp( this );
5276
5277     QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5278     for(int i = 0; i < aViews.count() ; i++){
5279       SUIT_ViewWindow *sf = aViews[i];
5280       connectView( sf );
5281     }
5282     EmitSignalActivatedViewManager();
5283   }
5284 }
5285
5286 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5287 {
5288   if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5289     myClippingPlaneInfoMap.erase( theViewManager );
5290 }
5291
5292 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5293 {
5294   theActor->AddObserver( SMESH::DeleteActorEvent,
5295                          myEventCallbackCommand.GetPointer(),
5296                          myPriority );
5297 }
5298
5299 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5300                               unsigned long theEvent,
5301                               void* theClientData,
5302                               void* theCallData )
5303 {
5304   if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5305     if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5306       if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5307         SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5308         SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5309         for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5310           SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5311           SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5312           for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5313             SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5314             std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5315             SMESH::TActorList::iterator anIter3 = anActorList.begin();
5316             for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5317               if( anActor == *anIter3 ) {
5318                 anActorList.erase( anIter3 );
5319                 break;
5320               }
5321             }
5322           }
5323         }
5324       }
5325     }
5326   }
5327 }
5328
5329 void SMESHGUI::createPreferences()
5330 {
5331   // General tab ------------------------------------------------------------------------
5332   int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5333
5334   int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5335   setPreferenceProperty( autoUpdate, "columns", 2 );
5336   int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5337   setPreferenceProperty( lim, "min",  0 );
5338   setPreferenceProperty( lim, "max",  100000000 );
5339   setPreferenceProperty( lim, "step", 1000 );
5340   setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5341   addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5342
5343   int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5344   setPreferenceProperty( dispgroup, "columns", 2 );
5345
5346   addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5347
5348   int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5349   QStringList modes;
5350   modes.append( tr("MEN_WIRE") );
5351   modes.append( tr("MEN_SHADE") );
5352   modes.append( tr("MEN_NODES") );
5353   modes.append( tr("MEN_SHRINK") );
5354   QList<QVariant> indices;
5355   indices.append( 0 );
5356   indices.append( 1 );
5357   indices.append( 2 );
5358   indices.append( 3 );
5359   setPreferenceProperty( dispmode, "strings", modes );
5360   setPreferenceProperty( dispmode, "indexes", indices );
5361
5362   int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5363   setPreferenceProperty( arcgroup, "columns", 2 );
5364   int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5365   QStringList quadraticModes;
5366   quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5367   quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5368   indices.clear();
5369   indices.append( 0 );
5370   indices.append( 1 );
5371   setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5372   setPreferenceProperty( quadraticmode, "indexes", indices );
5373
5374   int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5375                               "SMESH", "max_angle" );
5376   setPreferenceProperty( maxAngle, "min", 1 );
5377   setPreferenceProperty( maxAngle, "max", 90 );
5378
5379   int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5380   setPreferenceProperty( qaGroup, "columns", 2 );
5381   addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5382   addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5383   int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5384   setPreferenceProperty( prec, "min", 0 );
5385   setPreferenceProperty( prec, "max", 100 );
5386   int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5387   setPreferenceProperty( doubleNodesTol, "precision", 10 );
5388   setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5389   setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5390   setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5391
5392   /*
5393   int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5394   setPreferenceProperty( cinc, "min", 0 );
5395   setPreferenceProperty( cinc, "max", 5 );
5396   */
5397
5398   int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5399   setPreferenceProperty( exportgroup, "columns", 2 );
5400   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5401   addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5402   int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5403   setPreferenceProperty( zTol, "precision", 10 );
5404   setPreferenceProperty( zTol, "min", 0.0000000001 );
5405   setPreferenceProperty( zTol, "max", 1000000.0 );
5406   setPreferenceProperty( zTol, "step", 1. );
5407   //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5408
5409   int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5410   setPreferenceProperty( computeGroup, "columns", 2 );
5411   int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5412   modes.clear();
5413   modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5414   modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5415   modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5416   indices.clear();
5417   indices.append( 0 );
5418   indices.append( 1 );
5419   indices.append( 2 );
5420   setPreferenceProperty( notifyMode, "strings", modes );
5421   setPreferenceProperty( notifyMode, "indexes", indices );
5422
5423   int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5424   setPreferenceProperty( infoGroup, "columns", 2 );
5425   int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5426   modes.clear();
5427   modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5428   modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5429   indices.clear();
5430   indices.append( 0 );
5431   indices.append( 1 );
5432   setPreferenceProperty( elemInfo, "strings", modes );
5433   setPreferenceProperty( elemInfo, "indexes", indices );
5434   int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5435   setPreferenceProperty( nodesLim, "min", 0 );
5436   setPreferenceProperty( nodesLim, "max", 10000000 );
5437   setPreferenceProperty( nodesLim, "step", 10000 );
5438   setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5439   int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5440   setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5441   setPreferenceProperty( ctrlLim, "min", 0 );
5442   setPreferenceProperty( ctrlLim, "max", 10000000 );
5443   setPreferenceProperty( ctrlLim, "step", 1000 );
5444   addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5445   addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5446   addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5447   addPreference( tr( "PREF_DUMP_ADD_INFO"  ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5448   addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5449
5450   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5451   setPreferenceProperty( segGroup, "columns", 2 );
5452   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5453                               "SMESH", "segmentation" );
5454   setPreferenceProperty( segLen, "min", 1 );
5455   setPreferenceProperty( segLen, "max", 10000000 );
5456   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5457                              "SMESH", "nb_segments_per_edge" );
5458   setPreferenceProperty( nbSeg, "min", 1 );
5459   setPreferenceProperty( nbSeg, "max", 10000000 );
5460   addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5461
5462   int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5463   addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5464                  "SMESH", "forget_mesh_on_hyp_modif" );
5465
5466
5467   // Quantities with individual precision settings
5468   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5469   setPreferenceProperty( precGroup, "columns", 2 );
5470
5471   const int nbQuantities = 6;
5472   int precs[nbQuantities], ii = 0;
5473   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5474                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5475   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5476                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5477   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5478                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5479   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5480                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5481   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5482                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5483   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5484                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5485
5486   // Set property for precision value for spinboxes
5487   for ( ii = 0; ii < nbQuantities; ii++ ){
5488     setPreferenceProperty( precs[ii], "min", -14 );
5489     setPreferenceProperty( precs[ii], "max", 14 );
5490     setPreferenceProperty( precs[ii], "precision", 2 );
5491   }
5492
5493   int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5494   setPreferenceProperty( previewGroup, "columns", 2 );
5495   int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5496   setPreferenceProperty( chunkSize, "min",  1 );
5497   setPreferenceProperty( chunkSize, "max",  1000 );
5498   setPreferenceProperty( chunkSize, "step", 50 );
5499
5500   int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5501   addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5502
5503   // Mesh tab ------------------------------------------------------------------------
5504   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5505   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5506   setPreferenceProperty( nodeGroup, "columns", 3 );
5507
5508   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5509
5510   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5511
5512   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5513   QList<QVariant> aMarkerTypeIndicesList;
5514   QList<QVariant> aMarkerTypeIconsList;
5515   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5516     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5517     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5518     aMarkerTypeIndicesList << i;
5519     aMarkerTypeIconsList << pixmap;
5520   }
5521   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5522   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
5523
5524   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5525
5526   QList<QVariant> aMarkerScaleIndicesList;
5527   QStringList     aMarkerScaleValuesList;
5528   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5529     aMarkerScaleIndicesList << i;
5530     //aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5531     aMarkerScaleValuesList  << QString::number( i );
5532   }
5533   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5534   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5535
5536   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5537   //setPreferenceProperty( elemGroup, "columns", 2 );
5538
5539   int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5540   setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5541   ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5542   setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5543   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5544   addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5545   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5546   addPreference( tr( "PREF_WIREFRAME"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5547   addPreference( tr( "PREF_PREVIEW_COLOR"  ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5548
5549
5550   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5551   setPreferenceProperty( grpGroup, "columns", 2 );
5552
5553   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5554   addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5555
5556   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5557                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5558   /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5559                              LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5560   double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5561                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5562   double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5563                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5564   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
5565                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
5566   int outW  = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5567                              LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5568   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5569                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5570
5571   setPreferenceProperty( size0d, "min", 1 );
5572   setPreferenceProperty( size0d, "max", 10 );
5573
5574  // setPreferenceProperty( ballSize, "min", 1 );
5575  // setPreferenceProperty( ballSize, "max", 10 );
5576
5577   setPreferenceProperty( ballDiameter, "min", 1e-7 );
5578   setPreferenceProperty( ballDiameter, "max", 1e9 );
5579   setPreferenceProperty( ballDiameter, "step", 0.1 );
5580
5581   setPreferenceProperty( ballScale, "min", 1e-2 );
5582   setPreferenceProperty( ballScale, "max", 1e7 );
5583   setPreferenceProperty( ballScale, "step", 0.5 );
5584
5585   setPreferenceProperty( elemW, "min", 1 );
5586   setPreferenceProperty( elemW, "max", 5 );
5587
5588   setPreferenceProperty( outW, "min", 1 );
5589   setPreferenceProperty( outW, "max", 5 );
5590
5591   setPreferenceProperty( shrink, "min", 0 );
5592   setPreferenceProperty( shrink, "max", 100 );
5593
5594   int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5595   setPreferenceProperty( numGroup, "columns", 2 );
5596
5597   addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5598   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5599
5600   addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5601   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5602
5603   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5604   setPreferenceProperty( orientGroup, "columns", 1 );
5605
5606   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5607   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5608
5609   setPreferenceProperty( orientScale, "min", 0.05 );
5610   setPreferenceProperty( orientScale, "max", 0.5 );
5611   setPreferenceProperty( orientScale, "step", 0.05 );
5612
5613   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5614
5615   // Selection tab ------------------------------------------------------------------------
5616   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5617
5618   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5619   setPreferenceProperty( selGroup, "columns", 2 );
5620
5621   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5622   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5623
5624   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5625   setPreferenceProperty( preGroup, "columns", 2 );
5626
5627   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5628
5629   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5630   setPreferenceProperty( precSelGroup, "columns", 2 );
5631
5632   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5633   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5634   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5635
5636   int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5637   setPreferenceProperty( sinc, "min", 0 );
5638   setPreferenceProperty( sinc, "max", 5 );
5639
5640   // Scalar Bar tab ------------------------------------------------------------------------
5641   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5642   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5643   setPreferenceProperty( fontGr, "columns", 2 );
5644
5645   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5646   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5647
5648   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5649   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5650
5651   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5652   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5653
5654   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5655   setPreferenceProperty( numcol, "min", 2 );
5656   setPreferenceProperty( numcol, "max", 256 );
5657
5658   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5659   setPreferenceProperty( numlab, "min", 2 );
5660   setPreferenceProperty( numlab, "max", 65 );
5661
5662   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5663   setPreferenceProperty( orientGr, "columns", 2 );
5664   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5665   QStringList orients;
5666   orients.append( tr( "SMESH_VERTICAL" ) );
5667   orients.append( tr( "SMESH_HORIZONTAL" ) );
5668   indices.clear(); indices.append( 0 ); indices.append( 1 );
5669   setPreferenceProperty( orient, "strings", orients );
5670   setPreferenceProperty( orient, "indexes", indices );
5671
5672   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5673   setPreferenceProperty( posVSizeGr, "columns", 2 );
5674   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5675   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5676   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5677   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5678   setPreferenceProperty( xv, "step", 0.1 );
5679   setPreferenceProperty( xv, "min", 0.0 );
5680   setPreferenceProperty( xv, "max", 1.0 );
5681   setPreferenceProperty( yv, "step", 0.1 );
5682   setPreferenceProperty( yv, "min", 0.0 );
5683   setPreferenceProperty( yv, "max", 1.0 );
5684   setPreferenceProperty( wv, "step", 0.1 );
5685   setPreferenceProperty( wv, "min", 0.0 );
5686   setPreferenceProperty( wv, "max", 1.0 );
5687   setPreferenceProperty( hv, "min", 0.0 );
5688   setPreferenceProperty( hv, "max", 1.0 );
5689   setPreferenceProperty( hv, "step", 0.1 );
5690
5691   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5692   setPreferenceProperty( posHSizeGr, "columns", 2 );
5693   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5694   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5695   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5696   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5697   setPreferenceProperty( xv, "min", 0.0 );
5698   setPreferenceProperty( xv, "max", 1.0 );
5699   setPreferenceProperty( xv, "step", 0.1 );
5700   setPreferenceProperty( xh, "min", 0.0 );
5701   setPreferenceProperty( xh, "max", 1.0 );
5702   setPreferenceProperty( xh, "step", 0.1 );
5703   setPreferenceProperty( yh, "min", 0.0 );
5704   setPreferenceProperty( yh, "max", 1.0 );
5705   setPreferenceProperty( yh, "step", 0.1 );
5706   setPreferenceProperty( wh, "min", 0.0 );
5707   setPreferenceProperty( wh, "max", 1.0 );
5708   setPreferenceProperty( wh, "step", 0.1 );
5709   setPreferenceProperty( hh, "min", 0.0 );
5710   setPreferenceProperty( hh, "max", 1.0 );
5711   setPreferenceProperty( hh, "step", 0.1 );
5712
5713   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5714   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5715   setPreferenceProperty( distributionGr, "columns", 3 );
5716   QStringList types;
5717   types.append( tr( "SMESH_MONOCOLOR" ) );
5718   types.append( tr( "SMESH_MULTICOLOR" ) );
5719   indices.clear(); indices.append( 0 ); indices.append( 1 );
5720   setPreferenceProperty( coloringType, "strings", types );
5721   setPreferenceProperty( coloringType, "indexes", indices );
5722   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5723
5724   // Adaptation tab ------------------------------------------------------------------------
5725   int adaptTab = addPreference( tr( "ADAPT_PREF_TAB_GENERAL" ) );
5726   int bloc, pref ;
5727   // Refinement with HOMARD
5728   bloc = addPreference( tr( "ADAPT_PREF_PUBLICATION" ), adaptTab );
5729   setPreferenceProperty( bloc, "columns", 1 );
5730   pref = addPreference( tr( "ADAPT_PREF_PUBLICATION_MAILLAGE_IN" ), bloc, LightApp_Preferences::Bool, "HOMARD", "publish_mesh_in" );
5731   pref = addPreference( tr( "ADAPT_PREF_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "publish_mesh_out" );
5732
5733   bloc = addPreference( tr( "ADAPT_PREF_YACS_MAX" ), adaptTab );
5734   setPreferenceProperty( bloc, "columns", 1 );
5735   pref = addPreference( tr( "ADAPT_PREF_YACS_MAX_ITER" ), bloc, LightApp_Preferences::IntSpin, "HOMARD", "yacs_max_iter" );
5736   setPreferenceProperty( pref, "min",  0 );
5737   setPreferenceProperty( pref, "max",  100000000 );
5738   setPreferenceProperty( pref, "step", 1 );
5739   pref = addPreference( tr( "ADAPT_PREF_YACS_MAX_NODE" ), bloc, LightApp_Preferences::IntSpin, "HOMARD", "yacs_max_node" );
5740   setPreferenceProperty( pref, "min",  0 );
5741   setPreferenceProperty( pref, "max",  100000000 );
5742   setPreferenceProperty( pref, "step", 1000 );
5743   pref = addPreference( tr( "ADAPT_PREF_YACS_MAX_ELEM" ), bloc, LightApp_Preferences::IntSpin, "HOMARD", "yacs_max_elem" );
5744   setPreferenceProperty( pref, "min",  0 );
5745   setPreferenceProperty( pref, "max",  100000000 );
5746   setPreferenceProperty( pref, "step", 1000 );
5747   bloc = addPreference( tr( "ADAPT_PREF_YACS_CONVERGENCE" ), adaptTab );
5748   setPreferenceProperty( bloc, "columns", 1 );
5749   pref = addPreference( tr( "ADAPT_PREF_YACS_TYPE_TEST" ), bloc, LightApp_Preferences::Selector, "HOMARD", "yacs_type_test" );
5750   QStringList aListOfTypeTest;
5751   aListOfTypeTest << "None";
5752   aListOfTypeTest << "VTest > VRef";
5753   aListOfTypeTest << "VTest < VRef";
5754   setPreferenceProperty( pref, "strings", aListOfTypeTest );
5755
5756 }
5757
5758 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5759 {
5760   if ( sect=="SMESH" ) {
5761     float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5762     float aTol = 1.00000009999999;
5763     std::string aWarning;
5764     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5765
5766     if ( name ==  "selection_object_color" ||
5767          name == "selection_element_color" ||
5768          name ==         "highlight_color" ||
5769          name == "selection_precision_node"    ||
5770          name == "selection_precision_element" ||
5771          name == "selection_precision_object"  ||
5772          name == "selection_increment")
5773     {
5774       SMESH::UpdateSelectionProp( this );
5775     }
5776     else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5777     {
5778       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x",     sbX1);
5779       sbW  = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5780       if ( sbX1+sbW > aTol ) {
5781         aWarning = "Origin and Size Vertical: X+Width > 1\n";
5782         sbX1 = 0.01;
5783         sbW  = 0.08;
5784         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x",     sbX1);
5785         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5786       }
5787     }
5788     else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5789     {
5790       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y",     sbY1);
5791       sbH  = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5792       if ( sbY1 + sbH > aTol ) {
5793         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5794         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y",     sbY1);
5795         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5796       }
5797     }
5798     else if (name == "scalar_bar_horizontal_x" || name ==  "scalar_bar_horizontal_width")
5799     {
5800       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x",     sbX1);
5801       sbW  = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5802       if ( sbX1 + sbW > aTol ) {
5803         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5804         sbX1=0.1;
5805         sbW =0.08;
5806         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5807         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5808       }
5809     }
5810     else if (name == "scalar_bar_horizontal_y" || name ==  "scalar_bar_horizontal_height")
5811     {
5812       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y",     sbY1);
5813       sbH  = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5814       if ( sbY1 + sbH > aTol ) {
5815         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5816         sbY1=0.01;
5817         sbH =0.08;
5818         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5819         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5820       }
5821     }
5822     else if ( name == "segmentation" )
5823     {
5824       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5825       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5826     }
5827     else if ( name == "nb_segments_per_edge" )
5828     {
5829       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5830       myComponentSMESH->SetDefaultNbSegments( nbSeg );
5831     }
5832     else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5833     {
5834       QString val = aResourceMgr->stringValue( "SMESH", name );
5835       myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5836     }
5837     else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5838     {
5839       SMESH::UpdateFontProp( this );
5840     }
5841     else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5842     {
5843       SMESH::UpdateFontProp( this );
5844     }
5845
5846     if ( aWarning.size() != 0 ) {
5847       aWarning += "The default values are applied instead.";
5848       SUIT_MessageBox::warning(SMESHGUI::desktop(),
5849                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5850                                QObject::tr(aWarning.c_str()));
5851     }
5852   }
5853 }
5854
5855 //================================================================================
5856 /*!
5857  * \brief Update something in accordance with update flags
5858   * \param theFlags - update flags
5859 *
5860 * Update viewer or/and object browser etc. in accordance with update flags ( see
5861 * LightApp_UpdateFlags enumeration ).
5862 */
5863 //================================================================================
5864 void SMESHGUI::update( const int flags )
5865 {
5866   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5867     SMESH::UpdateView();
5868   else
5869     SalomeApp_Module::update( flags );
5870 }
5871
5872 //================================================================================
5873 /*!
5874  * \brief Set default selection mode
5875 *
5876 * SLOT called when operation committed. Sets default selection mode
5877 */
5878 //================================================================================
5879 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5880 {
5881   SVTK_ViewWindow* vtkWnd =
5882     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5883   if ( vtkWnd )
5884     vtkWnd->SetSelectionMode( ActorSelection );
5885 }
5886
5887 //================================================================================
5888 /*!
5889  * \brief Set default selection mode
5890 *
5891 * SLOT called when operation aborted. Sets default selection mode
5892 */
5893 //================================================================================
5894 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5895 {
5896   SVTK_ViewWindow* vtkWnd =
5897     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5898   if ( vtkWnd )
5899     vtkWnd->SetSelectionMode( ActorSelection );
5900 }
5901
5902 //================================================================================
5903 /*!
5904  * \brief Creates operation with given identifier
5905   * \param id - identifier of operation to be started
5906   * \return Pointer on created operation or NULL if operation is not created
5907 *
5908 * Virtual method redefined from the base class creates operation with given id.
5909 * It is called called automatically from startOperation method of base class.
5910 */
5911 //================================================================================
5912 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5913 {
5914   LightApp_Operation* op = 0;
5915   // to do : create operation here
5916   switch( id )
5917   {
5918     case SMESHOp::OpUniformRefinement:
5919     case SMESHOp::OpHONewCase:
5920     case SMESHOp::OpHOCaseFollow:
5921     case SMESHOp::OpHONewIter:
5922     case SMESHOp::OpHOIterCompute:
5923     case SMESHOp::OpHOIterComputePublish:
5924     case SMESHOp::OpHOEdit:
5925     case SMESHOp::OpHODelete:
5926     case SMESHOp::OpMGAdapt:
5927     break;
5928     case SMESHOp::OpSplitBiQuadratic:
5929       op = new SMESHGUI_SplitBiQuadOp();
5930     break;
5931     case SMESHOp::OpConvertMeshToQuadratic:
5932       op = new SMESHGUI_ConvToQuadOp();
5933     break;
5934     case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5935       op = new SMESHGUI_Make2DFrom3DOp();
5936     break;
5937     case SMESHOp::OpReorientFaces:
5938       op = new SMESHGUI_ReorientFacesOp();
5939       break;
5940     case SMESHOp::OpCreateMesh:
5941       op = new SMESHGUI_MeshOp( true, true );
5942     break;
5943     case SMESHOp::OpCreateSubMesh:
5944       op = new SMESHGUI_MeshOp( true, false );
5945     break;
5946     case SMESHOp::OpEditMeshOrSubMesh:
5947     case SMESHOp::OpEditMesh:
5948     case SMESHOp::OpEditSubMesh:
5949       op = new SMESHGUI_MeshOp( false );
5950     break;
5951     case SMESHOp::OpCompute:
5952     case SMESHOp::OpComputeSubMesh:
5953       op = new SMESHGUI_ComputeOp();
5954     break;
5955     case SMESHOp::OpPreCompute:
5956       op = new SMESHGUI_PrecomputeOp();
5957     break;
5958     case SMESHOp::OpEvaluate:
5959       op = new SMESHGUI_EvaluateOp();
5960     break;
5961     case SMESHOp::OpMeshOrder:
5962       op = new SMESHGUI_MeshOrderOp();
5963     break;
5964     case SMESHOp::OpCreateGeometryGroup:
5965       op = new SMESHGUI_GroupOnShapeOp();
5966       break;
5967     case SMESHOp::OpFindElementByPoint:
5968       op = new SMESHGUI_FindElemByPointOp();
5969       break;
5970     case SMESHOp::OpMoveNode: // Make mesh pass through point
5971       op = new SMESHGUI_MakeNodeAtPointOp();
5972       break;
5973     case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5974       op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5975       break;
5976     default:
5977     break;
5978   }
5979
5980   if( !op )
5981     op = SalomeApp_Module::createOperation( id );
5982   return op;
5983 }
5984
5985 //================================================================================
5986 /*!
5987  * \brief Stops current operations and starts a given one
5988   * \param id - The id of the operation to start
5989  */
5990 //================================================================================
5991
5992 void SMESHGUI::switchToOperation(int id)
5993 {
5994   activeStudy()->abortAllOperations();
5995   startOperation( id );
5996 }
5997
5998 LightApp_Displayer* SMESHGUI::displayer()
5999 {
6000   if( !myDisplayer )
6001     myDisplayer = new SMESHGUI_Displayer( getApp() );
6002   return myDisplayer;
6003 }
6004
6005 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
6006 {
6007   int aHue = -1;
6008   int aTolerance = 64;
6009   int anIterations = 0;
6010   int aPeriod = 5;
6011
6012   while( 1 )
6013   {
6014     anIterations++;
6015     if( anIterations % aPeriod == 0 )
6016     {
6017       aTolerance /= 2;
6018       if( aTolerance < 1 )
6019         break;
6020     }
6021
6022     aHue = (int)( 360.0 * rand() / RAND_MAX );
6023
6024     bool ok = true;
6025     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
6026     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
6027     for( ; it != itEnd; ++it )
6028     {
6029       SALOMEDS::Color anAutoColor = *it;
6030       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6031
6032       int h, s, v;
6033       aQColor.getHsv( &h, &s, &v );
6034       if( abs( h - aHue ) < aTolerance )
6035       {
6036         ok = false;
6037         break;
6038       }
6039     }
6040
6041     if( ok )
6042       break;
6043   }
6044
6045   QColor aColor;
6046   aColor.setHsv( aHue, 255, 255 );
6047
6048   SALOMEDS::Color aSColor;
6049   aSColor.R = aColor.redF();
6050   aSColor.G = aColor.greenF();
6051   aSColor.B = aColor.blueF();
6052
6053   return aSColor;
6054 }
6055
6056 const char* gSeparator = "_"; // character used to separate parameter names
6057 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6058 const char* gPathSep   = "|"; // character used to separate paths
6059
6060 /*!
6061  * \brief Store visual parameters
6062  *
6063  * This method is called just before the study document is saved.
6064  * Store visual parameters in AttributeParameter attribute(s)
6065  */
6066 void SMESHGUI::storeVisualParameters (int savePoint)
6067 {
6068   // localizing
6069   Kernel_Utils::Localizer loc;
6070
6071   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6072   if (!appStudy || !appStudy->studyDS())
6073     return;
6074   _PTR(Study) studyDS = appStudy->studyDS();
6075
6076   // componentName is used for encoding of entries when storing them in IParameters
6077   std::string componentName = myComponentSMESH->ComponentDataType();
6078   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6079   //if (!aSComponent) return;
6080
6081   // IParameters
6082   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6083                                                              componentName.c_str(),
6084                                                              savePoint);
6085   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6086
6087   // store custom markers
6088   if( !myMarkerMap.empty() )
6089   {
6090     VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6091     for( ; anIter != myMarkerMap.end(); anIter++ )
6092     {
6093       int anId = anIter->first;
6094       VTK::MarkerData aMarkerData = anIter->second;
6095       std::string aMarkerFileName = aMarkerData.first;
6096       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6097       if( aMarkerTexture.size() < 3 )
6098         continue; // should contain at least width, height and the first value
6099
6100       QString aPropertyName( "texture" );
6101       aPropertyName += gSeparator;
6102       aPropertyName += QString::number( anId );
6103
6104       QString aPropertyValue = aMarkerFileName.c_str();
6105       aPropertyValue += gPathSep;
6106
6107       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6108       ushort aWidth = *aTextureIter++;
6109       ushort aHeight = *aTextureIter++;
6110       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6111       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6112       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6113         aPropertyValue += QString::number( *aTextureIter );
6114
6115       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6116     }
6117   }
6118
6119   // viewers counters are used for storing view_numbers in IParameters
6120   int vtkViewers = 0;
6121
6122   // main cycle to store parameters of displayed objects
6123   QList<SUIT_ViewManager*> lst;
6124   QList<SUIT_ViewManager*>::Iterator it;
6125   getApp()->viewManagers(lst);
6126   for (it = lst.begin(); it != lst.end(); it++)
6127   {
6128     SUIT_ViewManager* vman = *it;
6129     QString vType = vman->getType();
6130
6131     // saving VTK actors properties
6132     if (vType == SVTK_Viewer::Type())
6133     {
6134       // store the clipping planes attached to the view manager
6135       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6136       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6137       if( anIter != myClippingPlaneInfoMap.end() )
6138         aClippingPlaneInfoList = anIter->second;
6139
6140       if( !aClippingPlaneInfoList.empty() ) {
6141         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6142         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6143         {
6144           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6145           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6146
6147           QString aPropertyName( "ClippingPlane" );
6148           aPropertyName += gSeparator;
6149           aPropertyName += QString::number( vtkViewers );
6150           aPropertyName += gSeparator;
6151           aPropertyName += QString::number( anId );
6152
6153           QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6154           aPropertyValue += gDigitsSep;
6155           aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6156           aPropertyValue += gDigitsSep;
6157           if ( aPlane->PlaneMode == SMESH::Absolute ) {
6158             aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6159             aPropertyValue += gDigitsSep;
6160             aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6161             aPropertyValue += gDigitsSep;
6162             aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6163             aPropertyValue += gDigitsSep;
6164             aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6165             aPropertyValue += gDigitsSep;
6166             aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6167             aPropertyValue += gDigitsSep;
6168             aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6169             aPropertyValue += gDigitsSep;
6170             aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6171           }
6172           else if ( aPlane->PlaneMode == SMESH::Relative ) {
6173             aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6174             aPropertyValue += gDigitsSep;
6175             aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6176             aPropertyValue += gDigitsSep;
6177             aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6178             aPropertyValue += gDigitsSep;
6179             aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6180           }
6181
6182           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6183         }
6184       }
6185
6186       QVector<SUIT_ViewWindow*> views = vman->getViews();
6187       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6188       {
6189         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6190         {
6191           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6192           vtkActorCollection* allActors = aCopy.GetActors();
6193           allActors->InitTraversal();
6194           while (vtkActor* actor = allActors->GetNextActor())
6195           {
6196             if (actor->GetVisibility()) // store only visible actors
6197             {
6198               SMESH_Actor* aSmeshActor = 0;
6199               if (actor->IsA("SMESH_Actor"))
6200                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6201               if (aSmeshActor && aSmeshActor->hasIO())
6202               {
6203                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6204                 if (io->hasEntry())
6205                 {
6206                   // entry is "encoded" = it does NOT contain component address,
6207                   // since it is a subject to change on next component loading
6208                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6209
6210                   std::string param, vtkParam = vType.toLatin1().data();
6211                   vtkParam += gSeparator;
6212                   vtkParam += QString::number(vtkViewers).toLatin1().data();
6213                   vtkParam += gSeparator;
6214
6215                   // Visibility
6216                   param = vtkParam + "Visibility";
6217                   ip->setParameter(entry, param, "On");
6218
6219                   // Representation
6220                   param = vtkParam + "Representation";
6221                   ip->setParameter(entry, param, QString::number
6222                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6223
6224                   // IsShrunk
6225                   param = vtkParam + "IsShrunk";
6226                   ip->setParameter(entry, param, QString::number
6227                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6228
6229                   // Displayed entities
6230                   unsigned int aMode = aSmeshActor->GetEntityMode();
6231                   bool isE  = aMode & SMESH_Actor::eEdges;
6232                   bool isF  = aMode & SMESH_Actor::eFaces;
6233                   bool isV  = aMode & SMESH_Actor::eVolumes;
6234                   bool is0d = aMode & SMESH_Actor::e0DElements;
6235                   bool isB  = aMode & SMESH_Actor::eBallElem;
6236
6237                   QString modeStr ("e");
6238                   modeStr += gDigitsSep; modeStr += QString::number(isE);
6239                   modeStr += gDigitsSep; modeStr += "f";
6240                   modeStr += gDigitsSep; modeStr += QString::number(isF);
6241                   modeStr += gDigitsSep; modeStr += "v";
6242                   modeStr += gDigitsSep; modeStr += QString::number(isV);
6243                   modeStr += gDigitsSep; modeStr += "0d";
6244                   modeStr += gDigitsSep; modeStr += QString::number(is0d);
6245                   modeStr += gDigitsSep; modeStr += "b";
6246                   modeStr += gDigitsSep; modeStr += QString::number(isB);
6247
6248                   param = vtkParam + "Entities";
6249                   ip->setParameter(entry, param, modeStr.toLatin1().data());
6250
6251                   // Colors
6252                   double r, g, b;
6253                   int delta;
6254
6255                   aSmeshActor->GetSufaceColor(r, g, b, delta);
6256                   QStringList colorStr;
6257                   colorStr << "surface";
6258                   colorStr << QString::number(r);
6259                   colorStr << QString::number(g);
6260                   colorStr << QString::number(b);
6261
6262                   colorStr << "backsurface";
6263                   colorStr << QString::number(delta);
6264
6265                   aSmeshActor->GetVolumeColor(r, g, b, delta);
6266                   colorStr << "volume";
6267                   colorStr << QString::number(r);
6268                   colorStr << QString::number(g);
6269                   colorStr << QString::number(b);
6270                   colorStr << QString::number(delta);
6271
6272                   aSmeshActor->GetEdgeColor(r, g, b);
6273                   colorStr << "edge";
6274                   colorStr << QString::number(r);
6275                   colorStr << QString::number(g);
6276                   colorStr << QString::number(b);
6277
6278                   aSmeshActor->GetNodeColor(r, g, b);
6279                   colorStr << "node";
6280                   colorStr << QString::number(r);
6281                   colorStr << QString::number(g);
6282                   colorStr << QString::number(b);
6283
6284                   aSmeshActor->GetOutlineColor(r, g, b);
6285                   colorStr << "outline";
6286                   colorStr << QString::number(r);
6287                   colorStr << QString::number(g);
6288                   colorStr << QString::number(b);
6289
6290                   aSmeshActor->Get0DColor(r, g, b);
6291                   colorStr << "elem0d";
6292                   colorStr << QString::number(r);
6293                   colorStr << QString::number(g);
6294                   colorStr << QString::number(b);
6295
6296                   aSmeshActor->GetBallColor(r, g, b);
6297                   colorStr << "ball";
6298                   colorStr << QString::number(r);
6299                   colorStr << QString::number(g);
6300                   colorStr << QString::number(b);
6301
6302                   aSmeshActor->GetFacesOrientationColor(r, g, b);
6303                   colorStr << "orientation";
6304                   colorStr << QString::number(r);
6305                   colorStr << QString::number(g);
6306                   colorStr << QString::number(b);
6307
6308                   param = vtkParam + "Colors";
6309                   ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6310
6311                   // Sizes
6312                   QStringList sizeStr;
6313                   sizeStr << "line";
6314                   sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6315                   sizeStr << "outline";
6316                   sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6317                   sizeStr << "elem0d";
6318                   sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6319                   sizeStr << "ball";
6320                   //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6321                   sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6322                   sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6323                   sizeStr << "shrink";
6324                   sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6325                   sizeStr << "orientation";
6326                   sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6327                   sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6328
6329                   param = vtkParam + "Sizes";
6330                   ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6331
6332                   // Point marker
6333                   QString markerStr;
6334
6335                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6336                   if( aMarkerType == VTK::MT_USER ) {
6337                     markerStr += "custom";
6338                     markerStr += gDigitsSep;
6339                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6340                   }
6341                   else {
6342                     markerStr += "std";
6343                     markerStr += gDigitsSep;
6344                     markerStr += QString::number( (int)aMarkerType );
6345                     markerStr += gDigitsSep;
6346                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6347                   }
6348
6349                   param = vtkParam + "PointMarker";
6350                   ip->setParameter(entry, param, markerStr.toLatin1().data());
6351
6352                   // Opacity
6353                   param = vtkParam + "Opacity";
6354                   ip->setParameter(entry, param,
6355                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6356
6357                   // Clipping
6358                   param = vtkParam + "ClippingPlane";
6359                   int aPlaneId = 0;
6360                   if( !aClippingPlaneInfoList.empty() ) {
6361                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6362                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6363                     {
6364                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6365                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6366                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
6367                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6368                         if( aSmeshActor == *anIter2 ) {
6369                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6370                                             QString::number( anId ).toLatin1().constData() );
6371                           break;
6372                         }
6373                       }
6374                     }
6375                   }
6376                   if( aPlaneId == 0 )
6377                     ip->setParameter( entry, param, "Off" );
6378                 } // if (io->hasEntry())
6379               } // SMESH_Actor && hasIO
6380             } // isVisible
6381           } // while.. actors traversal
6382         } // if (vtkView)
6383       } // for (views)
6384       vtkViewers++;
6385     } // if (SVTK view model)
6386   } // for (viewManagers)
6387 }
6388
6389 // data structures for clipping planes processing
6390 typedef struct {
6391   int Id;
6392   int Mode;
6393   bool isOpenGLClipping;
6394   vtkIdType RelativeOrientation;
6395   double Distance;
6396   double Angle[2];
6397   int AbsoluteOrientation;
6398   double X, Y, Z, Dx, Dy, Dz;
6399 } TPlaneData;
6400 typedef std::list<TPlaneData>         TPlaneDataList;
6401 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6402
6403 typedef std::list<vtkActor*>          TActorList;
6404 typedef struct {
6405   int PlaneId;
6406   TActorList ActorList;
6407   SUIT_ViewManager* ViewManager;
6408 } TPlaneInfo;
6409 typedef std::list<TPlaneInfo>         TPlaneInfoList;
6410 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6411
6412 /*!
6413  * \brief Restore visual parameters
6414  *
6415  * This method is called after the study document is opened.
6416  * Restore visual parameters from AttributeParameter attribute(s)
6417  */
6418 void SMESHGUI::restoreVisualParameters (int savePoint)
6419 {
6420   // localizing
6421   Kernel_Utils::Localizer loc;
6422
6423   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6424   if (!appStudy || !appStudy->studyDS())
6425     return;
6426   _PTR(Study) studyDS = appStudy->studyDS();
6427
6428   // componentName is used for encoding of entries when storing them in IParameters
6429   std::string componentName = myComponentSMESH->ComponentDataType();
6430
6431   // IParameters
6432   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6433                                                              componentName.c_str(),
6434                                                              savePoint);
6435   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6436
6437   // restore custom markers and map of clipping planes
6438   TPlaneDataMap aPlaneDataMap;
6439
6440   std::vector<std::string> properties = ip->getProperties();
6441   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6442   {
6443     std::string property = *propIt;
6444     QString aPropertyName( property.c_str() );
6445     QString aPropertyValue( ip->getProperty( property ).c_str() );
6446
6447     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6448     if( aPropertyNameList.isEmpty() )
6449       continue;
6450
6451     QString aPropertyType = aPropertyNameList[0];
6452     if( aPropertyType == "texture" )
6453     {
6454       if( aPropertyNameList.size() != 2 )
6455         continue;
6456
6457       bool ok = false;
6458       int anId = aPropertyNameList[1].toInt( &ok );
6459       if( !ok || anId < 1 )
6460         continue;
6461
6462       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6463       if( aPropertyValueList.size() != 2 )
6464         continue;
6465
6466       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6467       QString aMarkerTextureString = aPropertyValueList[1];
6468       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6469       if( aMarkerTextureStringList.size() != 3 )
6470         continue;
6471
6472       ok = false;
6473       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6474       if( !ok )
6475         continue;
6476
6477       ok = false;
6478       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6479       if( !ok )
6480         continue;
6481
6482       VTK::MarkerTexture aMarkerTexture;
6483       aMarkerTexture.push_back( aWidth );
6484       aMarkerTexture.push_back( aHeight );
6485
6486       QString aMarkerTextureData = aMarkerTextureStringList[2];
6487       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6488       {
6489         QChar aChar = aMarkerTextureData.at( i );
6490         if( aChar.isDigit() )
6491           aMarkerTexture.push_back( aChar.digitValue() );
6492       }
6493
6494       myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6495     }
6496     else if( aPropertyType == "ClippingPlane" )
6497     {
6498       if( aPropertyNameList.size() != 3 )
6499         continue;
6500
6501       bool ok = false;
6502       int aViewId = aPropertyNameList[1].toInt( &ok );
6503       if( !ok || aViewId < 0 )
6504         continue;
6505
6506       ok = false;
6507       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6508       if( !ok || aClippingPlaneId < 0 )
6509         continue;
6510
6511       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6512       if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6513         continue;
6514
6515       TPlaneData aPlaneData;
6516       aPlaneData.AbsoluteOrientation = false;
6517       aPlaneData.RelativeOrientation = 0;
6518       aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6519       aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6520       aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6521
6522       aPlaneData.Id = aClippingPlaneId;
6523
6524       ok = false;
6525       aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6526       if( !ok )
6527         continue;
6528
6529       ok = false;
6530       aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6531       if( !ok )
6532         continue;
6533
6534       if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6535       {
6536         ok = false;
6537         aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6538         if( !ok )
6539           continue;
6540
6541         ok = false;
6542         aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6543         if( !ok )
6544           continue;
6545
6546         ok = false;
6547         aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6548         if( !ok )
6549           continue;
6550
6551         ok = false;
6552         aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6553         if( !ok )
6554           continue;
6555
6556         ok = false;
6557         aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6558         if( !ok )
6559           continue;
6560
6561         ok = false;
6562         aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6563         if( !ok )
6564           continue;
6565
6566         ok = false;
6567         aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6568         if( !ok )
6569           continue;
6570       }
6571       else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6572         ok = false;
6573         aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6574         if( !ok )
6575           continue;
6576
6577         ok = false;
6578         aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6579         if( !ok )
6580           continue;
6581
6582         ok = false;
6583         aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6584         if( !ok )
6585           continue;
6586
6587         ok = false;
6588         aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6589         if( !ok )
6590           continue;
6591       }
6592
6593       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6594       aPlaneDataList.push_back( aPlaneData );
6595     }
6596   }
6597
6598   TPlaneInfoMap aPlaneInfoMap;
6599
6600   std::vector<std::string> entries = ip->getEntries();
6601
6602   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6603   {
6604     // entry is a normal entry - it should be "decoded" (setting base address of component)
6605     QString entry (ip->decodeEntry(*entIt).c_str());
6606
6607     // Check that the entry corresponds to a real object in the Study
6608     // as the object may be deleted or modified after the visual state is saved.
6609     _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6610     if (!so) continue; //Skip the not existent entry
6611
6612     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6613     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6614
6615     std::vector<std::string>::iterator namesIt = paramNames.begin();
6616     std::vector<std::string>::iterator valuesIt = paramValues.begin();
6617
6618     // actors are stored in a map after displaying of them for
6619     // quicker access in the future: map < viewID to actor >
6620     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6621
6622     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6623     {
6624       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6625       // '_' is used as separator and should not be used in viewer type or parameter names.
6626       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6627       if (lst.size() != 3)
6628         continue;
6629
6630       QString viewerTypStr = lst[0];
6631       QString viewIndexStr = lst[1];
6632       QString paramNameStr = lst[2];
6633
6634       bool ok;
6635       int viewIndex = viewIndexStr.toUInt(&ok);
6636       if (!ok) // bad conversion of view index to integer
6637         continue;
6638
6639       // viewers
6640       if (viewerTypStr == SVTK_Viewer::Type())
6641       {
6642         SMESH_Actor* aSmeshActor = 0;
6643         if (vtkActors.IsBound(viewIndex))
6644           aSmeshActor = vtkActors.Find(viewIndex);
6645
6646         QList<SUIT_ViewManager*> lst;
6647         getApp()->viewManagers(viewerTypStr, lst);
6648
6649         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6650         SUIT_ViewManager* vman = NULL;
6651         if (viewIndex >= 0 && viewIndex < lst.count())
6652           vman = lst.at(viewIndex);
6653
6654         if (paramNameStr == "Visibility")
6655         {
6656           if (!aSmeshActor && displayer() && vman)
6657           {
6658             SUIT_ViewModel* vmodel = vman->getViewModel();
6659             // SVTK view model can be casted to SALOME_View
6660             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6661
6662             // store displayed actor in a temporary map for quicker
6663             // access later when restoring other parameters
6664             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6665             vtkRenderer* Renderer = vtkView->getRenderer();
6666             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6667             vtkActorCollection* theActors = aCopy.GetActors();
6668             theActors->InitTraversal();
6669             bool isFound = false;
6670             vtkActor *ac = theActors->GetNextActor();
6671             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6672               if (ac->IsA("SMESH_Actor")) {
6673                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6674                 if (aGeomAc->hasIO()) {
6675                   Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6676                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6677                     isFound = true;
6678                     vtkActors.Bind(viewIndex, aGeomAc);
6679                   }
6680                 }
6681               }
6682             }
6683           }
6684         } // if (paramNameStr == "Visibility")
6685         else
6686         {
6687           // the rest properties "work" with SMESH_Actor
6688           if (aSmeshActor)
6689           {
6690             QString val ((*valuesIt).c_str());
6691
6692             // Representation
6693             if (paramNameStr == "Representation") {
6694               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6695             }
6696             // IsShrunk
6697             else if (paramNameStr == "IsShrunk") {
6698               if (val.toInt()) {
6699                 if (!aSmeshActor->IsShrunk())
6700                   aSmeshActor->SetShrink();
6701               }
6702               else {
6703                 if (aSmeshActor->IsShrunk())
6704                   aSmeshActor->UnShrink();
6705               }
6706             }
6707             // Displayed entities
6708             else if (paramNameStr == "Entities") {
6709               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6710               int aEntityMode = SMESH_Actor::eAllEntity;
6711               for ( int i = 0; i < mode.count(); i+=2 ) {
6712                 if ( i < mode.count()-1 ) {
6713                   QString type = mode[i];
6714                   bool val = mode[i+1].toInt();
6715                   if      ( type == "e" && !val )
6716                     aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6717                   else if ( type == "f" && !val )
6718                     aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6719                   else if ( type == "v" && !val )
6720                     aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6721                   else if ( type == "0d" && !val )
6722                     aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6723                   else if ( type == "b" && !val )
6724                     aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6725                 }
6726               }
6727               aSmeshActor->SetEntityMode( aEntityMode );
6728             }
6729             // Colors
6730             else if (paramNameStr == "Colors") {
6731               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6732               QColor nodeColor;
6733               QColor edgeColor;
6734               QColor faceColor;
6735               QColor volumeColor;
6736               QColor elem0dColor;
6737               QColor ballColor;
6738               QColor outlineColor;
6739               QColor orientationColor;
6740               int deltaF;
6741               int deltaV;
6742               QColor c;
6743               double r, g, b;
6744               bool bOk;
6745               // below lines are required to get default values for delta coefficients
6746               // of backface color for faces and color of reversed volumes
6747               SMESH::GetColor( "SMESH", "fill_color",   c, deltaF, "0,170,255|-100" );
6748               SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6749               for ( int i = 0; i < colors.count(); i++ ) {
6750                 QString type = colors[i];
6751                 if ( type == "surface" ) {
6752                   // face color is set by 3 values r:g:b, where
6753                   // - r,g,b - is rgb color components
6754                   if ( i+1 >= colors.count() ) break;                  // format error
6755                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6756                   if ( i+2 >= colors.count() ) break;                  // format error
6757                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6758                   if ( i+3 >= colors.count() ) break;                  // format error
6759                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6760                   faceColor.setRgbF( r, g, b );
6761                   i += 3;
6762                 }
6763                 else if ( type == "backsurface" ) {
6764                   // backface color can be defined in several ways
6765                   // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6766                   // - in latest versions, it is set as delta coefficient
6767                   bool rgbOk = false, deltaOk;
6768                   if ( i+1 >= colors.count() ) break;                  // format error
6769                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6770                   int delta = colors[i+1].toInt( &deltaOk );
6771                   i++;                                 // shift index
6772                   if ( i+1 < colors.count() )          // index is shifted to 1
6773                     g = colors[i+1].toDouble( &rgbOk );
6774                   if ( rgbOk ) i++;                    // shift index
6775                   if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6776                     b = colors[i+1].toDouble( &rgbOk );
6777                   if ( rgbOk ) i++;
6778                   // - as currently there's no way to set directly backsurface color as it was before,
6779                   // we ignore old dump where r,g,b triple was set
6780                   // - also we check that delta parameter is set properly
6781                   if ( !rgbOk && deltaOk )
6782                     deltaF = delta;
6783                 }
6784                 else if ( type == "volume" ) {
6785                   // volume color is set by 4 values r:g:b:delta, where
6786                   // - r,g,b - is a normal volume rgb color components
6787                   // - delta - is a reversed volume color delta coefficient
6788                   if ( i+1 >= colors.count() ) break;                  // format error
6789                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6790                   if ( i+2 >= colors.count() ) break;                  // format error
6791                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6792                   if ( i+3 >= colors.count() ) break;                  // format error
6793                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6794                   if ( i+4 >= colors.count() ) break;                  // format error
6795                   int delta = colors[i+4].toInt( &bOk );
6796                   if ( !bOk ) break;                                   // format error
6797                   volumeColor.setRgbF( r, g, b );
6798                   deltaV = delta;
6799                   i += 4;
6800                 }
6801                 else if ( type == "edge" ) {
6802                   // edge color is set by 3 values r:g:b, where
6803                   // - r,g,b - is rgb color components
6804                   if ( i+1 >= colors.count() ) break;                  // format error
6805                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6806                   if ( i+2 >= colors.count() ) break;                  // format error
6807                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6808                   if ( i+3 >= colors.count() ) break;                  // format error
6809                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6810                   edgeColor.setRgbF( r, g, b );
6811                   i += 3;
6812                 }
6813                 else if ( type == "node" ) {
6814                   // node color is set by 3 values r:g:b, where
6815                   // - r,g,b - is rgb color components
6816                   if ( i+1 >= colors.count() ) break;                  // format error
6817                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6818                   if ( i+2 >= colors.count() ) break;                  // format error
6819                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6820                   if ( i+3 >= colors.count() ) break;                  // format error
6821                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6822                   nodeColor.setRgbF( r, g, b );
6823                   i += 3;
6824                 }
6825                 else if ( type == "elem0d" ) {
6826                   // 0d element color is set by 3 values r:g:b, where
6827                   // - r,g,b - is rgb color components
6828                   if ( i+1 >= colors.count() ) break;                  // format error
6829                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6830                   if ( i+2 >= colors.count() ) break;                  // format error
6831                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6832                   if ( i+3 >= colors.count() ) break;                  // format error
6833                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6834                   elem0dColor.setRgbF( r, g, b );
6835                   i += 3;
6836                 }
6837                 else if ( type == "ball" ) {
6838                   // ball color is set by 3 values r:g:b, where
6839                   // - r,g,b - is rgb color components
6840                   if ( i+1 >= colors.count() ) break;                  // format error
6841                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6842                   if ( i+2 >= colors.count() ) break;                  // format error
6843                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6844                   if ( i+3 >= colors.count() ) break;                  // format error
6845                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6846                   ballColor.setRgbF( r, g, b );
6847                   i += 3;
6848                 }
6849                 else if ( type == "outline" ) {
6850                   // outline color is set by 3 values r:g:b, where
6851                   // - r,g,b - is rgb color components
6852                   if ( i+1 >= colors.count() ) break;                  // format error
6853                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6854                   if ( i+2 >= colors.count() ) break;                  // format error
6855                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6856                   if ( i+3 >= colors.count() ) break;                  // format error
6857                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6858                   outlineColor.setRgbF( r, g, b );
6859                   i += 3;
6860                 }
6861                 else if ( type == "orientation" ) {
6862                   // orientation color is set by 3 values r:g:b, where
6863                   // - r,g,b - is rgb color components
6864                   if ( i+1 >= colors.count() ) break;                  // format error
6865                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6866                   if ( i+2 >= colors.count() ) break;                  // format error
6867                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6868                   if ( i+3 >= colors.count() ) break;                  // format error
6869                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6870                   orientationColor.setRgbF( r, g, b );
6871                   i += 3;
6872                 }
6873               }
6874               // node color
6875               if ( nodeColor.isValid() )
6876                 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6877               // edge color
6878               if ( edgeColor.isValid() )
6879                 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6880               // face color
6881               if ( faceColor.isValid() )
6882                 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6883               // volume color
6884               if ( volumeColor.isValid() )
6885                 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6886               else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6887                 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6888               // 0d element color
6889               if ( elem0dColor.isValid() )
6890                 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6891               // ball color
6892               if ( ballColor.isValid() )
6893                 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6894               // outline color
6895               if ( outlineColor.isValid() )
6896                 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6897               // orientation color
6898               if ( orientationColor.isValid() )
6899                 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6900             }
6901             // Sizes
6902             else if (paramNameStr == "Sizes") {
6903               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6904               bool bOk;
6905               int lineWidth = -1;
6906               int outlineWidth = -1;
6907               int elem0dSize = -1;
6908               //int ballSize = -1;
6909               double ballDiameter = -1.0;
6910               double ballScale = -1.0;
6911               double shrinkSize = -1;
6912               double orientationSize = -1;
6913               bool orientation3d = false;
6914               for ( int i = 0; i < sizes.count(); i++ ) {
6915                 QString type = sizes[i];
6916                 if ( type == "line" ) {
6917                   // line (wireframe) width is given as single integer value
6918                   if ( i+1 >= sizes.count() ) break;                    // format error
6919                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6920                   lineWidth = v;
6921                   i++;
6922                 }
6923                 if ( type == "outline" ) {
6924                   // outline width is given as single integer value
6925                   if ( i+1 >= sizes.count() ) break;                    // format error
6926                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6927                   outlineWidth = v;
6928                   i++;
6929                 }
6930                 else if ( type == "elem0d" ) {
6931                   // 0d element size is given as single integer value
6932                   if ( i+1 >= sizes.count() ) break;                    // format error
6933                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6934                   elem0dSize = v;
6935                   i++;
6936                 }
6937                 else if ( type == "ball" ) {
6938                   // balls are specified by two values: size:scale, where
6939                   // - size - is a integer value specifying size
6940                   // - scale - is a double value specifying scale factor
6941                   if ( i+1 >= sizes.count() ) break;                       // format error
6942                   //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6943                   double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6944                   if ( i+2 >= sizes.count() ) break;                       // format error
6945                   double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6946                   //ballSize = v1;
6947                   ballDiameter = v1;
6948                   ballScale = v2;
6949                   i += 2;
6950                 }
6951                 else if ( type == "shrink" ) {
6952                   // shrink factor is given as single floating point value
6953                   if ( i+1 >= sizes.count() ) break;                          // format error
6954                   double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break;  // format error
6955                   shrinkSize = v;
6956                   i++;
6957                 }
6958                 else if ( type == "orientation" ) {
6959                   // orientation vectors are specified by two values size:3d, where
6960                   // - size - is a floating point value specifying scale factor
6961                   // - 3d - is a boolean
6962                   if ( i+1 >= sizes.count() ) break;                          // format error
6963                   double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6964                   if ( i+2 >= sizes.count() ) break;                          // format error
6965                   int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break;       // format error
6966                   orientationSize = v1;
6967                   orientation3d = (bool)v2;
6968                   i += 2;
6969                 }
6970               }
6971               // line (wireframe) width
6972               if ( lineWidth > 0 )
6973                 aSmeshActor->SetLineWidth( lineWidth );
6974               // outline width
6975               if ( outlineWidth > 0 )
6976                 aSmeshActor->SetOutlineWidth( outlineWidth );
6977               else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6978                 aSmeshActor->SetOutlineWidth( lineWidth );
6979               // 0d element size
6980               if ( elem0dSize > 0 )
6981                 aSmeshActor->Set0DSize( elem0dSize );
6982               // ball size
6983               /*if ( ballSize > 0 )
6984                 aSmeshActor->SetBallSize( ballSize );*/
6985               // ball diameter
6986               if ( ballDiameter > 0 )
6987                 aSmeshActor->SetBallSize( ballDiameter );
6988               // ball scale
6989               if ( ballScale > 0.0 )
6990                 aSmeshActor->SetBallScale( ballScale );
6991               // shrink factor
6992               if ( shrinkSize > 0 )
6993                 aSmeshActor->SetShrinkFactor( shrinkSize );
6994               // orientation vectors
6995               if ( orientationSize > 0 ) {
6996                 aSmeshActor->SetFacesOrientationScale( orientationSize );
6997                 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6998               }
6999             }
7000             // Point marker
7001             else if (paramNameStr == "PointMarker") {
7002               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
7003               if( data.count() >= 2 ) {
7004                 bool ok = false;
7005                 int aParam1 = data[1].toInt( &ok );
7006                 if( ok ) {
7007                   if( data[0] == "std" && data.count() == 3 ) {
7008                     int aParam2 = data[2].toInt( &ok );
7009                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
7010                   }
7011                   else if( data[0] == "custom" ) {
7012                     VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
7013                     if( markerIt != myMarkerMap.end() ) {
7014                       VTK::MarkerData aMarkerData = markerIt->second;
7015                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
7016                     }
7017                   }
7018                 }
7019               }
7020             }
7021             // Opacity
7022             else if (paramNameStr == "Opacity") {
7023               aSmeshActor->SetOpacity(val.toFloat());
7024             }
7025             // Clipping
7026             else if (paramNameStr.startsWith("ClippingPlane")) {
7027               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
7028               // old format - val looks like "Off" or "1:0:0:0.5:0:0"
7029               // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
7030               // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
7031               // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7032               // new format - val looks like "Off" or "0" (plane id)
7033               // (note: in new format "Off" value is used only for consistency,
7034               //  so it is processed together with values in old format)
7035               bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7036               if( anIsOldFormat ) {
7037                 if (paramNameStr == "ClippingPlane1" || val == "Off")
7038                   aSmeshActor->RemoveAllClippingPlanes();
7039                 if (val != "Off") {
7040                   QList<SUIT_ViewManager*> lst;
7041                   getApp()->viewManagers(viewerTypStr, lst);
7042                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7043                   if (viewIndex >= 0 && viewIndex < lst.count()) {
7044                     SUIT_ViewManager* vman = lst.at(viewIndex);
7045                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7046
7047                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7048
7049                     SMESH::TActorList anActorList;
7050                     anActorList.push_back( aSmeshActor );
7051                     SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7052                     aPlane->myViewWindow = vtkView;
7053                     SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7054                     aPlane->PlaneMode = aMode;
7055                     bool isOpenGLClipping = ( bool )vals[1].toInt();
7056                     aPlane->IsOpenGLClipping = isOpenGLClipping;
7057                     if ( aMode == SMESH::Absolute ) {
7058                       aPlane->myAbsoluteOrientation = vals[2].toInt();
7059                       aPlane->X = vals[3].toFloat();
7060                       aPlane->Y = vals[4].toFloat();
7061                       aPlane->Z = vals[5].toFloat();
7062                       aPlane->Dx = vals[6].toFloat();
7063                       aPlane->Dy = vals[7].toFloat();
7064                       aPlane->Dz = vals[8].toFloat();
7065                     }
7066                     else if ( aMode == SMESH::Relative ) {
7067                       aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7068                       aPlane->myDistance = vals[3].toFloat();
7069                       aPlane->myAngle[0] = vals[4].toFloat();
7070                       aPlane->myAngle[1] = vals[5].toFloat();
7071                     }
7072
7073                     if( aPlane ) {
7074                       if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7075                         SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7076                         aClippingPlaneInfo.Plane = aPlane;
7077                         aClippingPlaneInfo.ActorList = anActorList;
7078                         aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7079                       }
7080                     }
7081                   }
7082                 }
7083               }
7084               else {
7085                 bool ok = false;
7086                 int aPlaneId = val.toInt( &ok );
7087                 if( ok && aPlaneId >= 0 ) {
7088                   bool anIsDefinedPlane = false;
7089                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7090                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7091                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7092                     TPlaneInfo& aPlaneInfo = *anIter;
7093                     if( aPlaneInfo.PlaneId == aPlaneId ) {
7094                       aPlaneInfo.ActorList.push_back( aSmeshActor );
7095                       anIsDefinedPlane = true;
7096                       break;
7097                     }
7098                   }
7099                   if( !anIsDefinedPlane ) {
7100                     TPlaneInfo aPlaneInfo;
7101                     aPlaneInfo.PlaneId = aPlaneId;
7102                     aPlaneInfo.ActorList.push_back( aSmeshActor );
7103                     aPlaneInfo.ViewManager = vman;
7104
7105                     // to make the list sorted by plane id
7106                     anIter = aPlaneInfoList.begin();
7107                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7108                       const TPlaneInfo& aPlaneInfoRef = *anIter;
7109                       if( aPlaneInfoRef.PlaneId > aPlaneId )
7110                         break;
7111                     }
7112                     aPlaneInfoList.insert( anIter, aPlaneInfo );
7113                   }
7114                 }
7115               }
7116             }
7117           } // if (aSmeshActor)
7118         } // other parameters than Visibility
7119       }
7120     } // for names/parameters iterator
7121   } // for entries iterator
7122
7123   // take into account planes with empty list of actors referred to them
7124   QList<SUIT_ViewManager*> aVMList;
7125   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7126
7127   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7128   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7129     int aViewId = aPlaneDataIter->first;
7130     if( aViewId >= 0 && aViewId < aVMList.count() ) {
7131       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7132
7133       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7134
7135       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7136       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7137       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7138         const TPlaneData& aPlaneData = *anIter2;
7139         int aPlaneId = aPlaneData.Id;
7140
7141         bool anIsFound = false;
7142         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7143         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7144           const TPlaneInfo& aPlaneInfo = *anIter3;
7145           if( aPlaneInfo.PlaneId == aPlaneId ) {
7146             anIsFound = true;
7147             break;
7148           }
7149         }
7150
7151         if( !anIsFound ) {
7152           TPlaneInfo aPlaneInfo; // ActorList field is empty
7153           aPlaneInfo.PlaneId = aPlaneId;
7154           aPlaneInfo.ViewManager = aViewManager;
7155
7156           // to make the list sorted by plane id
7157           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7158           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7159             const TPlaneInfo& aPlaneInfoRef = *anIter4;
7160             if( aPlaneInfoRef.PlaneId > aPlaneId )
7161               break;
7162           }
7163           aPlaneInfoList.insert( anIter4, aPlaneInfo );
7164         }
7165       }
7166     }
7167   }
7168
7169   // add clipping planes to actors according to the restored parameters
7170   // and update the clipping plane map
7171   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7172   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7173     int aViewId = anIter1->first;
7174     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7175
7176     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7177     if( anIter2 == aPlaneDataMap.end() )
7178       continue;
7179     const TPlaneDataList& aPlaneDataList = anIter2->second;
7180
7181     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7182     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7183       const TPlaneInfo& aPlaneInfo = *anIter3;
7184       int aPlaneId = aPlaneInfo.PlaneId;
7185       const TActorList& anActorList = aPlaneInfo.ActorList;
7186       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7187       if( !aViewManager )
7188         continue;
7189
7190       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7191       if( !aViewWindow )
7192         continue;
7193
7194       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7195
7196       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7197       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7198         const TPlaneData& aPlaneData = *anIter4;
7199         if( aPlaneData.Id == aPlaneId ) {
7200           SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7201           aPlane->myViewWindow = aViewWindow;
7202           aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7203           aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7204           if ( aPlane->PlaneMode == SMESH::Absolute ) {
7205             aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7206             aPlane->X = aPlaneData.X;
7207             aPlane->Y = aPlaneData.Y;
7208             aPlane->Z = aPlaneData.Z;
7209             aPlane->Dx = aPlaneData.Dx;
7210             aPlane->Dy = aPlaneData.Dy;
7211             aPlane->Dz = aPlaneData.Dz;
7212           }
7213           else if ( aPlane->PlaneMode == SMESH::Relative ) {
7214             aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7215             aPlane->myDistance = aPlaneData.Distance;
7216             aPlane->myAngle[0] = aPlaneData.Angle[0];
7217             aPlane->myAngle[1] = aPlaneData.Angle[1];
7218           }
7219           if( aPlane ) {
7220             if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7221               SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7222               aClippingPlaneInfo.Plane = aPlane;
7223               aClippingPlaneInfo.ActorList = anActorList;
7224               aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7225             }
7226           }
7227           break;
7228         }
7229       }
7230
7231     }
7232   }
7233
7234
7235   // update all VTK views
7236   QList<SUIT_ViewManager*> lst;
7237   getApp()->viewManagers(lst);
7238   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7239     SUIT_ViewModel* vmodel = (*it)->getViewModel();
7240     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7241       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7242       // set OpenGL clipping planes
7243       VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7244       vtkActorCollection* anAllActors = aCopy.GetActors();
7245       anAllActors->InitTraversal();
7246       while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7247         if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7248           anActor->SetOpenGLClippingPlane();
7249
7250       vtkView->getRenderer()->ResetCameraClippingRange();
7251       vtkView->Repaint();
7252     }
7253   }
7254 }
7255
7256 /*!
7257   \brief Adds preferences for dfont of VTK viewer
7258   \param label label
7259   \param pIf group identifier
7260   \param param parameter
7261   \return identifier of preferences
7262 */
7263 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7264 {
7265   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7266
7267   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7268
7269   QStringList fam;
7270   fam.append( tr( "SMESH_FONT_ARIAL" ) );
7271   fam.append( tr( "SMESH_FONT_COURIER" ) );
7272   fam.append( tr( "SMESH_FONT_TIMES" ) );
7273
7274   setPreferenceProperty( tfont, "fonts", fam );
7275
7276   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7277   if ( needSize ) f = f | QtxFontEdit::Size;
7278   setPreferenceProperty( tfont, "features", f );
7279
7280   return tfont;
7281 }
7282
7283 /*!
7284   \brief Actions after hypothesis edition
7285   Updates object browser after hypothesis edition
7286 */
7287 void SMESHGUI::onHypothesisEdit( int result )
7288 {
7289   if( result == 1 )
7290     SMESHGUI::Modified();
7291   updateObjBrowser( true );
7292 }
7293
7294 /*!
7295   \brief Actions after choosing menu of control modes
7296   Updates control mode actions according to current selection
7297 */
7298 void SMESHGUI::onUpdateControlActions()
7299 {
7300   SALOME_ListIO selected;
7301   if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7302     aSel->selectedObjects( selected );
7303
7304   SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7305   if ( selected.Extent() ) {
7306     if ( selected.First()->hasEntry() ) {
7307       if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7308         aControl = anActor->GetControlMode();
7309         SALOME_ListIteratorOfListIO it(selected);
7310         for ( it.Next(); it.More(); it.Next() ) {
7311           Handle(SALOME_InteractiveObject) anIO = it.Value();
7312           if ( anIO->hasEntry() ) {
7313             if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7314               if ( aControl != anActor->GetControlMode() ) {
7315                 aControl = SMESH_Actor::eNone;
7316                 break;
7317               }
7318             }
7319           }
7320         }
7321       }
7322     }
7323   }
7324
7325   int anAction = ActionToControl( aControl, true );
7326   if ( anAction)
7327     action( anAction )->setChecked( true );
7328   else {
7329     QMenu* send = (QMenu*)sender();
7330     QList<QAction*> actions = send->actions();
7331     for ( int i = 0; i < actions.size(); i++ )
7332       actions[i]->setChecked( false );
7333   }
7334 }
7335
7336
7337 /*!
7338   \brief Signal handler closing(SUIT_ViewWindow*) of a view
7339   \param pview view being closed
7340 */
7341 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7342 #ifndef DISABLE_PLOT2DVIEWER
7343   //Crear all Plot2d Viewers if need.
7344   SMESH::ClearPlot2Viewers(pview);
7345 #endif
7346   EmitSignalCloseView();
7347 }
7348
7349 void SMESHGUI::message( const QString& msg )
7350 {
7351   // dispatch message
7352   QStringList data = msg.split("/");
7353   if ( data.count() > 0 ) {
7354     if ( data.first() == "mesh_loading" ) {
7355       // get mesh entry
7356       QString entry = data.count() > 1 ? data[1] : QString();
7357       if ( entry.isEmpty() )
7358         return;
7359       // get study
7360       _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7361       // get mesh name
7362       _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7363       QString name;
7364       if ( obj )
7365         name = SMESH::fromUtf8(obj->GetName());
7366       if ( name.isEmpty() )
7367         return;
7368
7369       if ( data.last() == "stop" )
7370         application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7371       else
7372         application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7373       QApplication::processEvents();
7374     }
7375   }
7376 }
7377
7378 /*!
7379   \brief Connects or disconnects signals about activating and cloning view on the module slots
7380   \param pview view which is connected/disconnected
7381 */
7382 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7383   if(!pview)
7384     return;
7385
7386   SUIT_ViewManager* viewMgr = pview->getViewManager();
7387   if ( viewMgr ) {
7388     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7389                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7390
7391     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7392              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7393   }
7394 }
7395
7396 /*!
7397   \brief Return \c true if object can be renamed
7398 */
7399 bool SMESHGUI::renameAllowed( const QString& entry) const {
7400   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7401   if( !anApp )
7402     return false;
7403
7404   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7405   if( !appStudy )
7406     return false;
7407
7408   SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7409
7410   if(!obj)
7411     return false;
7412
7413   if(appStudy->isComponent(entry) || obj->isReference())
7414     return false;
7415
7416   // check type to prevent renaming of inappropriate objects
7417   int aType = SMESHGUI_Selection::type(qPrintable(entry));
7418   if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7419       aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7420       aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7421       aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7422       aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7423     return true;
7424
7425   return false;
7426 }
7427
7428 /*!
7429   Rename object by entry.
7430   \param entry entry of the object
7431   \param name new name of the object
7432   \brief Return \c true if rename operation finished successfully, \c false otherwise.
7433 */
7434 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7435
7436   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7437   if( !anApp )
7438     return false;
7439
7440   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7441
7442   if(!appStudy)
7443     return false;
7444
7445   _PTR(Study) aStudy = appStudy->studyDS();
7446
7447   if(!aStudy)
7448     return false;
7449
7450   bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7451   if ( aLocked ) {
7452     SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7453     return false;
7454   }
7455
7456
7457   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7458   _PTR(GenericAttribute) anAttr;
7459   _PTR(AttributeName) aName;
7460   if ( obj ) {
7461     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7462       aName = anAttr;
7463       // check type to prevent renaming of inappropriate objects
7464       int aType = SMESHGUI_Selection::type( qPrintable(entry));
7465       if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7466           aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7467           aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7468           aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7469           aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7470         if ( !name.isEmpty() ) {
7471           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7472
7473           // update name of group object and its actor
7474           Handle(SALOME_InteractiveObject) IObject =
7475             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7476
7477           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7478           if( !aGroupObject->_is_nil() ) {
7479             aGroupObject->SetName( qUtf8Printable(name) );
7480             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7481               anActor->setName( qUtf8Printable(name) );
7482           }
7483           return true;
7484         }
7485       }
7486     }
7487   }
7488   return false;
7489 }
7490
7491 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7492 {
7493   static QList<QColor> colors;
7494
7495   if ( colors.isEmpty() ) {
7496
7497     for (int s = 0; s < 2 ; s++)
7498     {
7499       for (int v = 100; v >= 40; v = v - 20)
7500       {
7501         for (int h = 0; h < 359 ; h = h + 60)
7502         {
7503           colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7504         }
7505       }
7506     }
7507   }
7508   static int currentColor = randomize( colors.size() );
7509
7510   SALOMEDS::Color color;
7511   color.R = (double)colors[currentColor].red()   / 255.0;
7512   color.G = (double)colors[currentColor].green() / 255.0;
7513   color.B = (double)colors[currentColor].blue()  / 255.0;
7514
7515   currentColor = (currentColor+1) % colors.count();
7516
7517   return color;
7518 }