src/SMESHGUI/SMESHGUI.cxx

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