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