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