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   const int objectCountLimit = 30; // PAL23599
1859   int objectCount = 0;
1860   QString aNameList;
1861   QString aParentComponent = QString::null;
1862
1863   for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1864   {
1865     Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1866     if ( anIO.IsNull() ) continue;
1867
1868     QString father = "unknown", name;
1869
1870     _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1871     if (aSO) {
1872       father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1873       // check if object is reference
1874       _PTR(SObject) aRefSObj;
1875       if ( aSO->ReferencedObject( aRefSObj ) ) {
1876         name = QString::fromStdString ( aRefSObj->GetName() );
1877         father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1878       }
1879       else
1880         name = anIO->getName();
1881       objectCount++;
1882     }
1883     if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
1884       aNameList.append("\n    - ");
1885       aNameList.append( name );
1886     }
1887
1888     if( aParentComponent.isNull() )
1889       aParentComponent = father;
1890     else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1891       aParentComponent = "";
1892   }
1893   if ( objectCount >= objectCountLimit )
1894     aNameList.append("\n    - ...");
1895
1896   if ( objectCount == 0 )
1897     return; // No Valid Objects Selected
1898
1899   if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() )  {
1900     SUIT_MessageBox::warning( SMESHGUI::desktop(),
1901                               QObject::tr("ERR_ERROR"),
1902                               QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1903     return;
1904   }
1905   // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1906   if (SUIT_MessageBox::warning
1907       (SMESHGUI::desktop(),
1908        QObject::tr("SMESH_WRN_WARNING"),
1909        QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1910        SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1911        SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1912     return;
1913
1914   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1915
1916   // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1917   // then treat them all starting from the deepest objects (at list back)
1918   std::list< _PTR(SObject) > listSO;
1919   SALOME_ListIteratorOfListIO It(selected);
1920   for( ; It.More(); It.Next()) // loop on selected IO's
1921   {
1922     Handle(SALOME_InteractiveObject) IObject = It.Value();
1923     if(IObject->hasEntry()) {
1924       _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1925
1926       // disable removal of "SMESH" component object
1927       if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1928         anIOR = anAttr;
1929         if ( engineIOR() == anIOR->Value().c_str() )
1930           continue;
1931       }
1932       //Check the referenced object
1933       _PTR(SObject) aRefSObject;
1934       if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1935         aSO = aRefSObject; // Delete main Object instead of reference
1936
1937       listSO.push_back( aSO );
1938       std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1939       for ( ; itSO != listSO.end(); ++itSO ) {
1940         _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1941         for (it->InitEx(false); it->More(); it->Next())
1942           listSO.push_back( it->Value() );
1943       }
1944     }
1945   }
1946   // Check if none of objects to delete is referred from outside
1947   std::list< _PTR(SObject) >::reverse_iterator ritSO;
1948   for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1949   {
1950     _PTR(SObject) SO = *ritSO;
1951     if ( !SO ) continue;
1952     std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO  );
1953     for (size_t i = 0; i < aReferences.size(); i++) {
1954       _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1955       std::string type = aComponent->ComponentDataType();
1956       if ( type != "SMESH" )
1957       {
1958         SUIT_MessageBox::warning( anApp->desktop(),
1959                                   QObject::tr("WRN_WARNING"),
1960                                   QObject::tr("DEP_OBJECT") );
1961         return; // outside SMESH, there is an object depending on a SMESH object
1962       }
1963     }
1964   }
1965
1966   // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1967   for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1968   {
1969     Handle(SALOME_InteractiveObject) IObject = It.Value();
1970     SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1971     if ( !mesh->_is_nil() )
1972       mesh->Clear();
1973   }
1974
1975   // Treat SO's in the list starting from the back
1976   aStudyBuilder->NewCommand();  // There is a transaction
1977   for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1978   {
1979     _PTR(SObject) SO = *ritSO;
1980     if ( !SO ) continue;
1981     std::string anEntry = SO->GetID();
1982
1983     /** Erase graphical object and remove all its data **/
1984     if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1985       SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1986     }
1987     /** Remove an object from data structures **/
1988     SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1989     SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1990     if ( !aGroup->_is_nil() ) {                          // DELETE GROUP
1991       SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1992       aMesh->RemoveGroup( aGroup );
1993     }
1994     else if ( !aSubMesh->_is_nil() ) {                   // DELETE SUBMESH
1995       SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1996       aMesh->RemoveSubMesh( aSubMesh );
1997     }
1998     else {
1999       Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2000         ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2001       QString objType = CheckTypeObject(IObject);
2002       if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2003         SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2004         aStudyBuilder->RemoveObjectWithChildren( SO );
2005       }
2006       else {// default action: remove SObject from the study
2007         // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2008         //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2009         //op->start();
2010         aStudyBuilder->RemoveObjectWithChildren( SO );
2011         //op->finish();
2012       }
2013     }
2014   } /* listSO back loop */
2015
2016   aStudyBuilder->CommitCommand();
2017
2018   /* Clear any previous selection */
2019   SALOME_ListIO l1;
2020   aSel->setSelectedObjects( l1 );
2021
2022   SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2023 }
2024
2025 extern "C" {
2026   SMESHGUI_EXPORT CAM_Module* createModule()
2027   {
2028     return new SMESHGUI();
2029   }
2030
2031   SMESHGUI_EXPORT  char* getModuleVersion() {
2032     return (char*)SMESH_VERSION_STR;
2033   }
2034 }
2035
2036 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2037
2038 //=============================================================================
2039 /*!
2040  *
2041  */
2042 //=============================================================================
2043 SMESHGUI::SMESHGUI() :
2044 SalomeApp_Module( "SMESH" )
2045 {
2046   if ( CORBA::is_nil( myComponentSMESH ) )
2047   {
2048     CORBA::Boolean anIsEmbeddedMode;
2049     myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2050     //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2051
2052     //  0019923: EDF 765 SMESH : default values of hypothesis
2053     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2054     int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2055     myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2056     nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2057     myComponentSMESH->SetDefaultNbSegments( nbSeg );
2058
2059     const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2060     for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2061       if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2062       {
2063         QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2064         myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2065       }
2066   }
2067
2068   myActiveDialogBox = 0;
2069   myFilterLibraryDlg = 0;
2070   myState = -1;
2071   myDisplayer = 0;
2072
2073   myEventCallbackCommand = vtkCallbackCommand::New();
2074   myEventCallbackCommand->Delete();
2075   myEventCallbackCommand->SetClientData( this );
2076   myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2077   myPriority = 0.0;
2078
2079   /* load resources for all available meshers */
2080   SMESH::InitAvailableHypotheses();
2081 }
2082
2083 //=============================================================================
2084 /*!
2085  *
2086  */
2087 //=============================================================================
2088 SMESHGUI::~SMESHGUI()
2089 {
2090 }
2091
2092 //=============================================================================
2093 /*!
2094  *
2095  */
2096 //=============================================================================
2097 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2098 {
2099   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2100   if( anApp )
2101     return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2102   else
2103     return 0;
2104 }
2105
2106 //=============================================================================
2107 /*!
2108  *
2109  */
2110 //=============================================================================
2111 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2112 {
2113   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2114   if ( !resMgr )
2115     return false;
2116
2117   bool autoUpdate  = resMgr->booleanValue( "SMESH", "auto_update",  false );
2118   long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2119   bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2120   if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2121   return autoUpdate && !exceeded;
2122 }
2123
2124 //=============================================================================
2125 /*!
2126  *
2127  */
2128 //=============================================================================
2129 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2130                                 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2131 {
2132   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2133   if ( !resMgr )
2134     return false;
2135
2136   bool autoUpdate  = resMgr->booleanValue( "SMESH", "auto_update", false );
2137   long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2138   bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2139
2140   SMESH::long_array_var info = theMesh->GetMeshInfo();
2141   long nbOdElems = info[SMDSEntity_0D];
2142   long nbEdges   = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2143   long nbFaces   = info[SMDSEntity_Triangle]   + info[SMDSEntity_Quad_Triangle]   + info[SMDSEntity_BiQuad_Triangle] +
2144                    info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2145                    info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2146   long nbVolumes = info[SMDSEntity_Tetra]   + info[SMDSEntity_Quad_Tetra] +
2147                    info[SMDSEntity_Hexa]    + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2148                    info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2149                    info[SMDSEntity_Penta]   + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2150                    info[SMDSEntity_Polyhedra] +
2151                    info[SMDSEntity_Hexagonal_Prism];
2152   long nbBalls   = info[SMDSEntity_Ball];
2153
2154   long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2155   *nbElements = requestedSize;
2156
2157   *entities = SMESH_Actor::eAllEntity;
2158   *hidden   = 0;
2159
2160   bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2161
2162   if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2163
2164   if ( incrementalLimit ) {
2165     long total     = 0;
2166
2167     if ( nbOdElems > 0 ) {
2168       if ( total + nbOdElems > updateLimit ) {
2169         *entities = *entities & ~SMESH_Actor::e0DElements;
2170         *hidden = *hidden | SMESH_Actor::e0DElements;
2171       }
2172       else
2173         exceeded = false;
2174     }
2175     total += nbOdElems;
2176
2177     if ( nbEdges > 0 ) {
2178       if ( total + nbEdges > updateLimit ) {
2179         *entities = *entities & ~SMESH_Actor::eEdges;
2180         *hidden = *hidden | SMESH_Actor::eEdges;
2181       }
2182       else
2183         exceeded = false;
2184     }
2185     total += nbEdges;
2186
2187     if ( nbFaces > 0 ) {
2188       if ( total + nbFaces > updateLimit ) {
2189         *entities = *entities & ~SMESH_Actor::eFaces;
2190         *hidden = *hidden | SMESH_Actor::eFaces;
2191       }
2192       else
2193         exceeded = false;
2194     }
2195     total += nbFaces;
2196
2197     if ( nbVolumes > 0 ) {
2198       if ( total + nbVolumes > updateLimit ) {
2199         *entities = *entities & ~SMESH_Actor::eVolumes;
2200         *hidden = *hidden | SMESH_Actor::eVolumes;
2201       }
2202       else
2203         exceeded = false;
2204     }
2205     total += nbVolumes;
2206
2207     if ( nbBalls > 0 ) {
2208       if ( total + nbBalls > updateLimit ) {
2209         *entities = *entities & ~SMESH_Actor::eBallElem;
2210         *hidden = *hidden | SMESH_Actor::eBallElem;
2211       }
2212       else
2213         exceeded = false;
2214     }
2215     total += nbBalls;
2216   }
2217
2218   return autoUpdate && !exceeded;
2219 }
2220
2221 //=============================================================================
2222 /*!
2223  *
2224  */
2225 //=============================================================================
2226 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2227 {
2228   return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2229 }
2230
2231 //=============================================================================
2232 /*!
2233  *
2234  */
2235 //=============================================================================
2236 SMESHGUI* SMESHGUI::GetSMESHGUI()
2237 {
2238   SMESHGUI* smeshMod = 0;
2239   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2240   if ( app )
2241   {
2242     CAM_Module* module = app->module( "Mesh" );
2243     smeshMod = dynamic_cast<SMESHGUI*>( module );
2244   }
2245
2246   return smeshMod;
2247 }
2248
2249 extern "C"
2250 {
2251   Standard_EXPORT SMESHGUI* GetComponentGUI()
2252   {
2253     return SMESHGUI::GetSMESHGUI();
2254   }
2255 }
2256
2257 //=============================================================================
2258 /*!
2259  *
2260  */
2261 //=============================================================================
2262 void SMESHGUI::SetState(int aState)
2263 {
2264   myState = aState;
2265 }
2266
2267 //=============================================================================
2268 /*!
2269  *
2270  */
2271 //=============================================================================
2272 void SMESHGUI::ResetState()
2273 {
2274   myState = -1;
2275 }
2276
2277 //=============================================================================
2278 /*!
2279  *
2280  */
2281 //=============================================================================
2282 void SMESHGUI::EmitSignalDeactivateDialog()
2283 {
2284   emit SignalDeactivateActiveDialog();
2285 }
2286
2287 //=============================================================================
2288 /*!
2289  *
2290  */
2291 //=============================================================================
2292 void SMESHGUI::EmitSignalStudyFrameChanged()
2293 {
2294   emit SignalStudyFrameChanged();
2295 }
2296
2297 //=============================================================================
2298 /*!
2299  *
2300  */
2301 //=============================================================================
2302 void SMESHGUI::EmitSignalCloseAllDialogs()
2303 {
2304   emit SignalCloseAllDialogs();
2305 }
2306
2307 //=============================================================================
2308 /*!
2309  *
2310  */
2311 //=============================================================================
2312 void SMESHGUI::EmitSignalVisibilityChanged()
2313 {
2314   emit SignalVisibilityChanged();
2315 }
2316
2317 //=============================================================================
2318 /*!
2319  *
2320  */
2321 //=============================================================================
2322 void SMESHGUI::EmitSignalCloseView()
2323 {
2324   emit SignalCloseView();
2325 }
2326
2327 //=============================================================================
2328 /*!
2329  *
2330  */
2331 //=============================================================================
2332 void SMESHGUI::EmitSignalActivatedViewManager()
2333 {
2334   emit SignalActivatedViewManager();
2335 }
2336
2337 //=============================================================================
2338 /*!
2339  *
2340  */
2341 //=============================================================================
2342 QDialog *SMESHGUI::GetActiveDialogBox()
2343 {
2344   return myActiveDialogBox;
2345 }
2346
2347 //=============================================================================
2348 /*!
2349  *
2350  */
2351 //=============================================================================
2352 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2353 {
2354   myActiveDialogBox = (QDialog *) aDlg;
2355   return;
2356 }
2357
2358 //=============================================================================
2359 /*!
2360  *
2361  */
2362 //=============================================================================
2363 SUIT_Desktop* SMESHGUI::desktop()
2364 {
2365   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2366   if( app )
2367     return app->desktop();
2368   else
2369     return 0;
2370 }
2371
2372 //=============================================================================
2373 /*!
2374  *
2375  */
2376 //=============================================================================
2377 SalomeApp_Study* SMESHGUI::activeStudy()
2378 {
2379   SUIT_Application* app = SUIT_Session::session()->activeApplication();
2380   if( app )
2381     return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2382   else
2383     return NULL;
2384 }
2385
2386 //=============================================================================
2387 /*!
2388  *
2389  */
2390 //=============================================================================
2391 void SMESHGUI::Modified( bool theIsUpdateActions )
2392 {
2393   if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2394     if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2395       appStudy->Modified();
2396       if( theIsUpdateActions )
2397         app->updateActions();
2398     }
2399   }
2400 }
2401
2402 //=============================================================================
2403 /*!
2404  *
2405  */
2406 //=============================================================================
2407 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2408 {
2409   /* Here the position is on the bottom right corner - 10 */
2410   // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2411   aDlg->adjustSize();
2412   SUIT_Desktop *PP = desktop();
2413   x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2414   y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2415   return true;
2416 }
2417
2418 /*!
2419  * \brief Verifies whether study of operation is locked
2420   * \param theMess - specifies whether message box must be shown if study is locked
2421   * \return State of study.
2422 *
2423 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2424 * is locked when corresponding message box appears
2425 */
2426 bool SMESHGUI::isStudyLocked( bool theMessage )
2427 {
2428   if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2429   {
2430     if ( theMessage )
2431       SUIT_MessageBox::warning( SMESHGUI::desktop(),
2432                                 QObject::tr( "WRN_WARNING" ),
2433                                 QObject::tr( "WRN_STUDY_LOCKED" ) );
2434     return true;
2435   }
2436   return false;
2437 }
2438
2439 //=============================================================================
2440 /*!
2441  *
2442  */
2443 //=============================================================================
2444 bool SMESHGUI::OnGUIEvent( int theCommandID )
2445 {
2446   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2447   if( !anApp )
2448     return false;
2449
2450   SUIT_ResourceMgr* mgr = resourceMgr();
2451   if( !mgr )
2452     return false;
2453
2454   SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2455   SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2456
2457   //QAction* act = action( theCommandID );
2458
2459   switch (theCommandID) {
2460   case SMESHOp::OpDelete:
2461     if(isStudyLocked()) break;
2462     OnEditDelete();
2463     break;
2464   case SMESHOp::OpImportDAT:
2465   case SMESHOp::OpImportUNV:
2466   case SMESHOp::OpImportMED:
2467   case SMESHOp::OpImportSTL:
2468   case SMESHOp::OpImportCGNS:
2469   case SMESHOp::OpImportSAUV:
2470   case SMESHOp::OpImportGMF:
2471   case SMESHOp::OpPopupImportDAT:
2472   case SMESHOp::OpPopupImportUNV:
2473   case SMESHOp::OpPopupImportMED:
2474   case SMESHOp::OpPopupImportSTL:
2475   case SMESHOp::OpPopupImportCGNS:
2476   case SMESHOp::OpPopupImportSAUV:
2477   case SMESHOp::OpPopupImportGMF:
2478     {
2479       if(isStudyLocked()) break;
2480       ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2481       break;
2482     }
2483
2484   case SMESHOp::OpFileInformation:
2485     {
2486       SALOME_ListIO selected;
2487       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2488       if( aSel )
2489         aSel->selectedObjects( selected );
2490       if( selected.Extent() )
2491       {
2492         Handle(SALOME_InteractiveObject) anIObject = selected.First();
2493         SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2494         if ( !aMesh->_is_nil() )
2495         {
2496           SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2497           dlg.exec();
2498         }
2499       }
2500       break;
2501     }
2502   case SMESHOp::OpExportDAT:
2503   case SMESHOp::OpExportMED:
2504   case SMESHOp::OpExportUNV:
2505   case SMESHOp::OpExportSTL:
2506   case SMESHOp::OpExportCGNS:
2507   case SMESHOp::OpExportSAUV:
2508   case SMESHOp::OpExportGMF:
2509   case SMESHOp::OpPopupExportDAT:
2510   case SMESHOp::OpPopupExportMED:
2511   case SMESHOp::OpPopupExportUNV:
2512   case SMESHOp::OpPopupExportSTL:
2513   case SMESHOp::OpPopupExportCGNS:
2514   case SMESHOp::OpPopupExportSAUV:
2515   case SMESHOp::OpPopupExportGMF:
2516     {
2517       ::ExportMeshToFile(theCommandID);
2518       break;
2519     }
2520
2521   case SMESHOp::OpReset:                      // SCALAR BAR
2522     {
2523       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2524       SALOME_ListIO selected;
2525       if( aSel )
2526         aSel->selectedObjects( selected );
2527
2528       SALOME_ListIteratorOfListIO it(selected);
2529       for( ; it.More(); it.Next()) {
2530         Handle(SALOME_InteractiveObject) anIO = it.Value();
2531         if( anIO->hasEntry() ) {
2532           if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2533             anActor->SetControlMode( SMESH_Actor::eNone );
2534 #ifndef DISABLE_PLOT2DVIEWER
2535             SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2536 #endif
2537           }
2538         }
2539       }
2540       SMESH::UpdateView();
2541       break;
2542     }
2543   case SMESHOp::OpScalarBarProperties:
2544     {
2545       SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2546       break;
2547     }
2548   case SMESHOp::OpShowScalarBar:
2549     {
2550       // show/hide scalar bar
2551       ::ShowElement(theCommandID);
2552       break;
2553     }
2554   case SMESHOp::OpSaveDistribution:
2555     {
2556       // dump control distribution data to the text file
2557       ::SaveDistribution();
2558       break;
2559     }
2560
2561   case SMESHOp::OpShowDistribution:
2562     {
2563       // show/hide distribution
2564       ::ShowElement(theCommandID);
2565       break;
2566     }
2567
2568 #ifndef DISABLE_PLOT2DVIEWER
2569   case SMESHOp::OpPlotDistribution:
2570     {
2571       // plot distribution
2572       ::PlotDistribution();
2573       break;
2574     }
2575 #endif
2576
2577     // Auto-color
2578   case SMESHOp::OpAutoColor:
2579     ::AutoColor();
2580   break;
2581
2582   case SMESHOp::OpDisableAutoColor:
2583     ::DisableAutoColor();
2584   break;
2585
2586   case SMESHOp::OpClipping:
2587   case SMESHOp::OpTransparency:
2588   case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2589
2590     // Display Mode
2591   case SMESHOp::OpDMWireframe:
2592   case SMESHOp::OpDMShading:
2593   case SMESHOp::OpDMNodes:
2594   case SMESHOp::OpDMShrink:
2595     ::SetDisplayMode(theCommandID, myMarkerMap);
2596   break;
2597
2598   //2D quadratic representation
2599   case SMESHOp::OpRepresentationLines:
2600   case SMESHOp::OpRepresentationArcs:
2601     ::SetDisplayMode(theCommandID, myMarkerMap);
2602   break;
2603
2604   // Display Entity
2605   case SMESHOp::OpDE0DElements:
2606   case SMESHOp::OpDEEdges:
2607   case SMESHOp::OpDEFaces:
2608   case SMESHOp::OpDEVolumes:
2609   case SMESHOp::OpDEBalls:
2610   case SMESHOp::OpDEAllEntity:
2611     ::SetDisplayEntity(theCommandID);
2612   break;
2613
2614   // Choose entities to be displayed
2615   case SMESHOp::OpDEChoose:
2616     {
2617       ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2618       break;
2619     }
2620
2621   case SMESHOp::OpOrientationOnFaces:
2622     {
2623       SUIT_OverrideCursor wc;
2624       LightApp_SelectionMgr* mgr = selectionMgr();
2625       SALOME_ListIO selected; mgr->selectedObjects( selected );
2626
2627       SALOME_ListIteratorOfListIO it(selected);
2628       for( ; it.More(); it.Next()) {
2629         Handle(SALOME_InteractiveObject) anIObject = it.Value();
2630         if(anIObject->hasEntry()) {
2631           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2632             anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2633           }
2634         }
2635       }
2636       break;
2637     }
2638
2639   case SMESHOp::OpUpdate:
2640     {
2641       if(isStudyLocked()) break;
2642       SUIT_OverrideCursor wc;
2643       try {
2644         OCC_CATCH_SIGNALS;
2645         SMESH::UpdateView();
2646       }
2647       catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2648         SMESH::OnVisuException();
2649       }
2650       catch (...) { // PAL16774 (Crash after display of many groups)
2651         SMESH::OnVisuException();
2652       }
2653
2654       SALOME_ListIO l;
2655       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2656       aSel->selectedObjects( l );
2657       aSel->setSelectedObjects( l );
2658       break;
2659     }
2660
2661   case SMESHOp::OpHide:
2662   case SMESHOp::OpShow:
2663   case SMESHOp::OpShowOnly:
2664     {
2665       SUIT_OverrideCursor wc;
2666       SMESH::EDisplaing anAction;
2667       switch (theCommandID) {
2668       case SMESHOp::OpHide:     anAction = SMESH::eErase; break;
2669       case SMESHOp::OpShow:     anAction = SMESH::eDisplay; break;
2670       case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2671       }
2672
2673       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2674       SALOME_ListIO sel_objects, to_process;
2675       if (aSel)
2676         aSel->selectedObjects( sel_objects );
2677
2678       if ( theCommandID==SMESHOp::OpShowOnly )
2679       {
2680         //MESSAGE("anAction = SMESH::eDisplayOnly");
2681         startOperation( myEraseAll );
2682       }
2683
2684       extractContainers( sel_objects, to_process );
2685
2686       try {
2687         OCC_CATCH_SIGNALS;
2688         if (vtkwnd) {
2689           SALOME_ListIteratorOfListIO It( to_process );
2690           for ( ; It.More(); It.Next())
2691           {
2692             Handle(SALOME_InteractiveObject) IOS = It.Value();
2693             if ( IOS->hasEntry() )
2694             {
2695               if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2696                 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2697                 break; // PAL16774 (Crash after display of many groups)
2698               }
2699               if (anAction == SMESH::eDisplayOnly)
2700                 anAction = SMESH::eDisplay;
2701             }
2702           }
2703         }
2704
2705         // PAL13338 + PAL15161 -->
2706         if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2707           SMESH::UpdateView();
2708           SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2709         }
2710         // PAL13338 + PAL15161 <--
2711       }
2712       catch (...) { // PAL16774 (Crash after display of many groups)
2713         SMESH::OnVisuException();
2714       }
2715
2716       if (anAction == SMESH::eErase) {
2717         SALOME_ListIO l1;
2718         aSel->setSelectedObjects( l1 );
2719       }
2720       else
2721         aSel->setSelectedObjects( to_process );
2722
2723       break;
2724     }
2725
2726   case SMESHOp::OpNode:
2727     {
2728       if(isStudyLocked()) break;
2729
2730       if ( vtkwnd ) {
2731         EmitSignalDeactivateDialog();
2732
2733         ( new SMESHGUI_NodesDlg( this ) )->show();
2734       }
2735       else {
2736         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2737       }
2738       break;
2739     }
2740
2741   case SMESHOp::OpCreateMesh:
2742   case SMESHOp::OpCreateSubMesh:
2743   case SMESHOp::OpEditMeshOrSubMesh:
2744   case SMESHOp::OpEditMesh:
2745   case SMESHOp::OpEditSubMesh:
2746   case SMESHOp::OpCompute:
2747   case SMESHOp::OpComputeSubMesh:
2748   case SMESHOp::OpPreCompute:
2749   case SMESHOp::OpEvaluate:
2750   case SMESHOp::OpMeshOrder:
2751     startOperation( theCommandID );
2752     break;
2753   case SMESHOp::OpCopyMesh:
2754     {
2755       if (isStudyLocked()) break;
2756       EmitSignalDeactivateDialog();
2757       ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2758     }
2759     break;
2760   case SMESHOp::OpBuildCompoundMesh:
2761     {
2762       if (isStudyLocked()) break;
2763       EmitSignalDeactivateDialog();
2764       ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2765     }
2766     break;
2767
2768   case SMESHOp::OpDiagonalInversion:
2769   case SMESHOp::OpUnionOfTwoTriangle:
2770     {
2771       if ( !vtkwnd )
2772       {
2773         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2774         break;
2775       }
2776
2777       if ( isStudyLocked() )
2778         break;
2779
2780       /*Standard_Boolean aRes;
2781       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2782       if ( aMesh->_is_nil() )
2783       {
2784         SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2785           tr( "SMESH_BAD_SELECTION" ) );
2786         break;
2787       }
2788       */
2789       EmitSignalDeactivateDialog();
2790       if ( theCommandID == SMESHOp::OpDiagonalInversion )
2791         ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2792       else
2793         ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2794       break;
2795     }
2796   case SMESHOp::OpOrientation:
2797   case SMESHOp::OpUnionOfTriangles:
2798   case SMESHOp::OpCuttingOfQuadrangles:
2799   case SMESHOp::OpSplitVolumes:
2800     {
2801       if ( !vtkwnd )
2802       {
2803         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2804         break;
2805       }
2806
2807       if ( isStudyLocked() )
2808         break;
2809
2810       EmitSignalDeactivateDialog();
2811       SMESHGUI_MultiEditDlg* aDlg = NULL;
2812       if ( theCommandID == SMESHOp::OpOrientation )
2813         aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2814       else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2815         aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2816       else if ( theCommandID == SMESHOp::OpSplitVolumes )
2817         aDlg = new SMESHGUI_SplitVolumesDlg(this);
2818       else
2819         aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2820
2821       aDlg->show();
2822       break;
2823     }
2824   case SMESHOp::OpSmoothing:
2825     {
2826       if(isStudyLocked()) break;
2827       if( vtkwnd ) {
2828         EmitSignalDeactivateDialog();
2829         ( new SMESHGUI_SmoothingDlg( this ) )->show();
2830       }
2831       else {
2832         SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2833       }
2834       break;
2835     }
2836   case SMESHOp::OpExtrusion:
2837     {
2838       if (isStudyLocked()) break;
2839       if (vtkwnd) {
2840         EmitSignalDeactivateDialog();
2841         ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2842       } else {
2843         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2844       }
2845       break;
2846     }
2847   case SMESHOp::OpExtrusionAlongAPath:
2848     {
2849       if (isStudyLocked()) break;
2850       if (vtkwnd) {
2851         EmitSignalDeactivateDialog();
2852         ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2853       } else {
2854         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2855       }
2856       break;
2857     }
2858   case SMESHOp::OpRevolution:
2859     {
2860       if(isStudyLocked()) break;
2861       if( vtkwnd ) {
2862         EmitSignalDeactivateDialog();
2863         ( new SMESHGUI_RevolutionDlg( this ) )->show();
2864       }
2865       else {
2866         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2867       }
2868       break;
2869     }
2870   case SMESHOp::OpPatternMapping:
2871     {
2872       if ( isStudyLocked() )
2873         break;
2874       if ( vtkwnd )
2875       {
2876         EmitSignalDeactivateDialog();
2877         ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2878       }
2879       else {
2880         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2881       }
2882       break;
2883     }
2884   case SMESHOp::OpSplitBiQuadratic:
2885   case SMESHOp::OpConvertMeshToQuadratic:
2886   case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2887   case SMESHOp::OpReorientFaces:
2888   case SMESHOp::OpCreateGeometryGroup:
2889     {
2890       startOperation( theCommandID );
2891       break;
2892     }
2893   case SMESHOp::OpCreateGroup:
2894     {
2895       if ( !vtkwnd )
2896       {
2897         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2898         break;
2899       }
2900
2901       if(isStudyLocked()) break;
2902       EmitSignalDeactivateDialog();
2903       SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2904
2905       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2906       SALOME_ListIO selected;
2907       if( aSel )
2908         aSel->selectedObjects( selected );
2909
2910       int nbSel = selected.Extent();
2911       if (nbSel == 1) {
2912         // check if mesh is selected
2913         aMesh = SMESH::GetMeshByIO( selected.First() );
2914       }
2915       SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2916       aDlg->show();
2917       break;
2918     }
2919
2920   case SMESHOp::OpConstructGroup:
2921     {
2922       if ( !vtkwnd )
2923       {
2924         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2925         break;
2926       }
2927
2928       if(isStudyLocked()) break;
2929       EmitSignalDeactivateDialog();
2930
2931       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2932       SALOME_ListIO selected;
2933       if( aSel )
2934         aSel->selectedObjects( selected );
2935
2936       int nbSel = selected.Extent();
2937       if (nbSel == 1) {
2938         // check if submesh is selected
2939         Handle(SALOME_InteractiveObject) IObject = selected.First();
2940         if (IObject->hasEntry()) {
2941           _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
2942           if( aSObj ) {
2943             SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2944             if (!aSubMesh->_is_nil()) {
2945               try {
2946                 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2947                 // get submesh elements list by types
2948                 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2949                 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2950                 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2951                 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2952                 // create group for each type o elements
2953                 QString aName = IObject->getName();
2954                 QStringList anEntryList;
2955                 if (aNodes->length() > 0) {
2956                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2957                   aGroup->Add(aNodes.inout());
2958                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2959                     anEntryList.append( aSObject->GetID().c_str() );
2960                 }
2961                 if (aEdges->length() > 0) {
2962                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2963                   aGroup->Add(aEdges.inout());
2964                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2965                     anEntryList.append( aSObject->GetID().c_str() );
2966                 }
2967                 if (aFaces->length() > 0) {
2968                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2969                   aGroup->Add(aFaces.inout());
2970                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2971                     anEntryList.append( aSObject->GetID().c_str() );
2972                 }
2973                 if (aVolumes->length() > 0) {
2974                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2975                   aGroup->Add(aVolumes.inout());
2976                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2977                     anEntryList.append( aSObject->GetID().c_str() );
2978                 }
2979                 updateObjBrowser();
2980                 anApp->browseObjects( anEntryList );
2981               }
2982               catch(const SALOME::SALOME_Exception & S_ex){
2983                 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2984               }
2985             }
2986           }
2987         }
2988       }
2989       else if(nbSel==0) {
2990         SUIT_MessageBox::warning(desktop(),
2991                                  tr("SMESH_WRN_WARNING"),
2992                                  tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2993       }
2994       break;
2995     }
2996
2997   case SMESHOp::OpEditGroup:
2998     {
2999       if ( !vtkwnd )
3000       {
3001         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3002         break;
3003       }
3004
3005       if(isStudyLocked()) break;
3006       EmitSignalDeactivateDialog();
3007
3008       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3009       SALOME_ListIO selected;
3010       if( aSel )
3011         aSel->selectedObjects( selected );
3012
3013       SALOME_ListIteratorOfListIO It (selected);
3014       int nbSelectedGroups = 0;
3015       for ( ; It.More(); It.Next() )
3016       {
3017         SMESH::SMESH_GroupBase_var aGroup =
3018           SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3019         if (!aGroup->_is_nil()) {
3020           nbSelectedGroups++;
3021           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3022           aDlg->show();
3023         }
3024       }
3025       if (nbSelectedGroups == 0)
3026         {
3027           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3028           aDlg->show();
3029         }
3030       break;
3031     }
3032
3033   case SMESHOp::OpAddElemGroupPopup:     // Add elements to group
3034     {
3035       if(isStudyLocked()) break;
3036       if (myState == 800) {
3037         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3038         if (aDlg) aDlg->onAdd();
3039       }
3040       break;
3041     }
3042
3043   case SMESHOp::OpRemoveElemGroupPopup:  // Remove elements from group
3044     {
3045       if(isStudyLocked()) break;
3046       if (myState == 800) {
3047         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3048         if (aDlg) aDlg->onRemove();
3049       }
3050       break;
3051     }
3052
3053   case SMESHOp::OpEditGeomGroupAsGroup:
3054     {
3055       if ( !vtkwnd )
3056       {
3057         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3058         break;
3059       }
3060
3061       if(isStudyLocked()) break;
3062       EmitSignalDeactivateDialog();
3063
3064       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3065       SALOME_ListIO selected;
3066       if( aSel )
3067         aSel->selectedObjects( selected );
3068
3069       SALOME_ListIteratorOfListIO It (selected);
3070       for ( ; It.More(); It.Next() )
3071       {
3072         SMESH::SMESH_GroupOnGeom_var aGroup =
3073           SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3074         if (!aGroup->_is_nil()) {
3075           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3076           aDlg->show();
3077         }
3078         else
3079         {
3080           SMESH::SMESH_GroupOnFilter_var aGroup =
3081             SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3082           if (!aGroup->_is_nil()) {
3083             SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3084             aDlg->show();
3085           }
3086         }
3087       }
3088       break;
3089     }
3090
3091     case SMESHOp::OpUnionGroups:
3092     case SMESHOp::OpIntersectGroups:
3093     case SMESHOp::OpCutGroups:
3094     {
3095       if ( !vtkwnd )
3096       {
3097         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3098         break;
3099       }
3100
3101       if ( isStudyLocked() )
3102         break;
3103
3104       EmitSignalDeactivateDialog();
3105
3106       SMESHGUI_GroupOpDlg* aDlg = 0;
3107       if ( theCommandID == SMESHOp::OpUnionGroups )
3108         aDlg = new SMESHGUI_UnionGroupsDlg( this );
3109       else if ( theCommandID == SMESHOp::OpIntersectGroups )
3110         aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3111       else
3112         aDlg = new SMESHGUI_CutGroupsDlg( this );
3113
3114       aDlg->show();
3115
3116       break;
3117     }
3118
3119     case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3120     {
3121       if ( isStudyLocked() )
3122         break;
3123
3124       EmitSignalDeactivateDialog();
3125       SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3126       aDlg->show();
3127
3128       break;
3129     }
3130
3131     case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3132     {
3133       if ( !vtkwnd )
3134       {
3135         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3136         break;
3137       }
3138
3139       if ( isStudyLocked() )
3140         break;
3141
3142       EmitSignalDeactivateDialog();
3143
3144       ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3145       break;
3146     }
3147
3148   case SMESHOp::OpMeshInformation:
3149   case SMESHOp::OpWhatIs:
3150     {
3151       int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3152       EmitSignalDeactivateDialog();
3153       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3154       SALOME_ListIO selected;
3155       if( aSel )
3156         aSel->selectedObjects( selected );
3157
3158       if ( selected.Extent() > 1 ) { // a dlg for each IO
3159         SALOME_ListIteratorOfListIO It( selected );
3160         for ( ; It.More(); It.Next() ) {
3161           SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3162           dlg->showInfo( It.Value() );
3163           dlg->show();
3164         }
3165       }
3166       else {
3167         SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3168         dlg->show();
3169       }
3170       break;
3171     }
3172
3173   case SMESHOp::OpFindElementByPoint:
3174     {
3175       startOperation( theCommandID );
3176       break;
3177     }
3178
3179   case SMESHOp::OpEditHypothesis:
3180     {
3181       if(isStudyLocked()) break;
3182
3183       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3184       SALOME_ListIO selected;
3185       if( aSel )
3186         aSel->selectedObjects( selected );
3187
3188       int nbSel = selected.Extent();
3189
3190       if (nbSel == 1) {
3191         Handle(SALOME_InteractiveObject) anIObject = selected.First();
3192         SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3193
3194         if ( !aHypothesis->_is_nil() )
3195         {
3196           SMESHGUI_GenericHypothesisCreator* aCreator =
3197             SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3198           if (aCreator)
3199           {
3200             // set geometry of mesh and sub-mesh to aCreator
3201             aSel->selectedObjects( selected, "",  /*convertReferences=*/false);
3202             if ( selected.Extent() == 1 )
3203             {
3204               QString subGeomID, meshGeomID;
3205               Handle(SALOME_InteractiveObject) hypIO = selected.First();
3206               if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3207               {
3208                 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3209                 aCreator->setShapeEntry( subGeomID );
3210                 aCreator->setMainShapeEntry( meshGeomID );
3211               }
3212             }
3213
3214             aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3215           }
3216           else
3217           {
3218             // report error
3219           }
3220         }
3221       }
3222       break;
3223     }
3224   case SMESHOp::OpUnassign:                      // REMOVE HYPOTHESIS / ALGORITHMS
3225     {
3226       if(isStudyLocked()) break;
3227       SUIT_OverrideCursor wc;
3228
3229       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3230       SALOME_ListIO selected;
3231       if( aSel )
3232         aSel->selectedObjects( selected, QString::null, false );
3233
3234       SALOME_ListIteratorOfListIO It(selected);
3235       for (int i = 0; It.More(); It.Next(), i++) {
3236         Handle(SALOME_InteractiveObject) IObject = It.Value();
3237         SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3238       }
3239       SALOME_ListIO l1;
3240       aSel->setSelectedObjects( l1 );
3241       updateObjBrowser();
3242       break;
3243     }
3244
3245   case SMESHOp::OpElem0D:
3246   case SMESHOp::OpBall:
3247   case SMESHOp::OpEdge:
3248   case SMESHOp::OpTriangle:
3249   case SMESHOp::OpQuadrangle:
3250   case SMESHOp::OpPolygon:
3251   case SMESHOp::OpTetrahedron:
3252   case SMESHOp::OpHexahedron:
3253   case SMESHOp::OpPentahedron:
3254   case SMESHOp::OpPyramid:
3255   case SMESHOp::OpHexagonalPrism:
3256     {
3257       if(isStudyLocked()) break;
3258       if ( vtkwnd ) {
3259         EmitSignalDeactivateDialog();
3260         SMDSAbs_EntityType type = SMDSEntity_Edge;
3261         switch (theCommandID) {
3262         case SMESHOp::OpElem0D: type = SMDSEntity_0D;                      break;
3263         case SMESHOp::OpBall: type = SMDSEntity_Ball;                      break;
3264         case SMESHOp::OpTriangle: type = SMDSEntity_Triangle;              break;
3265         case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle;          break;
3266         case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra;              break;
3267         case SMESHOp::OpPolygon: type = SMDSEntity_Polygon;                break;
3268         case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa;                break;
3269         case SMESHOp::OpPentahedron: type = SMDSEntity_Penta;              break;
3270         case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid;                break;
3271         case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3272         default:;
3273         }
3274         ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3275       }
3276       else {
3277         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3278       }
3279       break;
3280     }
3281   case SMESHOp::OpPolyhedron:
3282     {
3283       if(isStudyLocked()) break;
3284       if ( vtkwnd ) {
3285         EmitSignalDeactivateDialog();
3286         ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3287       }
3288       else {
3289         SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3290       }
3291       break;
3292     }
3293   case SMESHOp::OpQuadraticEdge:
3294   case SMESHOp::OpQuadraticTriangle:
3295   case SMESHOp::OpBiQuadraticTriangle:
3296   case SMESHOp::OpQuadraticQuadrangle:
3297   case SMESHOp::OpBiQuadraticQuadrangle:
3298   case SMESHOp::OpQuadraticPolygon:
3299   case SMESHOp::OpQuadraticTetrahedron:
3300   case SMESHOp::OpQuadraticPyramid:
3301   case SMESHOp::OpQuadraticPentahedron:
3302   case SMESHOp::OpBiQuadraticPentahedron:
3303   case SMESHOp::OpQuadraticHexahedron:
3304   case SMESHOp::OpTriQuadraticHexahedron:
3305     {
3306       if(isStudyLocked()) break;
3307       if ( vtkwnd ) {
3308         EmitSignalDeactivateDialog();
3309         SMDSAbs_EntityType type = SMDSEntity_Last;
3310
3311         switch (theCommandID) {
3312         case SMESHOp::OpQuadraticEdge:          type = SMDSEntity_Quad_Edge; break;
3313         case SMESHOp::OpQuadraticTriangle:      type = SMDSEntity_Quad_Triangle; break;
3314         case SMESHOp::OpBiQuadraticTriangle:    type = SMDSEntity_BiQuad_Triangle; break;
3315         case SMESHOp::OpQuadraticQuadrangle:    type = SMDSEntity_Quad_Quadrangle; break;
3316         case SMESHOp::OpBiQuadraticQuadrangle:  type = SMDSEntity_BiQuad_Quadrangle; break;
3317         case SMESHOp::OpQuadraticPolygon:       type = SMDSEntity_Quad_Polygon; break;
3318         case SMESHOp::OpQuadraticTetrahedron:   type = SMDSEntity_Quad_Tetra; break;
3319         case SMESHOp::OpQuadraticPyramid:       type = SMDSEntity_Quad_Pyramid; break;
3320         case SMESHOp::OpQuadraticPentahedron:   type = SMDSEntity_Quad_Penta; break;
3321         case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3322         case SMESHOp::OpQuadraticHexahedron:    type = SMDSEntity_Quad_Hexa; break;
3323         case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3324         default: break;
3325         }
3326         if ( type != SMDSEntity_Last )
3327           ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3328       }
3329       else {
3330         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3331                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3332       }
3333       break;
3334     }
3335   case SMESHOp::OpRemoveNodes:
3336     {
3337       if(isStudyLocked()) break;
3338       if ( vtkwnd ) {
3339         EmitSignalDeactivateDialog();
3340         ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3341       }
3342       else {
3343         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3344                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3345       }
3346       break;
3347     }
3348   case SMESHOp::OpRemoveElements:                                    // REMOVES ELEMENTS
3349     {
3350       if(isStudyLocked()) break;
3351       if( vtkwnd ) {
3352         EmitSignalDeactivateDialog();
3353         ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3354       }
3355       else
3356         {
3357           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3358                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3359         }
3360       break;
3361     }
3362   case SMESHOp::OpClearMesh: {
3363
3364     if(isStudyLocked()) break;
3365
3366     SALOME_ListIO selected;
3367     if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3368       aSel->selectedObjects( selected );
3369
3370     SUIT_OverrideCursor wc;
3371     SALOME_ListIteratorOfListIO It (selected);
3372     for ( ; It.More(); It.Next() )
3373     {
3374       Handle(SALOME_InteractiveObject) IOS = It.Value();
3375       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3376       if ( aMesh->_is_nil()) continue;
3377       try {
3378         aMesh->Clear();
3379         if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3380           SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3381         _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3382         // hide groups and submeshes
3383         _PTR(ChildIterator) anIter =
3384           SMESH::getStudy()->NewChildIterator( aMeshSObj );
3385         for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3386         {
3387           _PTR(SObject) so = anIter->Value();
3388           SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3389         }
3390       }
3391       catch (const SALOME::SALOME_Exception& S_ex){
3392         wc.suspend();
3393         SalomeApp_Tools::QtCatchCorbaException(S_ex);
3394         wc.resume();
3395       }
3396     }
3397     SMESH::UpdateView();
3398     updateObjBrowser();
3399     break;
3400   }
3401   case SMESHOp::OpRemoveOrphanNodes:
3402     {
3403       if(isStudyLocked()) break;
3404       SALOME_ListIO selected;
3405       if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3406         aSel->selectedObjects( selected );
3407       if ( selected.Extent() == 1 ) {
3408         Handle(SALOME_InteractiveObject) anIO = selected.First();
3409         SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3410         if ( !aMesh->_is_nil() ) {
3411           bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3412                                                     tr( "SMESH_WARNING" ),
3413                                                     tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3414                                                     SUIT_MessageBox::Yes |
3415                                                     SUIT_MessageBox::No,
3416                                                     SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3417           if( confirm ) {
3418             try {
3419               SUIT_OverrideCursor wc;
3420               SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3421               int removed = aMeshEditor->RemoveOrphanNodes();
3422               SUIT_MessageBox::information(SMESHGUI::desktop(),
3423                                            tr("SMESH_INFORMATION"),
3424                                            tr("NB_NODES_REMOVED").arg(removed));
3425               if ( removed > 0 ) {
3426                 SMESH::UpdateView();
3427                 SMESHGUI::Modified();
3428               }
3429             }
3430             catch (const SALOME::SALOME_Exception& S_ex) {
3431               SalomeApp_Tools::QtCatchCorbaException(S_ex);
3432             }
3433             catch (...) {
3434             }
3435           }
3436         }
3437       }
3438       break;
3439     }
3440   case SMESHOp::OpRenumberingNodes:
3441     {
3442       if(isStudyLocked()) break;
3443       if( vtkwnd ) {
3444         EmitSignalDeactivateDialog();
3445         ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3446       }
3447       else
3448         {
3449           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3450                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3451         }
3452       break;
3453     }
3454   case SMESHOp::OpRenumberingElements:
3455     {
3456       if(isStudyLocked()) break;
3457       if ( vtkwnd ) {
3458         EmitSignalDeactivateDialog();
3459         ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3460       }
3461       else
3462         {
3463           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3464                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3465         }
3466       break;
3467     }
3468   case SMESHOp::OpTranslation:
3469     {
3470       if(isStudyLocked()) break;
3471       if ( vtkwnd ) {
3472         EmitSignalDeactivateDialog();
3473         ( new SMESHGUI_TranslationDlg( this ) )->show();
3474       }
3475       else {
3476         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3477                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3478       }
3479       break;
3480     }
3481   case SMESHOp::OpRotation:
3482     {
3483       if(isStudyLocked()) break;
3484       if( vtkwnd ) {
3485         EmitSignalDeactivateDialog();
3486         ( new SMESHGUI_RotationDlg( this ) )->show();
3487       }
3488       else {
3489         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3490                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3491       }
3492       break;
3493     }
3494   case SMESHOp::OpSymmetry:
3495     {
3496       if(isStudyLocked()) break;
3497       if(vtkwnd) {
3498         EmitSignalDeactivateDialog();
3499         ( new SMESHGUI_SymmetryDlg( this ) )->show();
3500       }
3501       else {
3502         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3503                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3504       }
3505       break;
3506     }
3507   case SMESHOp::OpScale:
3508     {
3509       if(isStudyLocked()) break;
3510       if ( vtkwnd ) {
3511         EmitSignalDeactivateDialog();
3512         ( new SMESHGUI_ScaleDlg( this ) )->show();
3513       }
3514       else {
3515         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3516                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3517       }
3518       break;
3519     }
3520
3521   case SMESHOp::OpOffset:
3522     {
3523       if(isStudyLocked()) break;
3524       if ( vtkwnd ) {
3525         EmitSignalDeactivateDialog();
3526         ( new SMESHGUI_OffsetDlg( this ) )->show();
3527       }
3528       else {
3529         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3530                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3531       }
3532       break;
3533     }
3534
3535   case SMESHOp::OpSewing:
3536     {
3537       if(isStudyLocked()) break;
3538       if(vtkwnd) {
3539         EmitSignalDeactivateDialog();
3540         ( new SMESHGUI_SewingDlg( this ) )->show();
3541       }
3542       else {
3543         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3544                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3545       }
3546       break;
3547     }
3548   case SMESHOp::OpMergeNodes:
3549     {
3550       if(isStudyLocked()) break;
3551       if(vtkwnd) {
3552         EmitSignalDeactivateDialog();
3553         ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3554       }
3555       else {
3556         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3557                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3558       }
3559       break;
3560     }
3561   case SMESHOp::OpMergeElements:
3562     {
3563       if (isStudyLocked()) break;
3564       if (vtkwnd) {
3565         EmitSignalDeactivateDialog();
3566         ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3567       } else {
3568         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3569                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3570       }
3571       break;
3572     }
3573
3574   case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3575     startOperation( SMESHOp::OpMoveNode );
3576     break;
3577
3578   case SMESHOp::OpDuplicateNodes:
3579     {
3580       if(isStudyLocked()) break;
3581       if ( vtkwnd ) {
3582         EmitSignalDeactivateDialog();
3583         ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3584       }
3585       else {
3586         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3587                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3588       }
3589       break;
3590     }
3591
3592   case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3593     startOperation( SMESHOp::OpElem0DOnElemNodes );
3594     break;
3595
3596   case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3597   {
3598     static QList<int> aTypes;
3599     if ( aTypes.isEmpty() )
3600     {
3601       aTypes.append( SMESH::NODE );
3602       aTypes.append( SMESH::EDGE );
3603       aTypes.append( SMESH::FACE );
3604       aTypes.append( SMESH::VOLUME );
3605     }
3606     if (!myFilterLibraryDlg)
3607       myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3608     else if (myFilterLibraryDlg->isHidden())
3609       myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3610     myFilterLibraryDlg->raise();
3611   }
3612   break;
3613   // CONTROLS
3614   case SMESHOp::OpFreeNode:
3615   case SMESHOp::OpEqualNode:
3616   case SMESHOp::OpNodeConnectivityNb:
3617   case SMESHOp::OpFreeEdge:
3618   case SMESHOp::OpFreeBorder:
3619   case SMESHOp::OpLength:
3620   case SMESHOp::OpConnection:
3621   case SMESHOp::OpEqualEdge:
3622   case SMESHOp::OpFreeFace:
3623   case SMESHOp::OpBareBorderFace:
3624   case SMESHOp::OpOverConstrainedFace:
3625   case SMESHOp::OpLength2D:
3626   case SMESHOp::OpDeflection2D:
3627   case SMESHOp::OpConnection2D:
3628   case SMESHOp::OpArea:
3629   case SMESHOp::OpTaper:
3630   case SMESHOp::OpAspectRatio:
3631   case SMESHOp::OpMinimumAngle:
3632   case SMESHOp::OpWarpingAngle:
3633   case SMESHOp::OpSkew:
3634   case SMESHOp::OpMaxElementLength2D:
3635   case SMESHOp::OpEqualFace:
3636   case SMESHOp::OpAspectRatio3D:
3637   case SMESHOp::OpVolume:
3638   case SMESHOp::OpMaxElementLength3D:
3639   case SMESHOp::OpBareBorderVolume:
3640   case SMESHOp::OpOverConstrainedVolume:
3641   case SMESHOp::OpEqualVolume:
3642     if ( vtkwnd ) {
3643
3644       LightApp_SelectionMgr* mgr = selectionMgr();
3645       SALOME_ListIO selected; mgr->selectedObjects( selected );
3646
3647       if( !selected.IsEmpty() ) {
3648         SUIT_OverrideCursor wc;
3649         ::Control( theCommandID );
3650         break;
3651       }
3652       SUIT_MessageBox::warning(desktop(),
3653                                tr( "SMESH_WRN_WARNING" ),
3654                                tr( "SMESH_BAD_SELECTION" ) );
3655       break;
3656     }
3657     else {
3658       SUIT_MessageBox::warning(desktop(),
3659                                tr( "SMESH_WRN_WARNING" ),
3660                                tr( "NOT_A_VTK_VIEWER" ) );
3661     }
3662     break;
3663   case SMESHOp::OpOverallMeshQuality:
3664     OverallMeshQuality();
3665     break;
3666   case SMESHOp::OpNumberingNodes:
3667     {
3668       SUIT_OverrideCursor wc;
3669       LightApp_SelectionMgr* mgr = selectionMgr();
3670       SALOME_ListIO selected; mgr->selectedObjects( selected );
3671
3672       SALOME_ListIteratorOfListIO it(selected);
3673       for( ; it.More(); it.Next()) {
3674         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3675         if(anIObject->hasEntry()) {
3676           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3677             anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3678           }
3679         }
3680       }
3681       break;
3682     }
3683   case SMESHOp::OpNumberingElements:
3684     {
3685       SUIT_OverrideCursor wc;
3686       LightApp_SelectionMgr* mgr = selectionMgr();
3687       SALOME_ListIO selected; mgr->selectedObjects( selected );
3688
3689       SALOME_ListIteratorOfListIO it(selected);
3690       for( ; it.More(); it.Next()) {
3691         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3692         if(anIObject->hasEntry())
3693           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3694             anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3695           }
3696       }
3697       break;
3698     }
3699   case SMESHOp::OpPropertiesLength:
3700   case SMESHOp::OpPropertiesArea:
3701   case SMESHOp::OpPropertiesVolume:
3702   case SMESHOp::OpMinimumDistance:
3703   case SMESHOp::OpBoundingBox:
3704     {
3705       int page = SMESHGUI_MeasureDlg::MinDistance;
3706       if ( theCommandID == SMESHOp::OpBoundingBox )
3707         page = SMESHGUI_MeasureDlg::BoundingBox;
3708       else if ( theCommandID == SMESHOp::OpPropertiesLength )
3709         page = SMESHGUI_MeasureDlg::Length;
3710       else if ( theCommandID == SMESHOp::OpPropertiesArea )
3711         page = SMESHGUI_MeasureDlg::Area;
3712       else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3713         page = SMESHGUI_MeasureDlg::Volume;
3714
3715       EmitSignalDeactivateDialog();
3716       SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3717       dlg->show();
3718       break;
3719     }
3720   case SMESHOp::OpSortChild:
3721     ::sortChildren();
3722     break;
3723
3724   }
3725
3726   anApp->updateActions(); //SRN: To update a Save button in the toolbar
3727   //updateObjBrowser();
3728   return true;
3729 }
3730
3731 //=============================================================================
3732 /*!
3733  *
3734  */
3735 //=============================================================================
3736 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3737 {
3738   return false;
3739 }
3740
3741 //=============================================================================
3742 /*!
3743  *
3744  */
3745 //=============================================================================
3746 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3747 {
3748   return true;
3749 }
3750
3751 //=============================================================================
3752 /*!
3753  *
3754  */
3755 //=============================================================================
3756 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3757 {
3758   return true;
3759 }
3760
3761 //=============================================================================
3762 /*! Method:  BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3763  *  Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3764  */
3765 //=============================================================================
3766 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3767                                   SUIT_ViewWindow* wnd )
3768 {
3769   if(theIO->hasEntry()){
3770     //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3771     SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3772   }
3773 }
3774
3775 //=======================================================================
3776 // function : createSMESHAction
3777 // purpose  :
3778 //=======================================================================
3779 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3780                                   const int key, const bool toggle, const QString& shortcutAction  )
3781 {
3782   QIcon icon;
3783   QWidget* parent = application()->desktop();
3784   SUIT_ResourceMgr* resMgr = resourceMgr();
3785   QPixmap pix;
3786   if ( !icon_id.isEmpty() )
3787     pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3788   else
3789     pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3790   if ( !pix.isNull() )
3791     icon = QIcon( pix );
3792
3793   QString tooltip    = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3794           menu       = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3795           status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3796
3797   createAction( id, tooltip, icon, menu, status_bar, key, parent,
3798                 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3799 }
3800
3801 //=======================================================================
3802 // function : createPopupItem
3803 // purpose  :
3804 //=======================================================================
3805 void SMESHGUI::createPopupItem( const int id,
3806                                 const QString& clients,
3807                                 const QString& types,
3808                                 const QString& theRule,
3809                                 const int pId )
3810 {
3811   if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3812     popupMgr()->insert( action( id ), pId, 0 );
3813
3814   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
3815   QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3816   QString rule = "(%1) and (%2) and (%3)";
3817   rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3818   if( clients.isEmpty() )
3819     rule = rule.arg( QString( "true" ) );
3820   else
3821     rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3822   rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3823   rule += theRule;
3824
3825   bool cont = myRules.contains( id );
3826   if( cont )
3827     rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3828
3829   popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3830   myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3831 }
3832
3833 //=======================================================================
3834 // function : initialize
3835 // purpose  :
3836 //=======================================================================
3837 void SMESHGUI::initialize( CAM_Application* app )
3838 {
3839   SalomeApp_Module::initialize( app );
3840
3841 //   SUIT_ResourceMgr* mgr = app->resourceMgr();
3842 //   if ( mgr )
3843   /* Automatic Update flag */
3844 //     myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3845
3846   // ----- create actions --------------
3847
3848   //createSMESHAction(  SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3849   createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3850   createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3851   createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL"  );
3852 #ifdef WITH_CGNS
3853   createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3854 #endif
3855   createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3856   createSMESHAction( SMESHOp::OpImportGMF,  "IMPORT_GMF"  );
3857   createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3858   createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3859   createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL"  );
3860 #ifdef WITH_CGNS
3861   createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3862 #endif
3863   createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3864   createSMESHAction( SMESHOp::OpPopupImportGMF,  "IMPORT_GMF"  );
3865
3866   createSMESHAction( SMESHOp::OpExportDAT,  "DAT" );
3867   createSMESHAction( SMESHOp::OpExportMED,  "MED" );
3868   createSMESHAction( SMESHOp::OpExportUNV,  "UNV" );
3869   createSMESHAction( SMESHOp::OpExportSTL,  "STL" );
3870 #ifdef WITH_CGNS
3871   createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3872 #endif
3873   createSMESHAction( SMESHOp::OpExportSAUV,     "SAUV");
3874   createSMESHAction( SMESHOp::OpExportGMF,      "GMF" );
3875   createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3876   createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3877   createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3878   createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3879 #ifdef WITH_CGNS
3880   createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3881 #endif
3882   createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3883   createSMESHAction( SMESHOp::OpPopupExportGMF,  "GMF" );
3884   createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3885   createSMESHAction( SMESHOp::OpDelete,          "DELETE", "ICON_DELETE", Qt::Key_Delete );
3886   createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3887   createSMESHAction( SMESHOp::OpCreateMesh,           "CREATE_MESH",             "ICON_DLG_INIT_MESH" );
3888   createSMESHAction( SMESHOp::OpCreateSubMesh,        "CREATE_SUBMESH",          "ICON_DLG_ADD_SUBMESH" );
3889   createSMESHAction( SMESHOp::OpEditMeshOrSubMesh,    "EDIT_MESHSUBMESH",        "ICON_DLG_EDIT_MESH" );
3890   createSMESHAction( SMESHOp::OpEditMesh,             "EDIT_MESH",               "ICON_DLG_EDIT_MESH" );
3891   createSMESHAction( SMESHOp::OpEditSubMesh,          "EDIT_SUBMESH",            "ICON_DLG_EDIT_MESH" );
3892   createSMESHAction( SMESHOp::OpBuildCompoundMesh,    "BUILD_COMPOUND",          "ICON_BUILD_COMPOUND" );
3893   createSMESHAction( SMESHOp::OpCopyMesh,             "COPY_MESH",               "ICON_COPY_MESH" );
3894   createSMESHAction( SMESHOp::OpCompute,              "COMPUTE",                 "ICON_COMPUTE" );
3895   createSMESHAction( SMESHOp::OpComputeSubMesh,       "COMPUTE_SUBMESH",         "ICON_COMPUTE" );
3896   createSMESHAction( SMESHOp::OpPreCompute,           "PRECOMPUTE",              "ICON_PRECOMPUTE" );
3897   createSMESHAction( SMESHOp::OpEvaluate,             "EVALUATE",                "ICON_EVALUATE" );
3898   createSMESHAction( SMESHOp::OpMeshOrder,            "MESH_ORDER",              "ICON_MESH_ORDER");
3899   createSMESHAction( SMESHOp::OpCreateGroup,          "CREATE_GROUP",            "ICON_CREATE_GROUP" );
3900   createSMESHAction( SMESHOp::OpCreateGeometryGroup,  "CREATE_GEO_GROUP",        "ICON_CREATE_GEO_GROUP" );
3901   createSMESHAction( SMESHOp::OpConstructGroup,       "CONSTRUCT_GROUP",         "ICON_CONSTRUCT_GROUP" );
3902   createSMESHAction( SMESHOp::OpEditGroup,            "EDIT_GROUP",              "ICON_EDIT_GROUP" );
3903   createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3904   createSMESHAction( SMESHOp::OpUnionGroups,          "UN_GROUP",                "ICON_UNION" );
3905   createSMESHAction( SMESHOp::OpIntersectGroups,      "INT_GROUP",               "ICON_INTERSECT" );
3906   createSMESHAction( SMESHOp::OpCutGroups,            "CUT_GROUP",               "ICON_CUT" );
3907   createSMESHAction( SMESHOp::OpGroupUnderlyingElem,  "UNDERLYING_ELEMS",        "ICON_UNDERLYING_ELEMS" );
3908   createSMESHAction( SMESHOp::OpAddElemGroupPopup,    "ADD_TO_GROUP" );
3909   createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3910   createSMESHAction( SMESHOp::OpDeleteGroup,          "DEL_GROUP",               "ICON_DEL_GROUP" );
3911   createSMESHAction( SMESHOp::OpMeshInformation ,     "ADV_INFO",                "ICON_ADV_INFO" );
3912   //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO",        "ICON_STD_INFO" );
3913   //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS",         "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3914   createSMESHAction( SMESHOp::OpFindElementByPoint,   "FIND_ELEM",               "ICON_FIND_ELEM" );
3915   //update
3916   createSMESHAction( SMESHOp::OpFreeNode,              "FREE_NODE",               "ICON_FREE_NODE",     0, true );
3917   createSMESHAction( SMESHOp::OpEqualNode,             "EQUAL_NODE",              "ICON_EQUAL_NODE",    0, true );
3918   createSMESHAction( SMESHOp::OpNodeConnectivityNb,    "NODE_CONNECTIVITY_NB",    "ICON_NODE_CONN_NB",    0, true );
3919   createSMESHAction( SMESHOp::OpFreeEdge,              "FREE_EDGE",               "ICON_FREE_EDGE",     0, true );
3920   createSMESHAction( SMESHOp::OpFreeBorder,            "FREE_BORDER",             "ICON_FREE_EDGE_2D",  0, true );
3921   createSMESHAction( SMESHOp::OpLength,                "LENGTH",                  "ICON_LENGTH",        0, true );
3922   createSMESHAction( SMESHOp::OpConnection,            "CONNECTION",              "ICON_CONNECTION",    0, true );
3923   createSMESHAction( SMESHOp::OpEqualEdge,             "EQUAL_EDGE",              "ICON_EQUAL_EDGE",    0, true );
3924   createSMESHAction( SMESHOp::OpFreeFace,              "FREE_FACES",              "ICON_FREE_FACES",    0, true );
3925   createSMESHAction( SMESHOp::OpBareBorderFace,        "BARE_BORDER_FACE",        "ICON_BARE_BORDER_FACE",        0, true );
3926   createSMESHAction( SMESHOp::OpOverConstrainedFace,   "OVER_CONSTRAINED_FACE",   "ICON_OVER_CONSTRAINED_FACE",   0, true );
3927   createSMESHAction( SMESHOp::OpLength2D,              "LENGTH_2D",               "ICON_LENGTH_2D",     0, true );
3928   createSMESHAction( SMESHOp::OpDeflection2D,          "DEFLECTION_2D",           "ICON_DEFLECTION_2D", 0, true );
3929   createSMESHAction( SMESHOp::OpConnection2D,          "CONNECTION_2D",           "ICON_CONNECTION_2D", 0, true );
3930   createSMESHAction( SMESHOp::OpArea,                  "AREA",                    "ICON_AREA",          0, true );
3931   createSMESHAction( SMESHOp::OpTaper,                 "TAPER",                   "ICON_TAPER",         0, true );
3932   createSMESHAction( SMESHOp::OpAspectRatio,           "ASPECT",                  "ICON_ASPECT",        0, true );
3933   createSMESHAction( SMESHOp::OpMinimumAngle,          "MIN_ANG",                 "ICON_ANGLE",         0, true );
3934   createSMESHAction( SMESHOp::OpWarpingAngle,          "WARP",                    "ICON_WARP",          0, true );
3935   createSMESHAction( SMESHOp::OpSkew,                  "SKEW",                    "ICON_SKEW",          0, true );
3936   createSMESHAction( SMESHOp::OpMaxElementLength2D,    "MAX_ELEMENT_LENGTH_2D",   "ICON_MAX_ELEMENT_LENGTH_2D",   0, true );
3937   createSMESHAction( SMESHOp::OpEqualFace,             "EQUAL_FACE",              "ICON_EQUAL_FACE",    0, true );
3938   createSMESHAction( SMESHOp::OpAspectRatio3D,         "ASPECT_3D",               "ICON_ASPECT_3D",     0, true );
3939   createSMESHAction( SMESHOp::OpVolume,                "VOLUME_3D",               "ICON_VOLUME_3D",     0, true );
3940   createSMESHAction( SMESHOp::OpMaxElementLength3D,    "MAX_ELEMENT_LENGTH_3D",   "ICON_MAX_ELEMENT_LENGTH_3D",   0, true );
3941   createSMESHAction( SMESHOp::OpBareBorderVolume,      "BARE_BORDER_VOLUME",      "ICON_BARE_BORDER_VOLUME",      0, true );
3942   createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3943   createSMESHAction( SMESHOp::OpEqualVolume,           "EQUAL_VOLUME",            "ICON_EQUAL_VOLUME",  0, true );
3944   createSMESHAction( SMESHOp::OpOverallMeshQuality,    "OVERALL_MESH_QUALITY",    "ICON_OVL_MESH_QUALITY" );
3945
3946   createSMESHAction( SMESHOp::OpNode,                   "NODE",            "ICON_DLG_NODE" );
3947   createSMESHAction( SMESHOp::OpElem0D,                 "ELEM0D",          "ICON_DLG_ELEM0D" );
3948   createSMESHAction( SMESHOp::OpElem0DOnElemNodes,      "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3949   createSMESHAction( SMESHOp::OpBall,                   "BALL",            "ICON_DLG_BALL" );
3950   createSMESHAction( SMESHOp::OpEdge,                   "EDGE",            "ICON_DLG_EDGE" );
3951   createSMESHAction( SMESHOp::OpTriangle,               "TRIANGLE",        "ICON_DLG_TRIANGLE" );
3952   createSMESHAction( SMESHOp::OpQuadrangle,             "QUAD",            "ICON_DLG_QUADRANGLE" );
3953   createSMESHAction( SMESHOp::OpPolygon,                "POLYGON",         "ICON_DLG_POLYGON" );
3954   createSMESHAction( SMESHOp::OpTetrahedron,            "TETRA",           "ICON_DLG_TETRAS" );
3955   createSMESHAction( SMESHOp::OpHexahedron,             "HEXA",            "ICON_DLG_HEXAS" );
3956   createSMESHAction( SMESHOp::OpPentahedron,            "PENTA",           "ICON_DLG_PENTA" );
3957   createSMESHAction( SMESHOp::OpPyramid ,               "PYRAMID",         "ICON_DLG_PYRAMID" );
3958   createSMESHAction( SMESHOp::OpHexagonalPrism,         "OCTA",            "ICON_DLG_OCTA" );
3959   createSMESHAction( SMESHOp::OpPolyhedron,             "POLYHEDRON",      "ICON_DLG_POLYHEDRON" );
3960   createSMESHAction( SMESHOp::OpQuadraticEdge,          "QUADRATIC_EDGE",          "ICON_DLG_QUADRATIC_EDGE" );
3961   createSMESHAction( SMESHOp::OpQuadraticTriangle,      "QUADRATIC_TRIANGLE",      "ICON_DLG_QUADRATIC_TRIANGLE" );
3962   createSMESHAction( SMESHOp::OpBiQuadraticTriangle,    "BIQUADRATIC_TRIANGLE",    "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3963   createSMESHAction( SMESHOp::OpQuadraticQuadrangle,    "QUADRATIC_QUADRANGLE",    "ICON_DLG_QUADRATIC_QUADRANGLE" );
3964   createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle,  "BIQUADRATIC_QUADRANGLE",  "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3965   createSMESHAction( SMESHOp::OpQuadraticPolygon,       "QUADRATIC_POLYGON",       "ICON_DLG_QUADRATIC_POLYGON" );
3966   createSMESHAction( SMESHOp::OpQuadraticTetrahedron,   "QUADRATIC_TETRAHEDRON",   "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3967   createSMESHAction( SMESHOp::OpQuadraticPyramid,       "QUADRATIC_PYRAMID",       "ICON_DLG_QUADRATIC_PYRAMID" );
3968   createSMESHAction( SMESHOp::OpQuadraticPentahedron,   "QUADRATIC_PENTAHEDRON",   "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3969   createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
3970   createSMESHAction( SMESHOp::OpQuadraticHexahedron,    "QUADRATIC_HEXAHEDRON",    "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3971   createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3972
3973   createSMESHAction( SMESHOp::OpRemoveNodes,       "REMOVE_NODES",          "ICON_DLG_REM_NODE" );
3974   createSMESHAction( SMESHOp::OpRemoveElements,    "REMOVE_ELEMENTS",       "ICON_DLG_REM_ELEMENT" );
3975   createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES",   "ICON_DLG_REM_ORPHAN_NODES" );
3976   createSMESHAction( SMESHOp::OpClearMesh,         "CLEAR_MESH",            "ICON_CLEAR_MESH" );
3977
3978   //createSMESHAction( SMESHOp::OpRenumberingNodes,    "RENUM_NODES",     "ICON_DLG_RENUMBERING_NODES" );
3979   //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS",  "ICON_DLG_RENUMBERING_ELEMENTS" );
3980
3981   createSMESHAction( SMESHOp::OpTranslation,            "TRANS",           "ICON_SMESH_TRANSLATION_VECTOR" );
3982   createSMESHAction( SMESHOp::OpRotation,               "ROT",             "ICON_DLG_MESH_ROTATION" );
3983   createSMESHAction( SMESHOp::OpSymmetry,               "SYM",             "ICON_SMESH_SYMMETRY_PLANE" );
3984   createSMESHAction( SMESHOp::OpScale,                  "SCALE",           "ICON_DLG_MESH_SCALE" );
3985   createSMESHAction( SMESHOp::OpOffset,                 "OFFSET",          "ICON_DLG_MESH_OFFSET" );
3986   createSMESHAction( SMESHOp::OpSewing,                 "SEW",             "ICON_SMESH_SEWING_FREEBORDERS" );
3987   createSMESHAction( SMESHOp::OpMergeNodes,             "MERGE",           "ICON_SMESH_MERGE_NODES" );
3988   createSMESHAction( SMESHOp::OpMergeElements,          "MERGE_ELEMENTS",  "ICON_DLG_MERGE_ELEMENTS" );
3989   createSMESHAction( SMESHOp::OpMoveNode,               "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3990   createSMESHAction( SMESHOp::OpDuplicateNodes,         "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3991   createSMESHAction( SMESHOp::OpDiagonalInversion,      "INV",             "ICON_DLG_MESH_DIAGONAL" );
3992   createSMESHAction( SMESHOp::OpUnionOfTwoTriangle,     "UNION2",          "ICON_UNION2TRI" );
3993   createSMESHAction( SMESHOp::OpOrientation,            "ORIENT",          "ICON_DLG_MESH_ORIENTATION" );
3994   createSMESHAction( SMESHOp::OpReorientFaces,          "REORIENT_2D",     "ICON_REORIENT_2D" );
3995   createSMESHAction( SMESHOp::OpUnionOfTriangles,       "UNION",           "ICON_UNIONTRI" );
3996   createSMESHAction( SMESHOp::OpCuttingOfQuadrangles,   "CUT",             "ICON_CUTQUAD" );
3997   createSMESHAction( SMESHOp::OpSplitVolumes,           "SPLIT_TO_TETRA",  "ICON_SPLIT_TO_TETRA" );
3998   createSMESHAction( SMESHOp::OpSplitBiQuadratic,       "SPLIT_BIQUAD",    "ICON_SPLIT_BIQUAD" );
3999   createSMESHAction( SMESHOp::OpSmoothing,              "SMOOTH",          "ICON_DLG_SMOOTHING" );
4000   createSMESHAction( SMESHOp::OpExtrusion,              "EXTRUSION",       "ICON_EXTRUSION" );
4001   createSMESHAction( SMESHOp::OpExtrusionAlongAPath,    "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4002   createSMESHAction( SMESHOp::OpRevolution,             "REVOLUTION",      "ICON_REVOLUTION" );
4003   createSMESHAction( SMESHOp::OpPatternMapping,         "MAP",             "ICON_MAP" );
4004   createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD",    "ICON_CONV_TO_QUAD" );
4005   createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D",      "ICON_2D_FROM_3D" );
4006
4007   createSMESHAction( SMESHOp::OpReset,               "RESET" );
4008   createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4009   createSMESHAction( SMESHOp::OpShowScalarBar,       "SHOW_SCALAR_BAR","",0, true  );
4010   createSMESHAction( SMESHOp::OpSaveDistribution,    "SAVE_DISTRIBUTION" );
4011   createSMESHAction( SMESHOp::OpShowDistribution,    "SHOW_DISTRIBUTION","",0, true );
4012 #ifndef DISABLE_PLOT2DVIEWER
4013   createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4014 #endif
4015   createSMESHAction( SMESHOp::OpDMWireframe,  "WIRE",    "ICON_WIRE", 0, true );
4016   createSMESHAction( SMESHOp::OpDMShading,    "SHADE",   "ICON_SHADE", 0, true );
4017   createSMESHAction( SMESHOp::OpDMNodes,      "NODES",   "ICON_POINTS", 0, true );
4018   createSMESHAction( SMESHOp::OpDMShrink,     "SHRINK",  "ICON_SHRINK", 0, true );
4019   createSMESHAction( SMESHOp::OpUpdate,       "UPDATE",  "ICON_UPDATE" );
4020   createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4021   createSMESHAction( SMESHOp::OpDEEdges,      "EDGES",   "ICON_DLG_EDGE", 0, true );
4022   createSMESHAction( SMESHOp::OpDEFaces,      "FACES",   "ICON_DLG_TRIANGLE", 0, true );
4023   createSMESHAction( SMESHOp::OpDEVolumes,    "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4024   createSMESHAction( SMESHOp::OpDEBalls,      "BALLS",   "ICON_DLG_BALL", 0, true );
4025   createSMESHAction( SMESHOp::OpDEChoose,     "CHOOSE",  "ICON_DLG_CHOOSE", 0, false );
4026   createSMESHAction( SMESHOp::OpDEAllEntity,  "ALL",     "ICON_DLG_CHOOSE_ALL", 0, false );
4027   createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4028
4029   createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4030   createSMESHAction( SMESHOp::OpRepresentationArcs,  "ARC_REPRESENTATION", "", 0, true );
4031
4032   createSMESHAction( SMESHOp::OpEditHypothesis,    "EDIT_HYPO" );
4033   createSMESHAction( SMESHOp::OpUnassign,          "UNASSIGN" );
4034   createSMESHAction( SMESHOp::OpNumberingNodes,    "NUM_NODES", "", 0, true );
4035   createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4036   createSMESHAction( SMESHOp::OpProperties,   "COLORS" );
4037   createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4038   createSMESHAction( SMESHOp::OpClipping,     "CLIP" );
4039   createSMESHAction( SMESHOp::OpAutoColor,        "AUTO_COLOR" );
4040   createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4041
4042   createSMESHAction( SMESHOp::OpMinimumDistance,  "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4043   createSMESHAction( SMESHOp::OpBoundingBox,      "MEASURE_BND_BOX",  "ICON_MEASURE_BND_BOX" );
4044   createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH",   "ICON_MEASURE_LENGTH" );
4045   createSMESHAction( SMESHOp::OpPropertiesArea,   "MEASURE_AREA",     "ICON_MEASURE_AREA" );
4046   createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME",   "ICON_MEASURE_VOLUME" );
4047
4048   createSMESHAction( SMESHOp::OpHide,     "HIDE", "ICON_HIDE" );
4049   createSMESHAction( SMESHOp::OpShow,     "SHOW", "ICON_SHOW" );
4050   createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4051
4052   createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4053
4054   QList<int> aCtrlActions;
4055   aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4056                << SMESHOp::OpNodeConnectivityNb                                         // node controls
4057                << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4058                << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge    // edge controls
4059                << SMESHOp::OpDeflection2D
4060                << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4061                << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4062                << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4063                << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4064                << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace                // face controls
4065                << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4066                << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4067                << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume;           // volume controls
4068   QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4069   aCtrlGroup->setExclusive( true );
4070   for( int i = 0; i < aCtrlActions.size(); i++ )
4071     aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4072
4073   // ----- create menu --------------
4074   int fileId    = createMenu( tr( "MEN_FILE" ),    -1,  1 ),
4075       editId    = createMenu( tr( "MEN_EDIT" ),    -1,  3 ),
4076       toolsId   = createMenu( tr( "MEN_TOOLS" ),   -1,  5, 50 ),
4077       meshId    = createMenu( tr( "MEN_MESH" ),    -1, 70, 10 ),
4078       ctrlId    = createMenu( tr( "MEN_CTRL" ),    -1, 60, 10 ),
4079       modifyId  = createMenu( tr( "MEN_MODIFY" ),  -1, 40, 10 ),
4080       measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4081       viewId    = createMenu( tr( "MEN_VIEW" ),    -1,  2 );
4082
4083   createMenu( separator(), fileId );
4084
4085   QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4086   QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4087   int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4088       exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4089       nodeId   = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4090       edgeId   = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4091       faceId   = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4092       volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4093       addId    = createMenu( tr( "MEN_ADD" ),    modifyId, 402 ),
4094       removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4095     //renumId  = createMenu( tr( "MEN_RENUM" ),  modifyId, 404 ),
4096       transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4097       basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4098
4099   //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4100   createMenu( SMESHOp::OpImportUNV,  importId, -1 );
4101   createMenu( SMESHOp::OpImportMED,  importId, -1 );
4102   createMenu( SMESHOp::OpImportSTL,  importId, -1 );
4103 #ifdef WITH_CGNS
4104   createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4105 #endif
4106   createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4107   createMenu( SMESHOp::OpImportGMF,  importId, -1 );
4108   createMenu( SMESHOp::OpExportDAT,  exportId, -1 );
4109   createMenu( SMESHOp::OpExportMED,  exportId, -1 );
4110   createMenu( SMESHOp::OpExportUNV,  exportId, -1 );
4111   createMenu( SMESHOp::OpExportSTL,  exportId, -1 );
4112 #ifdef WITH_CGNS
4113   createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4114 #endif
4115   createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4116   createMenu( SMESHOp::OpExportGMF,  exportId, -1 );
4117   createMenu( separator(), fileId, 10 );
4118
4119   createMenu( SMESHOp::OpDelete, editId, -1 );
4120
4121   createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4122
4123   createMenu( SMESHOp::OpCreateMesh,           meshId, -1 ); // "Mesh" menu
4124   createMenu( SMESHOp::OpCreateSubMesh,        meshId, -1 );
4125   createMenu( SMESHOp::OpEditMeshOrSubMesh,    meshId, -1 );
4126   createMenu( SMESHOp::OpBuildCompoundMesh,    meshId, -1 );
4127   createMenu( SMESHOp::OpCopyMesh,             meshId, -1 );
4128   createMenu( separator(),                     meshId, -1 );
4129   createMenu( SMESHOp::OpCompute,              meshId, -1 );
4130   createMenu( SMESHOp::OpPreCompute,           meshId, -1 );
4131   createMenu( SMESHOp::OpEvaluate,             meshId, -1 );
4132   createMenu( SMESHOp::OpMeshOrder,            meshId, -1 );
4133   createMenu( separator(),                     meshId, -1 );
4134   createMenu( SMESHOp::OpCreateGroup,          meshId, -1 );
4135   createMenu( SMESHOp::OpCreateGeometryGroup,  meshId, -1 );
4136   createMenu( SMESHOp::OpConstructGroup,       meshId, -1 );
4137   createMenu( SMESHOp::OpEditGroup,            meshId, -1 );
4138   createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4139   createMenu( separator(),                     meshId, -1 );
4140   createMenu( SMESHOp::OpUnionGroups,          meshId, -1 );
4141   createMenu( SMESHOp::OpIntersectGroups,      meshId, -1 );
4142   createMenu( SMESHOp::OpCutGroups,            meshId, -1 );
4143   createMenu( separator(),                     meshId, -1 );
4144   createMenu( SMESHOp::OpGroupUnderlyingElem,  meshId, -1 );
4145   createMenu( separator(),                     meshId, -1 );
4146   createMenu( SMESHOp::OpMeshInformation,      meshId, -1 );
4147   //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4148   //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4149   createMenu( SMESHOp::OpFindElementByPoint,   meshId, -1 );
4150   createMenu( separator(),                     meshId, -1 );
4151
4152   createMenu( SMESHOp::OpFreeNode,              nodeId,   -1 );
4153   createMenu( SMESHOp::OpEqualNode,             nodeId,   -1 );
4154   //createMenu( SMESHOp::OpNodeConnectivityNb,    nodeId,   -1 );
4155   createMenu( SMESHOp::OpFreeBorder,            edgeId,   -1 );
4156   createMenu( SMESHOp::OpLength,                edgeId,   -1 );
4157   createMenu( SMESHOp::OpConnection,            edgeId,   -1 );
4158   createMenu( SMESHOp::OpEqualEdge,             edgeId,   -1 );
4159   createMenu( SMESHOp::OpFreeEdge,              faceId,   -1 );
4160   createMenu( SMESHOp::OpFreeFace,              faceId,   -1 );
4161   createMenu( SMESHOp::OpBareBorderFace,        faceId,   -1 );
4162   createMenu( SMESHOp::OpOverConstrainedFace,   faceId,   -1 );
4163   createMenu( SMESHOp::OpLength2D,              faceId,   -1 );
4164   createMenu( SMESHOp::OpConnection2D,          faceId,   -1 );
4165   createMenu( SMESHOp::OpArea,                  faceId,   -1 );
4166   createMenu( SMESHOp::OpTaper,                 faceId,   -1 );
4167   createMenu( SMESHOp::OpAspectRatio,           faceId,   -1 );
4168   createMenu( SMESHOp::OpMinimumAngle,          faceId,   -1 );
4169   createMenu( SMESHOp::OpWarpingAngle,          faceId,   -1 );
4170   createMenu( SMESHOp::OpSkew,                  faceId,   -1 );
4171   createMenu( SMESHOp::OpMaxElementLength2D,    faceId,   -1 );
4172   createMenu( SMESHOp::OpEqualFace,             faceId,   -1 );
4173   createMenu( SMESHOp::OpDeflection2D,          faceId,   -1 );
4174   createMenu( SMESHOp::OpAspectRatio3D,         volumeId, -1 );
4175   createMenu( SMESHOp::OpVolume,                volumeId, -1 );
4176   createMenu( SMESHOp::OpMaxElementLength3D,    volumeId, -1 );
4177   createMenu( SMESHOp::OpBareBorderVolume,      volumeId, -1 );
4178   createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4179   createMenu( SMESHOp::OpEqualVolume,           volumeId, -1 );
4180   createMenu( separator(),                      ctrlId,   -1 );
4181   createMenu( SMESHOp::OpReset,                 ctrlId,   -1 );
4182   createMenu( separator(),                      ctrlId,   -1 );
4183   createMenu( SMESHOp::OpOverallMeshQuality,    ctrlId,   -1 );
4184
4185   createMenu( SMESHOp::OpNode,                   addId, -1 );
4186   createMenu( SMESHOp::OpElem0D,                 addId, -1 );
4187   createMenu( SMESHOp::OpElem0DOnElemNodes,      addId, -1 );
4188   createMenu( SMESHOp::OpBall,                   addId, -1 );
4189   createMenu( SMESHOp::OpEdge,                   addId, -1 );
4190   createMenu( SMESHOp::OpTriangle,               addId, -1 );
4191   createMenu( SMESHOp::OpQuadrangle,             addId, -1 );
4192   createMenu( SMESHOp::OpPolygon,                addId, -1 );
4193   createMenu( SMESHOp::OpTetrahedron,            addId, -1 );
4194   createMenu( SMESHOp::OpHexahedron,             addId, -1 );
4195   createMenu( SMESHOp::OpPentahedron,            addId, -1 );
4196   createMenu( SMESHOp::OpPyramid,                addId, -1 );
4197   createMenu( SMESHOp::OpHexagonalPrism,         addId, -1 );
4198   createMenu( SMESHOp::OpPolyhedron,             addId, -1 );
4199   createMenu( separator(),                       addId, -1 );
4200   createMenu( SMESHOp::OpQuadraticEdge,          addId, -1 );
4201   createMenu( SMESHOp::OpQuadraticTriangle,      addId, -1 );
4202   createMenu( SMESHOp::OpBiQuadraticTriangle ,   addId, -1 );
4203   createMenu( SMESHOp::OpQuadraticQuadrangle,    addId, -1 );
4204   createMenu( SMESHOp::OpBiQuadraticQuadrangle,  addId, -1 );
4205   createMenu( SMESHOp::OpQuadraticPolygon,       addId, -1 );
4206   createMenu( SMESHOp::OpQuadraticTetrahedron,   addId, -1 );
4207   createMenu( SMESHOp::OpQuadraticPyramid,       addId, -1 );
4208   createMenu( SMESHOp::OpQuadraticPentahedron,   addId, -1 );
4209   createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4210   createMenu( SMESHOp::OpQuadraticHexahedron,    addId, -1 );
4211   createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4212
4213   createMenu( SMESHOp::OpRemoveNodes,       removeId, -1 );
4214   createMenu( SMESHOp::OpRemoveElements,    removeId, -1 );
4215   createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4216   createMenu( separator(),                  removeId, -1 );
4217   createMenu( SMESHOp::OpDeleteGroup,       removeId, -1 );
4218   createMenu( separator(),                  removeId, -1 );
4219   createMenu( SMESHOp::OpClearMesh,         removeId, -1 );
4220
4221   //createMenu( SMESHOp::OpRenumberingNodes,    renumId, -1 );
4222   //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4223
4224   createMenu( SMESHOp::OpMergeNodes,     transfId, -1 );
4225   createMenu( SMESHOp::OpMergeElements,  transfId, -1 );
4226   createMenu( SMESHOp::OpTranslation,    transfId, -1 );
4227   createMenu( SMESHOp::OpRotation,       transfId, -1 );
4228   createMenu( SMESHOp::OpSymmetry,       transfId, -1 );
4229   createMenu( SMESHOp::OpScale,          transfId, -1 );
4230   createMenu( SMESHOp::OpOffset,         transfId, -1 );
4231   createMenu( SMESHOp::OpSewing,         transfId, -1 );
4232   createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4233
4234   createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4235   createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4236   createMenu( SMESHOp::OpExtrusion,              modifyId, -1 );
4237   createMenu( SMESHOp::OpExtrusionAlongAPath,    modifyId, -1 );
4238   createMenu( SMESHOp::OpRevolution,             modifyId, -1 );
4239   createMenu( SMESHOp::OpOrientation,            modifyId, -1 );
4240   createMenu( SMESHOp::OpReorientFaces,          modifyId, -1 );
4241   createMenu( SMESHOp::OpMoveNode,               modifyId, -1 );
4242   createMenu( SMESHOp::OpDiagonalInversion,      modifyId, -1 );
4243   createMenu( SMESHOp::OpUnionOfTwoTriangle,     modifyId, -1 );
4244   createMenu( SMESHOp::OpUnionOfTriangles,       modifyId, -1 );
4245   createMenu( SMESHOp::OpCuttingOfQuadrangles,   modifyId, -1 );
4246   createMenu( SMESHOp::OpSplitVolumes,           modifyId, -1 );
4247   createMenu( SMESHOp::OpSplitBiQuadratic,       modifyId, -1 );
4248   createMenu( SMESHOp::OpSmoothing,              modifyId, -1 );
4249   createMenu( SMESHOp::OpPatternMapping,         modifyId, -1 );
4250
4251   createMenu( SMESHOp::OpMinimumDistance,  measureId,   -1 );
4252   createMenu( SMESHOp::OpBoundingBox,      measureId,   -1 );
4253   createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4254   createMenu( SMESHOp::OpPropertiesArea,   basicPropId, -1 );
4255   createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4256   createMenu( SMESHOp::OpUpdate,           viewId,      -1 );
4257
4258   connect( nodeMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4259   connect( edgeMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4260   connect( faceMenu,   SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4261   connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4262
4263   // ----- create toolbars --------------
4264   int meshTb       = createTool( tr( "TB_MESH" ),      QString( "SMESHMeshToolbar" ) ),
4265       info         = createTool( tr( "TB_INFO" ),      QString( "SMESHInformationToolbar" ) ),
4266       groupTb      = createTool( tr( "TB_GROUP" ),     QString( "SMESHGroupToolbar" ) ),
4267       ctrl0dTb     = createTool( tr( "TB_CTRL0D" ),    QString( "SMESHNodeControlsToolbar" ) ),
4268       ctrl1dTb     = createTool( tr( "TB_CTRL1D" ),    QString( "SMESHEdgeControlsToolbar" ) ),
4269       ctrl2dTb     = createTool( tr( "TB_CTRL2D" ),    QString( "SMESHFaceControlsToolbar" ) ),
4270       ctrl3dTb     = createTool( tr( "TB_CTRL3D" ),    QString( "SMESHVolumeControlsToolbar" ) ),
4271       addElemTb    = createTool( tr( "TB_ADD" ),       QString( "SMESHAddElementToolbar" ) ),
4272       addNonElemTb = createTool( tr( "TB_ADDNON" ),    QString( "SMESHAddElementToolbar" ) ),
4273       remTb        = createTool( tr( "TB_REM" ),       QString( "SMESHRemoveToolbar" ) ),
4274     //renumbTb     = createTool( tr( "TB_RENUMBER" ),  QString( "SMESHRenumberingToolbar" ) ),
4275       transformTb  = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4276       modifyTb     = createTool( tr( "TB_MODIFY" ),    QString( "SMESHModificationToolbar" ) ),
4277       measuremTb   = createTool( tr( "TB_MEASUREM" ),  QString( "SMESHMeasurementsToolbar" ) ),
4278       dispModeTb   = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4279
4280   createTool( SMESHOp::OpCreateMesh,        meshTb );
4281   createTool( SMESHOp::OpCreateSubMesh,     meshTb );
4282   createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4283   createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4284   createTool( SMESHOp::OpCopyMesh,          meshTb );
4285   createTool( separator(),                  meshTb );
4286   createTool( SMESHOp::OpCompute,           meshTb );
4287   createTool( SMESHOp::OpPreCompute,        meshTb );
4288   createTool( SMESHOp::OpEvaluate,          meshTb );
4289   createTool( SMESHOp::OpMeshOrder,         meshTb );
4290
4291   createTool( SMESHOp::OpCreateGroup,         groupTb );
4292   createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4293   createTool( SMESHOp::OpConstructGroup,      groupTb );
4294   createTool( SMESHOp::OpEditGroup,           groupTb );
4295
4296   createTool( SMESHOp::OpMeshInformation,    info );
4297   //createTool( SMESHOp::OpStdInfo, meshTb );
4298   //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4299   createTool( SMESHOp::OpFindElementByPoint, info );
4300
4301   createTool( SMESHOp::OpFreeNode,  ctrl0dTb );
4302   createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4303   //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4304
4305   createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4306   createTool( SMESHOp::OpLength,     ctrl1dTb );
4307   createTool( SMESHOp::OpConnection, ctrl1dTb );
4308   createTool( SMESHOp::OpEqualEdge,  ctrl1dTb );
4309
4310   createTool( SMESHOp::OpFreeEdge,            ctrl2dTb );
4311   createTool( SMESHOp::OpFreeFace,            ctrl2dTb );
4312   createTool( SMESHOp::OpBareBorderFace,      ctrl2dTb );
4313   createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4314   createTool( SMESHOp::OpLength2D,            ctrl2dTb );
4315   createTool( SMESHOp::OpConnection2D,        ctrl2dTb );
4316   createTool( SMESHOp::OpArea,                ctrl2dTb );
4317   createTool( SMESHOp::OpTaper,               ctrl2dTb );
4318   createTool( SMESHOp::OpAspectRatio,         ctrl2dTb );
4319   createTool( SMESHOp::OpMinimumAngle,        ctrl2dTb );
4320   createTool( SMESHOp::OpWarpingAngle,        ctrl2dTb );
4321   createTool( SMESHOp::OpSkew,                ctrl2dTb );
4322   createTool( SMESHOp::OpMaxElementLength2D,  ctrl2dTb );
4323   createTool( SMESHOp::OpEqualFace,           ctrl2dTb );
4324   createTool( SMESHOp::OpDeflection2D,        ctrl2dTb );
4325
4326   createTool( SMESHOp::OpAspectRatio3D,         ctrl3dTb );
4327   createTool( SMESHOp::OpVolume,                ctrl3dTb );
4328   createTool( SMESHOp::OpMaxElementLength3D,    ctrl3dTb );
4329   createTool( SMESHOp::OpBareBorderVolume,      ctrl3dTb );
4330   createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4331   createTool( SMESHOp::OpEqualVolume,           ctrl3dTb );
4332
4333   createTool( SMESHOp::OpNode,              addElemTb );
4334   createTool( SMESHOp::OpElem0D,            addElemTb );
4335   createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4336   createTool( SMESHOp::OpBall,              addElemTb );
4337   createTool( SMESHOp::OpEdge,              addElemTb );
4338   createTool( SMESHOp::OpTriangle,          addElemTb );
4339   createTool( SMESHOp::OpQuadrangle,        addElemTb );
4340   createTool( SMESHOp::OpPolygon,           addElemTb );
4341   createTool( SMESHOp::OpTetrahedron,       addElemTb );
4342   createTool( SMESHOp::OpHexahedron,        addElemTb );
4343   createTool( SMESHOp::OpPentahedron,       addElemTb );
4344   createTool( SMESHOp::OpPyramid,           addElemTb );
4345   createTool( SMESHOp::OpHexagonalPrism,    addElemTb );
4346   createTool( SMESHOp::OpPolyhedron,        addElemTb );
4347
4348   createTool( SMESHOp::OpQuadraticEdge,          addNonElemTb );
4349   createTool( SMESHOp::OpQuadraticTriangle,      addNonElemTb );
4350   createTool( SMESHOp::OpBiQuadraticTriangle,    addNonElemTb );
4351   createTool( SMESHOp::OpQuadraticQuadrangle,    addNonElemTb );
4352   createTool( SMESHOp::OpBiQuadraticQuadrangle,  addNonElemTb );
4353   createTool( SMESHOp::OpQuadraticPolygon,       addNonElemTb );
4354   createTool( SMESHOp::OpQuadraticTetrahedron,   addNonElemTb );
4355   createTool( SMESHOp::OpQuadraticPyramid,       addNonElemTb );
4356   createTool( SMESHOp::OpQuadraticPentahedron,   addNonElemTb );
4357   createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4358   createTool( SMESHOp::OpQuadraticHexahedron,    addNonElemTb );
4359   createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4360
4361   createTool( SMESHOp::OpRemoveNodes,       remTb );
4362   createTool( SMESHOp::OpRemoveElements,    remTb );
4363   createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4364   createTool( SMESHOp::OpClearMesh,         remTb );
4365
4366   //createTool( SMESHOp::OpRenumberingNodes,    renumbTb );
4367   //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4368
4369   createTool( SMESHOp::OpMergeNodes,     transformTb );
4370   createTool( SMESHOp::OpMergeElements,  transformTb );
4371   createTool( SMESHOp::OpTranslation,    transformTb );
4372   createTool( SMESHOp::OpRotation,       transformTb );
4373   createTool( SMESHOp::OpSymmetry,       transformTb );
4374   createTool( SMESHOp::OpScale,          transformTb );
4375   createTool( SMESHOp::OpOffset,         transformTb );
4376   createTool( SMESHOp::OpSewing,         transformTb );
4377   createTool( SMESHOp::OpDuplicateNodes, transformTb );
4378
4379   createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4380   createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4381   createTool( SMESHOp::OpExtrusion,              modifyTb );
4382   createTool( SMESHOp::OpExtrusionAlongAPath,    modifyTb );
4383   createTool( SMESHOp::OpRevolution,             modifyTb );
4384   createTool( SMESHOp::OpOrientation,            modifyTb );
4385   createTool( SMESHOp::OpReorientFaces,          modifyTb );
4386   createTool( SMESHOp::OpMoveNode,               modifyTb );
4387   createTool( SMESHOp::OpDiagonalInversion,      modifyTb );
4388   createTool( SMESHOp::OpUnionOfTwoTriangle,     modifyTb );
4389   createTool( SMESHOp::OpUnionOfTriangles,       modifyTb );
4390   createTool( SMESHOp::OpCuttingOfQuadrangles,   modifyTb );
4391   createTool( SMESHOp::OpSplitVolumes,           modifyTb );
4392   createTool( SMESHOp::OpSplitBiQuadratic,       modifyTb );
4393   createTool( SMESHOp::OpSmoothing,              modifyTb );
4394   createTool( SMESHOp::OpPatternMapping,         modifyTb );
4395
4396   createTool( SMESHOp::OpMinimumDistance, measuremTb );
4397
4398   createTool( SMESHOp::OpUpdate, dispModeTb );
4399
4400   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
4401   QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4402
4403   myRules.clear();
4404   QString
4405     OB      = "'ObjectBrowser'",
4406     View    = "'" + SVTK_Viewer::Type() + "'",
4407     pat     = "'%1'",
4408     mesh    = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4409     group   = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4410     hypo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4411     algo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4412     smesh   = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4413     elems   = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4414     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4415     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4416     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4417     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4418     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4419     arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4420     subMesh      = elems,
4421     mesh_part    = mesh + " " + subMesh + " " + group,
4422     mesh_group   = mesh + " " + group,
4423     mesh_submesh = mesh + " " + subMesh,
4424     hyp_alg      = hypo + " " + algo;
4425
4426   // popup for object browser
4427   QString
4428     isInvisible("not( isVisible )"),
4429     isEmpty("numberOfNodes = 0"),
4430     isNotEmpty("numberOfNodes <> 0"),
4431
4432     // has nodes, edges, etc in VISIBLE! actor
4433     hasNodes("(numberOfNodes > 0 ) && hasActor"),
4434     hasElems("(count( elemTypes ) > 0)"),
4435     hasDifferentElems("(count( elemTypes ) > 1)"),
4436     hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4437     hasBalls("({'BallElem'} in elemTypes)"),
4438     hasElems0d("({'Elem0d'} in elemTypes)"),
4439     hasEdges("({'Edge'} in elemTypes)"),
4440     hasFaces("({'Face'} in elemTypes)"),
4441     hasVolumes("({'Volume'} in elemTypes)"),
4442     hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4443
4444   createPopupItem( SMESHOp::OpFileInformation,   OB, mesh, "&& selcount=1 && isImported" );
4445   createPopupItem( SMESHOp::OpCreateSubMesh,     OB, mesh, "&& hasGeomReference");
4446   createPopupItem( SMESHOp::OpEditMesh,          OB, mesh, "&& selcount=1" );
4447   createPopupItem( SMESHOp::OpEditSubMesh,       OB, subMesh, "&& selcount=1 && hasGeomReference" );
4448   createPopupItem( SMESHOp::OpEditGroup,         OB, group );
4449   createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4450
4451   popupMgr()->insert( separator(), -1, 0 );
4452   createPopupItem( SMESHOp::OpCompute,           OB, mesh, "&& selcount=1 && isComputable" );
4453   createPopupItem( SMESHOp::OpComputeSubMesh,    OB, subMesh, "&& selcount=1 && isComputable" );
4454   createPopupItem( SMESHOp::OpPreCompute,        OB, mesh, "&& selcount=1 && isPreComputable" );
4455   createPopupItem( SMESHOp::OpEvaluate,          OB, mesh, "&& selcount=1 && isComputable" );
4456   createPopupItem( SMESHOp::OpMeshOrder,         OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4457   createPopupItem( SMESHOp::OpUpdate,            OB, mesh_part );
4458   createPopupItem( SMESHOp::OpMeshInformation,   OB, mesh_part );
4459   createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4460   createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4461   popupMgr()->insert( separator(), -1, 0 );
4462   createPopupItem( SMESHOp::OpCreateGroup,       OB, mesh, "&& selcount=1" );
4463   createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4464   createPopupItem( SMESHOp::OpConstructGroup,    OB, subMesh );
4465   popupMgr()->insert( separator(), -1, 0 );
4466   createPopupItem( SMESHOp::OpEditHypothesis,    OB, hypo, "&& isEditableHyp");
4467   createPopupItem( SMESHOp::OpUnassign,          OB, hyp_alg );
4468   popupMgr()->insert( separator(), -1, 0 );
4469   createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4470   createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4471   popupMgr()->insert( separator(), -1, 0 );
4472   createPopupItem( SMESHOp::OpClearMesh,              OB, mesh );
4473   //popupMgr()->insert( separator(), -1, 0 );
4474
4475   QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4476   QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4477   QString only_one_2D        = only_one_non_empty + " && dim>1";
4478
4479   int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 );        // EXPORT submenu
4480   createPopupItem( SMESHOp::OpPopupExportMED,  OB, mesh_group, multiple_non_empty, anId );
4481   createPopupItem( SMESHOp::OpPopupExportUNV,  OB, mesh_group, only_one_non_empty, anId );
4482   createPopupItem( SMESHOp::OpPopupExportSTL,  OB, mesh_group, only_one_2D, anId );
4483 #ifdef WITH_CGNS
4484   createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4485 #endif
4486   createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4487   createPopupItem( SMESHOp::OpPopupExportGMF,  OB, mesh_group, only_one_non_empty, anId );
4488   createPopupItem( SMESHOp::OpPopupExportDAT,  OB, mesh_group, only_one_non_empty, anId );
4489   createPopupItem( SMESHOp::OpDelete,          OB, mesh_part + " " + hyp_alg );
4490   createPopupItem( SMESHOp::OpDeleteGroup,     OB, group );
4491
4492   anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 );        // IMPORT submenu
4493   createPopupItem( SMESHOp::OpPopupImportMED,  OB, smesh, "", anId );
4494   createPopupItem( SMESHOp::OpPopupImportUNV,  OB, smesh, "", anId );
4495   createPopupItem( SMESHOp::OpPopupImportSTL,  OB, smesh, "", anId );
4496 #ifdef WITH_CGNS
4497   createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4498 #endif
4499   createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4500   createPopupItem( SMESHOp::OpPopupImportGMF,  OB, smesh, "", anId );
4501   createPopupItem( SMESHOp::OpPopupImportDAT,  OB, smesh, "", anId );
4502   popupMgr()->insert( separator(), -1, 0 );
4503
4504   // popup for viewer
4505   createPopupItem( SMESHOp::OpEditGroup,            View, group );
4506   createPopupItem( SMESHOp::OpAddElemGroupPopup,    View, elems, "&& guiState = 800" );
4507   createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4508
4509   popupMgr()->insert( separator(), -1, 0 );
4510   createPopupItem( SMESHOp::OpUpdate,             View, mesh_part );
4511   createPopupItem( SMESHOp::OpMeshInformation,    View, mesh_part );
4512   createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4513   createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4514   popupMgr()->insert( separator(), -1, 0 );
4515
4516   createPopupItem( SMESHOp::OpAutoColor,        OB + " " + View, mesh, "&& (not isAutoColor)" );
4517   createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4518   popupMgr()->insert( separator(), -1, 0 );
4519
4520   QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4521   QString aType = QString( "%1type in {%2}" ).arg( lc );
4522   aType = aType.arg( mesh_part );
4523   QString aMeshInVTK = aClient + "&&" + aType;
4524
4525   aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4526   QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4527   QString aSelCount = QString( "%1 > 0" ).arg( dc );
4528
4529   //-------------------------------------------------
4530   // Numbering
4531   //-------------------------------------------------
4532   anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4533
4534   popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4535   popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4536   popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4537
4538   popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4539   popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4540   popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4541
4542   popupMgr()->insert( separator(), -1, -1 );
4543
4544   //-------------------------------------------------
4545   // Display Mode
4546   //-------------------------------------------------
4547   anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4548
4549   popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4550   popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4551   popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4552
4553   popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4554   popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4555   popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4556
4557   popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4558   popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4559   popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4560
4561   popupMgr()->insert( separator(), anId, -1 );
4562
4563   popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4564   popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4565   popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4566
4567   //-------------------------------------------------
4568   // Display Entity
4569   //-------------------------------------------------
4570   QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4571
4572   anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4573
4574   popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4575   popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4576   popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4577
4578   popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4579   popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4580   popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4581
4582   popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4583   popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4584   popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4585
4586   popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4587   popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4588   popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4589
4590   popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4591   popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4592   popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4593
4594   popupMgr()->insert( separator(), anId, -1 );
4595
4596   popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4597   popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4598
4599   popupMgr()->insert( separator(), anId, -1 );
4600
4601   popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4602   popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4603
4604
4605   //-------------------------------------------------
4606   // Representation of the 2D Quadratic elements
4607   //-------------------------------------------------
4608   anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4609   popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4610   popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4611   popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4612
4613   popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4614   popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4615   popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4616
4617   //-------------------------------------------------
4618   // Orientation of faces
4619   //-------------------------------------------------
4620   popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4621   popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4622   popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4623
4624   //-------------------------------------------------
4625   // Color / Size
4626   //-------------------------------------------------
4627   popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4628   popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4629
4630   //-------------------------------------------------
4631   // Transparency
4632   //-------------------------------------------------
4633   popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4634   popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4635
4636   //-------------------------------------------------
4637   // Controls
4638   //-------------------------------------------------
4639   QString
4640     aMeshInVtkHasNodes   = aMeshInVTK + "&&" + hasNodes,
4641     aMeshInVtkHasEdges   = aMeshInVTK + "&&" + hasEdges,
4642     aMeshInVtkHasFaces   = aMeshInVTK + "&&" + hasFaces,
4643     aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4644
4645   anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4646
4647   popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4648   popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4649
4650   popupMgr()->insert( separator(), anId, -1 );
4651
4652   int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4653
4654   popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4655   popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4656   popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4657
4658   popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4659   popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4660   popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4661
4662   // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4663   // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4664   // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4665
4666   aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4667
4668   popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4669   popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4670   popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4671
4672   popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4673   popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4674   popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4675
4676   popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4677   popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4678   popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4679   popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4680   popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4681   popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4682
4683   aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4684
4685   popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4686   popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4687   popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4688
4689   popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4690   popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4691                                        QtxPopupMgr::VisibleRule );
4692   popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4693
4694   popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4695   popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4696   popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4697
4698   popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4699   popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4700   popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4701
4702   popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4703   popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4704   popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4705
4706   popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4707   popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4708   popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4709
4710   popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4711   popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4712   popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4713
4714   popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4715   popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4716   popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4717
4718   popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4719   popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4720   popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4721
4722   popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4723   popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4724   popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4725
4726   popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4727   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4728   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4729
4730   popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4731   popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4732   popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4733
4734   popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4735   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4736   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4737
4738   popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4739   popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4740   popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4741
4742   popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4743   popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4744   popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4745
4746   aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4747
4748   popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D  ), aSubId, -1 );
4749   popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4750   popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4751
4752   popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4753   popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4754   popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4755
4756   popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4757   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4758   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4759
4760   popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4761   popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4762   popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4763
4764   popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4765   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4766   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4767
4768   popupMgr()->insert ( action( SMESHOp::OpEqualVolume  ), aSubId, -1 );
4769   popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4770   popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4771
4772   popupMgr()->insert( separator(), anId, -1 );
4773
4774   popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4775   popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4776   popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4777   popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4778   popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4779
4780   popupMgr()->insert( separator(), anId, -1 );
4781
4782   aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4783
4784   popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4785   popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4786
4787   popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4788   popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4789   popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4790
4791 #ifndef DISABLE_PLOT2DVIEWER
4792   popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4793   popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4794 #endif
4795
4796   //-------------------------------------------------
4797   // Show / Hide
4798   //-------------------------------------------------
4799   popupMgr()->insert( separator(), -1, -1 );
4800   QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4801     aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4802   popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4803   popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4804
4805   popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4806   popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4807
4808   popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4809   popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4810
4811   popupMgr()->insert( separator(), -1, -1 );
4812
4813   //-------------------------------------------------
4814   // Clipping
4815   //-------------------------------------------------
4816   popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4817   popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4818
4819   popupMgr()->insert( separator(), -1, -1 );
4820
4821   popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4822   popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4823   popupMgr()->insert( separator(), -1, -1 );
4824
4825   connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4826            this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4827
4828   connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4829            this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4830 }
4831
4832 //================================================================================
4833 /*!
4834  * \brief Return true if SMESH or GEOM objects are selected.
4835  * Is called form LightApp_Module::activateModule() which clear selection if
4836  * not isSelectionCompatible()
4837  */
4838 //================================================================================
4839
4840 bool SMESHGUI::isSelectionCompatible()
4841 {
4842   bool isCompatible = true;
4843   SALOME_ListIO selected;
4844   if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4845     Sel->selectedObjects( selected );
4846
4847   SALOME_ListIteratorOfListIO It( selected );
4848   for ( ; isCompatible && It.More(); It.Next())
4849     isCompatible =
4850       ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4851       ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4852
4853   return isCompatible;
4854 }
4855
4856
4857 bool SMESHGUI::reusableOperation( const int id )
4858 {
4859   // compute, evaluate and precompute are not reusable operations
4860   return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4861 }
4862
4863 bool SMESHGUI::activateModule( SUIT_Study* study )
4864 {
4865   bool res = SalomeApp_Module::activateModule( study );
4866
4867   setMenuShown( true );
4868   setToolShown( true );
4869
4870   // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4871   PyGILState_STATE gstate = PyGILState_Ensure();
4872   PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4873   if ( !pluginsmanager ) {
4874     PyErr_Print();
4875   }
4876   else {
4877     PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4878     if ( !result )
4879       PyErr_Print();
4880     Py_XDECREF(result);
4881   }
4882   PyGILState_Release(gstate);
4883   // end of SMESH plugins loading
4884
4885   // Reset actions accelerator keys
4886   action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4887
4888   //  0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4889   GetSMESHGen()->UpdateStudy();
4890
4891   // get all view currently opened in the study and connect their signals  to
4892   // the corresponding slots of the class.
4893   SUIT_Desktop* aDesk = study->application()->desktop();
4894   if ( aDesk ) {
4895     QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4896     SUIT_ViewWindow* wnd;
4897     foreach ( wnd, wndList )
4898       connectView( wnd );
4899   }
4900
4901   Py_XDECREF(pluginsmanager);
4902   return res;
4903 }
4904
4905 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4906 {
4907   setMenuShown( false );
4908   setToolShown( false );
4909
4910   EmitSignalCloseAllDialogs();
4911
4912   // Unset actions accelerator keys
4913   action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4914
4915   return SalomeApp_Module::deactivateModule( study );
4916 }
4917
4918 void SMESHGUI::studyClosed( SUIT_Study* s )
4919 {
4920   if( !s )
4921     return;
4922   SMESH::RemoveVisuData();
4923   SalomeApp_Module::studyClosed( s );
4924 }
4925
4926 void SMESHGUI::OnGUIEvent()
4927 {
4928   const QObject* obj = sender();
4929   if ( !obj || !obj->inherits( "QAction" ) )
4930     return;
4931   int id = actionId((QAction*)obj);
4932   if ( id != -1 )
4933     OnGUIEvent( id );
4934 }
4935
4936 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4937 {
4938   if ( CORBA::is_nil( myComponentSMESH ) )
4939   {
4940     SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4941     return aGUI.myComponentSMESH;
4942   }
4943   return myComponentSMESH;
4944 }
4945
4946 QString SMESHGUI::engineIOR() const
4947 {
4948   CORBA::ORB_var anORB = getApp()->orb();
4949   CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4950   return QString( anIOR.in() );
4951 }
4952
4953 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4954 {
4955   SalomeApp_Module::contextMenuPopup( client, menu, title );
4956   SALOME_ListIO lst;
4957   selectionMgr()->selectedObjects( lst );
4958   if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4959     Handle(SALOME_InteractiveObject) io = lst.First();
4960     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4961     _PTR(Study) study = appStudy->studyDS();
4962     _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4963     if ( obj ) {
4964       QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4965       while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4966           aName.remove( (aName.length() - 1), 1 );
4967       title = aName;
4968     }
4969   }
4970 }
4971
4972 LightApp_Selection* SMESHGUI::createSelection() const
4973 {
4974   return new SMESHGUI_Selection();
4975 }
4976
4977 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4978 {
4979   aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4980   aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4981 #ifndef DISABLE_PYCONSOLE
4982   aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4983 #endif
4984 }
4985
4986 void SMESHGUI::viewManagers( QStringList& list ) const
4987 {
4988   list.append( SVTK_Viewer::Type() );
4989 }
4990
4991 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4992 {
4993   if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4994     SMESH::UpdateSelectionProp( this );
4995
4996     QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4997     for(int i = 0; i < aViews.count() ; i++){
4998       SUIT_ViewWindow *sf = aViews[i];
4999       connectView( sf );
5000     }
5001     EmitSignalActivatedViewManager();
5002   }
5003 }
5004
5005 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5006 {
5007   if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5008     myClippingPlaneInfoMap.erase( theViewManager );
5009 }
5010
5011 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5012 {
5013   theActor->AddObserver( SMESH::DeleteActorEvent,
5014                          myEventCallbackCommand.GetPointer(),
5015                          myPriority );
5016 }
5017
5018 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5019                               unsigned long theEvent,
5020                               void* theClientData,
5021                               void* theCallData )
5022 {
5023   if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5024     if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5025       if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5026         SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5027         SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5028         for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5029           SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5030           SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5031           for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5032             SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5033             std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5034             SMESH::TActorList::iterator anIter3 = anActorList.begin();
5035             for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5036               if( anActor == *anIter3 ) {
5037                 anActorList.erase( anIter3 );
5038                 break;
5039               }
5040             }
5041           }
5042         }
5043       }
5044     }
5045   }
5046 }
5047
5048 void SMESHGUI::createPreferences()
5049 {
5050   // General tab ------------------------------------------------------------------------
5051   int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5052
5053   int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5054   setPreferenceProperty( autoUpdate, "columns", 2 );
5055   int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5056   setPreferenceProperty( lim, "min",  0 );
5057   setPreferenceProperty( lim, "max",  100000000 );
5058   setPreferenceProperty( lim, "step", 1000 );
5059   setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5060   addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5061
5062   int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5063   setPreferenceProperty( dispgroup, "columns", 2 );
5064   int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5065   QStringList modes;
5066   modes.append( tr("MEN_WIRE") );
5067   modes.append( tr("MEN_SHADE") );
5068   modes.append( tr("MEN_NODES") );
5069   modes.append( tr("MEN_SHRINK") );
5070   QList<QVariant> indices;
5071   indices.append( 0 );
5072   indices.append( 1 );
5073   indices.append( 2 );
5074   indices.append( 3 );
5075   setPreferenceProperty( dispmode, "strings", modes );
5076   setPreferenceProperty( dispmode, "indexes", indices );
5077
5078   int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5079   setPreferenceProperty( arcgroup, "columns", 2 );
5080   int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5081   QStringList quadraticModes;
5082   quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5083   quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5084   indices.clear();
5085   indices.append( 0 );
5086   indices.append( 1 );
5087   setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5088   setPreferenceProperty( quadraticmode, "indexes", indices );
5089
5090   int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5091                               "SMESH", "max_angle" );
5092   setPreferenceProperty( maxAngle, "min", 1 );
5093   setPreferenceProperty( maxAngle, "max", 90 );
5094
5095   int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5096   setPreferenceProperty( qaGroup, "columns", 2 );
5097   addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5098   addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5099   int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5100   setPreferenceProperty( prec, "min", 0 );
5101   setPreferenceProperty( prec, "max", 100 );
5102   int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5103   setPreferenceProperty( doubleNodesTol, "precision", 10 );
5104   setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5105   setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5106   setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5107
5108   /*
5109   int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5110   setPreferenceProperty( cinc, "min", 0 );
5111   setPreferenceProperty( cinc, "max", 5 );
5112   */
5113
5114   int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5115   setPreferenceProperty( exportgroup, "columns", 2 );
5116   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5117   addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5118   //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5119
5120   int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5121   setPreferenceProperty( computeGroup, "columns", 2 );
5122   int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5123   modes.clear();
5124   modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5125   modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5126   modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5127   indices.clear();
5128   indices.append( 0 );
5129   indices.append( 1 );
5130   indices.append( 2 );
5131   setPreferenceProperty( notifyMode, "strings", modes );
5132   setPreferenceProperty( notifyMode, "indexes", indices );
5133
5134   int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5135   setPreferenceProperty( infoGroup, "columns", 2 );
5136   int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5137   modes.clear();
5138   modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5139   modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5140   indices.clear();
5141   indices.append( 0 );
5142   indices.append( 1 );
5143   setPreferenceProperty( elemInfo, "strings", modes );
5144   setPreferenceProperty( elemInfo, "indexes", indices );
5145   int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5146   setPreferenceProperty( nodesLim, "min", 0 );
5147   setPreferenceProperty( nodesLim, "max", 10000000 );
5148   setPreferenceProperty( nodesLim, "step", 10000 );
5149   setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5150   int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5151   setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5152   setPreferenceProperty( ctrlLim, "min", 0 );
5153   setPreferenceProperty( ctrlLim, "max", 10000000 );
5154   setPreferenceProperty( ctrlLim, "step", 1000 );
5155   addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5156   addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5157   addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5158   addPreference( tr( "PREF_DUMP_ADD_INFO"  ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5159   addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5160
5161   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5162   setPreferenceProperty( segGroup, "columns", 2 );
5163   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5164                               "SMESH", "segmentation" );
5165   setPreferenceProperty( segLen, "min", 1 );
5166   setPreferenceProperty( segLen, "max", 10000000 );
5167   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5168                              "SMESH", "nb_segments_per_edge" );
5169   setPreferenceProperty( nbSeg, "min", 1 );
5170   setPreferenceProperty( nbSeg, "max", 10000000 );
5171
5172   int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5173   addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5174                  "SMESH", "forget_mesh_on_hyp_modif" );
5175
5176
5177   // Quantities with individual precision settings
5178   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5179   setPreferenceProperty( precGroup, "columns", 2 );
5180
5181   const int nbQuantities = 6;
5182   int precs[nbQuantities], ii = 0;
5183   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5184                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5185   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5186                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5187   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5188                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5189   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5190                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5191   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5192                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5193   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5194                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5195
5196   // Set property for precision value for spinboxes
5197   for ( ii = 0; ii < nbQuantities; ii++ ){
5198     setPreferenceProperty( precs[ii], "min", -14 );
5199     setPreferenceProperty( precs[ii], "max", 14 );
5200     setPreferenceProperty( precs[ii], "precision", 2 );
5201   }
5202
5203   int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5204   setPreferenceProperty( previewGroup, "columns", 2 );
5205   int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5206   setPreferenceProperty( chunkSize, "min",  1 );
5207   setPreferenceProperty( chunkSize, "max",  1000 );
5208   setPreferenceProperty( chunkSize, "step", 50 );
5209
5210   int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5211   addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5212
5213   // Mesh tab ------------------------------------------------------------------------
5214   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5215   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5216   setPreferenceProperty( nodeGroup, "columns", 3 );
5217
5218   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5219
5220   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5221
5222   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5223   QList<QVariant> aMarkerTypeIndicesList;
5224   QList<QVariant> aMarkerTypeIconsList;
5225   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5226     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5227     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5228     aMarkerTypeIndicesList << i;
5229     aMarkerTypeIconsList << pixmap;
5230   }
5231   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5232   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
5233
5234   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5235
5236   QList<QVariant> aMarkerScaleIndicesList;
5237   QStringList     aMarkerScaleValuesList;
5238   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5239     aMarkerScaleIndicesList << i;
5240     //aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5241     aMarkerScaleValuesList  << QString::number( i );
5242   }
5243   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5244   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5245
5246   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5247   //setPreferenceProperty( elemGroup, "columns", 2 );
5248
5249   int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5250   setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5251   ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5252   setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5253   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5254   addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5255   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5256   addPreference( tr( "PREF_WIREFRAME"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5257   addPreference( tr( "PREF_PREVIEW_COLOR"  ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5258
5259
5260   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5261   setPreferenceProperty( grpGroup, "columns", 2 );
5262
5263   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5264   addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5265
5266   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5267                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5268   /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5269                              LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5270   double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5271                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5272   double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5273                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5274   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
5275                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
5276   int outW  = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5277                              LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5278   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5279                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5280
5281   setPreferenceProperty( size0d, "min", 1 );
5282   setPreferenceProperty( size0d, "max", 10 );
5283
5284  // setPreferenceProperty( ballSize, "min", 1 );
5285  // setPreferenceProperty( ballSize, "max", 10 );
5286
5287   setPreferenceProperty( ballDiameter, "min", 1e-7 );
5288   setPreferenceProperty( ballDiameter, "max", 1e9 );
5289   setPreferenceProperty( ballDiameter, "step", 0.1 );
5290
5291   setPreferenceProperty( ballScale, "min", 1e-2 );
5292   setPreferenceProperty( ballScale, "max", 1e7 );
5293   setPreferenceProperty( ballScale, "step", 0.5 );
5294
5295   setPreferenceProperty( elemW, "min", 1 );
5296   setPreferenceProperty( elemW, "max", 5 );
5297
5298   setPreferenceProperty( outW, "min", 1 );
5299   setPreferenceProperty( outW, "max", 5 );
5300
5301   setPreferenceProperty( shrink, "min", 0 );
5302   setPreferenceProperty( shrink, "max", 100 );
5303
5304   int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5305   setPreferenceProperty( numGroup, "columns", 2 );
5306
5307   addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5308   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5309
5310   addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5311   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5312
5313   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5314   setPreferenceProperty( orientGroup, "columns", 1 );
5315
5316   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5317   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5318
5319   setPreferenceProperty( orientScale, "min", 0.05 );
5320   setPreferenceProperty( orientScale, "max", 0.5 );
5321   setPreferenceProperty( orientScale, "step", 0.05 );
5322
5323   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5324
5325   // Selection tab ------------------------------------------------------------------------
5326   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5327
5328   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5329   setPreferenceProperty( selGroup, "columns", 2 );
5330
5331   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5332   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5333
5334   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5335   setPreferenceProperty( preGroup, "columns", 2 );
5336
5337   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5338
5339   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5340   setPreferenceProperty( precSelGroup, "columns", 2 );
5341
5342   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5343   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5344   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5345
5346   int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5347   setPreferenceProperty( sinc, "min", 0 );
5348   setPreferenceProperty( sinc, "max", 5 );
5349
5350   // Scalar Bar tab ------------------------------------------------------------------------
5351   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5352   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5353   setPreferenceProperty( fontGr, "columns", 2 );
5354
5355   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5356   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5357
5358   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5359   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5360
5361   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5362   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5363
5364   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5365   setPreferenceProperty( numcol, "min", 2 );
5366   setPreferenceProperty( numcol, "max", 256 );
5367
5368   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5369   setPreferenceProperty( numlab, "min", 2 );
5370   setPreferenceProperty( numlab, "max", 65 );
5371
5372   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5373   setPreferenceProperty( orientGr, "columns", 2 );
5374   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5375   QStringList orients;
5376   orients.append( tr( "SMESH_VERTICAL" ) );
5377   orients.append( tr( "SMESH_HORIZONTAL" ) );
5378   indices.clear(); indices.append( 0 ); indices.append( 1 );
5379   setPreferenceProperty( orient, "strings", orients );
5380   setPreferenceProperty( orient, "indexes", indices );
5381
5382   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5383   setPreferenceProperty( posVSizeGr, "columns", 2 );
5384   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5385   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5386   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5387   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5388   setPreferenceProperty( xv, "step", 0.1 );
5389   setPreferenceProperty( xv, "min", 0.0 );
5390   setPreferenceProperty( xv, "max", 1.0 );
5391   setPreferenceProperty( yv, "step", 0.1 );
5392   setPreferenceProperty( yv, "min", 0.0 );
5393   setPreferenceProperty( yv, "max", 1.0 );
5394   setPreferenceProperty( wv, "step", 0.1 );
5395   setPreferenceProperty( wv, "min", 0.0 );
5396   setPreferenceProperty( wv, "max", 1.0 );
5397   setPreferenceProperty( hv, "min", 0.0 );
5398   setPreferenceProperty( hv, "max", 1.0 );
5399   setPreferenceProperty( hv, "step", 0.1 );
5400
5401   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5402   setPreferenceProperty( posHSizeGr, "columns", 2 );
5403   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5404   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5405   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5406   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5407   setPreferenceProperty( xv, "min", 0.0 );
5408   setPreferenceProperty( xv, "max", 1.0 );
5409   setPreferenceProperty( xv, "step", 0.1 );
5410   setPreferenceProperty( xh, "min", 0.0 );
5411   setPreferenceProperty( xh, "max", 1.0 );
5412   setPreferenceProperty( xh, "step", 0.1 );
5413   setPreferenceProperty( yh, "min", 0.0 );
5414   setPreferenceProperty( yh, "max", 1.0 );
5415   setPreferenceProperty( yh, "step", 0.1 );
5416   setPreferenceProperty( wh, "min", 0.0 );
5417   setPreferenceProperty( wh, "max", 1.0 );
5418   setPreferenceProperty( wh, "step", 0.1 );
5419   setPreferenceProperty( hh, "min", 0.0 );
5420   setPreferenceProperty( hh, "max", 1.0 );
5421   setPreferenceProperty( hh, "step", 0.1 );
5422
5423   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5424   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5425   setPreferenceProperty( distributionGr, "columns", 3 );
5426   QStringList types;
5427   types.append( tr( "SMESH_MONOCOLOR" ) );
5428   types.append( tr( "SMESH_MULTICOLOR" ) );
5429   indices.clear(); indices.append( 0 ); indices.append( 1 );
5430   setPreferenceProperty( coloringType, "strings", types );
5431   setPreferenceProperty( coloringType, "indexes", indices );
5432   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5433
5434 }
5435
5436 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5437 {
5438   if ( sect=="SMESH" ) {
5439     float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5440     float aTol = 1.00000009999999;
5441     std::string aWarning;
5442     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5443
5444     if ( name== "selection_object_color" ||
5445          name=="selection_element_color" ||
5446          name==        "highlight_color" ||
5447          name=="selection_precision_node"    ||
5448          name=="selection_precision_element" ||
5449          name=="selection_precision_object"   ||
5450          name=="selection_increment")
5451     {
5452       SMESH::UpdateSelectionProp( this );
5453     }
5454     else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5455     {
5456       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x",     sbX1);
5457       sbW  = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5458       if ( sbX1+sbW > aTol ) {
5459         aWarning = "Origin and Size Vertical: X+Width > 1\n";
5460         sbX1 = 0.01;
5461         sbW  = 0.08;
5462         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x",     sbX1);
5463         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5464       }
5465     }
5466     else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5467     {
5468       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y",     sbY1);
5469       sbH  = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5470       if ( sbY1 + sbH > aTol ) {
5471         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5472         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y",     sbY1);
5473         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5474       }
5475     }
5476     else if (name == "scalar_bar_horizontal_x" || name ==  "scalar_bar_horizontal_width")
5477     {
5478       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x",     sbX1);
5479       sbW  = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5480       if ( sbX1 + sbW > aTol ) {
5481         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5482         sbX1=0.1;
5483         sbW =0.08;
5484         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5485         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5486       }
5487     }
5488     else if (name == "scalar_bar_horizontal_y" || name ==  "scalar_bar_horizontal_height")
5489     {
5490       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y",     sbY1);
5491       sbH  = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5492       if ( sbY1 + sbH > aTol ) {
5493         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5494         sbY1=0.01;
5495         sbH =0.08;
5496         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5497         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5498       }
5499     }
5500     else if ( name == "segmentation" )
5501     {
5502       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5503       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5504     }
5505     else if ( name == "nb_segments_per_edge" )
5506     {
5507       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5508       myComponentSMESH->SetDefaultNbSegments( nbSeg );
5509     }
5510     else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5511     {
5512       QString val = aResourceMgr->stringValue( "SMESH", name );
5513       myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5514     }
5515     else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5516     {
5517       SMESH::UpdateFontProp( this );
5518     }
5519     else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5520     {
5521       SMESH::UpdateFontProp( this );
5522     }
5523
5524     if ( aWarning.size() != 0 ) {
5525       aWarning += "The default values are applied instead.";
5526       SUIT_MessageBox::warning(SMESHGUI::desktop(),
5527                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5528                                QObject::tr(aWarning.c_str()));
5529     }
5530   }
5531 }
5532
5533 //================================================================================
5534 /*!
5535  * \brief Update something in accordance with update flags
5536   * \param theFlags - update flags
5537 *
5538 * Update viewer or/and object browser etc. in accordance with update flags ( see
5539 * LightApp_UpdateFlags enumeration ).
5540 */
5541 //================================================================================
5542 void SMESHGUI::update( const int flags )
5543 {
5544   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5545     SMESH::UpdateView();
5546   else
5547     SalomeApp_Module::update( flags );
5548 }
5549
5550 //================================================================================
5551 /*!
5552  * \brief Set default selection mode
5553 *
5554 * SLOT called when operation committed. Sets default selection mode
5555 */
5556 //================================================================================
5557 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5558 {
5559   SVTK_ViewWindow* vtkWnd =
5560     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5561   if ( vtkWnd )
5562     vtkWnd->SetSelectionMode( ActorSelection );
5563 }
5564
5565 //================================================================================
5566 /*!
5567  * \brief Set default selection mode
5568 *
5569 * SLOT called when operation aborted. Sets default selection mode
5570 */
5571 //================================================================================
5572 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5573 {
5574   SVTK_ViewWindow* vtkWnd =
5575     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5576   if ( vtkWnd )
5577     vtkWnd->SetSelectionMode( ActorSelection );
5578 }
5579
5580 //================================================================================
5581 /*!
5582  * \brief Creates operation with given identifier
5583   * \param id - identifier of operation to be started
5584   * \return Pointer on created operation or NULL if operation is not created
5585 *
5586 * Virtual method redefined from the base class creates operation with given id.
5587 * It is called called automatically from startOperation method of base class.
5588 */
5589 //================================================================================
5590 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5591 {
5592   LightApp_Operation* op = 0;
5593   // to do : create operation here
5594   switch( id )
5595   {
5596     case SMESHOp::OpSplitBiQuadratic:
5597       op = new SMESHGUI_SplitBiQuadOp();
5598     break;
5599     case SMESHOp::OpConvertMeshToQuadratic:
5600       op = new SMESHGUI_ConvToQuadOp();
5601     break;
5602     case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5603       op = new SMESHGUI_Make2DFrom3DOp();
5604     break;
5605     case SMESHOp::OpReorientFaces:
5606       op = new SMESHGUI_ReorientFacesOp();
5607       break;
5608     case SMESHOp::OpCreateMesh:
5609       op = new SMESHGUI_MeshOp( true, true );
5610     break;
5611     case SMESHOp::OpCreateSubMesh:
5612       op = new SMESHGUI_MeshOp( true, false );
5613     break;
5614     case SMESHOp::OpEditMeshOrSubMesh:
5615     case SMESHOp::OpEditMesh:
5616     case SMESHOp::OpEditSubMesh:
5617       op = new SMESHGUI_MeshOp( false );
5618     break;
5619     case SMESHOp::OpCompute:
5620     case SMESHOp::OpComputeSubMesh:
5621       op = new SMESHGUI_ComputeOp();
5622     break;
5623     case SMESHOp::OpPreCompute:
5624       op = new SMESHGUI_PrecomputeOp();
5625     break;
5626     case SMESHOp::OpEvaluate:
5627       op = new SMESHGUI_EvaluateOp();
5628     break;
5629     case SMESHOp::OpMeshOrder:
5630       op = new SMESHGUI_MeshOrderOp();
5631     break;
5632     case SMESHOp::OpCreateGeometryGroup:
5633       op = new SMESHGUI_GroupOnShapeOp();
5634       break;
5635     case SMESHOp::OpFindElementByPoint:
5636       op = new SMESHGUI_FindElemByPointOp();
5637       break;
5638     case SMESHOp::OpMoveNode: // Make mesh pass through point
5639       op = new SMESHGUI_MakeNodeAtPointOp();
5640       break;
5641     case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5642       op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5643       break;
5644     default:
5645     break;
5646   }
5647
5648   if( !op )
5649     op = SalomeApp_Module::createOperation( id );
5650   return op;
5651 }
5652
5653 //================================================================================
5654 /*!
5655  * \brief Stops current operations and starts a given one
5656   * \param id - The id of the operation to start
5657  */
5658 //================================================================================
5659
5660 void SMESHGUI::switchToOperation(int id)
5661 {
5662   activeStudy()->abortAllOperations();
5663   startOperation( id );
5664 }
5665
5666 LightApp_Displayer* SMESHGUI::displayer()
5667 {
5668   if( !myDisplayer )
5669     myDisplayer = new SMESHGUI_Displayer( getApp() );
5670   return myDisplayer;
5671 }
5672
5673 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5674 {
5675   int aHue = -1;
5676   int aTolerance = 64;
5677   int anIterations = 0;
5678   int aPeriod = 5;
5679
5680   while( 1 )
5681   {
5682     anIterations++;
5683     if( anIterations % aPeriod == 0 )
5684     {
5685       aTolerance /= 2;
5686       if( aTolerance < 1 )
5687         break;
5688     }
5689
5690     aHue = (int)( 360.0 * rand() / RAND_MAX );
5691
5692     bool ok = true;
5693     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5694     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5695     for( ; it != itEnd; ++it )
5696     {
5697       SALOMEDS::Color anAutoColor = *it;
5698       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5699
5700       int h, s, v;
5701       aQColor.getHsv( &h, &s, &v );
5702       if( abs( h - aHue ) < aTolerance )
5703       {
5704         ok = false;
5705         break;
5706       }
5707     }
5708
5709     if( ok )
5710       break;
5711   }
5712
5713   QColor aColor;
5714   aColor.setHsv( aHue, 255, 255 );
5715
5716   SALOMEDS::Color aSColor;
5717   aSColor.R = aColor.redF();
5718   aSColor.G = aColor.greenF();
5719   aSColor.B = aColor.blueF();
5720
5721   return aSColor;
5722 }
5723
5724 const char* gSeparator = "_"; // character used to separate parameter names
5725 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5726 const char* gPathSep   = "|"; // character used to separate paths
5727
5728 /*!
5729  * \brief Store visual parameters
5730  *
5731  * This method is called just before the study document is saved.
5732  * Store visual parameters in AttributeParameter attribue(s)
5733  */
5734 void SMESHGUI::storeVisualParameters (int savePoint)
5735 {
5736   // localizing
5737   Kernel_Utils::Localizer loc;
5738
5739   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5740   if (!appStudy || !appStudy->studyDS())
5741     return;
5742   _PTR(Study) studyDS = appStudy->studyDS();
5743
5744   // componentName is used for encoding of entries when storing them in IParameters
5745   std::string componentName = myComponentSMESH->ComponentDataType();
5746   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5747   //if (!aSComponent) return;
5748
5749   // IParameters
5750   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5751                                                              componentName.c_str(),
5752                                                              savePoint);
5753   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5754
5755   // store custom markers
5756   if( !myMarkerMap.empty() )
5757   {
5758     VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5759     for( ; anIter != myMarkerMap.end(); anIter++ )
5760     {
5761       int anId = anIter->first;
5762       VTK::MarkerData aMarkerData = anIter->second;
5763       std::string aMarkerFileName = aMarkerData.first;
5764       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5765       if( aMarkerTexture.size() < 3 )
5766         continue; // should contain at least width, height and the first value
5767
5768       QString aPropertyName( "texture" );
5769       aPropertyName += gSeparator;
5770       aPropertyName += QString::number( anId );
5771
5772       QString aPropertyValue = aMarkerFileName.c_str();
5773       aPropertyValue += gPathSep;
5774
5775       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5776       ushort aWidth = *aTextureIter++;
5777       ushort aHeight = *aTextureIter++;
5778       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5779       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5780       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5781         aPropertyValue += QString::number( *aTextureIter );
5782
5783       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5784     }
5785   }
5786
5787   // viewers counters are used for storing view_numbers in IParameters
5788   int vtkViewers = 0;
5789
5790   // main cycle to store parameters of displayed objects
5791   QList<SUIT_ViewManager*> lst;
5792   QList<SUIT_ViewManager*>::Iterator it;
5793   getApp()->viewManagers(lst);
5794   for (it = lst.begin(); it != lst.end(); it++)
5795   {
5796     SUIT_ViewManager* vman = *it;
5797     QString vType = vman->getType();
5798
5799     // saving VTK actors properties
5800     if (vType == SVTK_Viewer::Type())
5801     {
5802       // store the clipping planes attached to the view manager
5803       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5804       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5805       if( anIter != myClippingPlaneInfoMap.end() )
5806         aClippingPlaneInfoList = anIter->second;
5807
5808       if( !aClippingPlaneInfoList.empty() ) {
5809         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5810         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5811         {
5812           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5813           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5814
5815           QString aPropertyName( "ClippingPlane" );
5816           aPropertyName += gSeparator;
5817           aPropertyName += QString::number( vtkViewers );
5818           aPropertyName += gSeparator;
5819           aPropertyName += QString::number( anId );
5820
5821           QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5822           aPropertyValue += gDigitsSep;
5823           aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5824           aPropertyValue += gDigitsSep;
5825           if ( aPlane->PlaneMode == SMESH::Absolute ) {
5826             aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5827             aPropertyValue += gDigitsSep;
5828             aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5829             aPropertyValue += gDigitsSep;
5830             aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5831             aPropertyValue += gDigitsSep;
5832             aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5833             aPropertyValue += gDigitsSep;
5834             aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5835             aPropertyValue += gDigitsSep;
5836             aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5837             aPropertyValue += gDigitsSep;
5838             aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5839           }
5840           else if ( aPlane->PlaneMode == SMESH::Relative ) {
5841             aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5842             aPropertyValue += gDigitsSep;
5843             aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5844             aPropertyValue += gDigitsSep;
5845             aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5846             aPropertyValue += gDigitsSep;
5847             aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5848           }
5849
5850           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5851         }
5852       }
5853
5854       QVector<SUIT_ViewWindow*> views = vman->getViews();
5855       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5856       {
5857         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5858         {
5859           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5860           vtkActorCollection* allActors = aCopy.GetActors();
5861           allActors->InitTraversal();
5862           while (vtkActor* actor = allActors->GetNextActor())
5863           {
5864             if (actor->GetVisibility()) // store only visible actors
5865             {
5866               SMESH_Actor* aSmeshActor = 0;
5867               if (actor->IsA("SMESH_Actor"))
5868                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5869               if (aSmeshActor && aSmeshActor->hasIO())
5870               {
5871                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5872                 if (io->hasEntry())
5873                 {
5874                   // entry is "encoded" = it does NOT contain component address,
5875                   // since it is a subject to change on next component loading
5876                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5877
5878                   std::string param, vtkParam = vType.toLatin1().data();
5879                   vtkParam += gSeparator;
5880                   vtkParam += QString::number(vtkViewers).toLatin1().data();
5881                   vtkParam += gSeparator;
5882
5883                   // Visibility
5884                   param = vtkParam + "Visibility";
5885                   ip->setParameter(entry, param, "On");
5886
5887                   // Representation
5888                   param = vtkParam + "Representation";
5889                   ip->setParameter(entry, param, QString::number
5890                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5891
5892                   // IsShrunk
5893                   param = vtkParam + "IsShrunk";
5894                   ip->setParameter(entry, param, QString::number
5895                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5896
5897                   // Displayed entities
5898                   unsigned int aMode = aSmeshActor->GetEntityMode();
5899                   bool isE  = aMode & SMESH_Actor::eEdges;
5900                   bool isF  = aMode & SMESH_Actor::eFaces;
5901                   bool isV  = aMode & SMESH_Actor::eVolumes;
5902                   bool is0d = aMode & SMESH_Actor::e0DElements;
5903                   bool isB  = aMode & SMESH_Actor::eBallElem;
5904
5905                   QString modeStr ("e");
5906                   modeStr += gDigitsSep; modeStr += QString::number(isE);
5907                   modeStr += gDigitsSep; modeStr += "f";
5908                   modeStr += gDigitsSep; modeStr += QString::number(isF);
5909                   modeStr += gDigitsSep; modeStr += "v";
5910                   modeStr += gDigitsSep; modeStr += QString::number(isV);
5911                   modeStr += gDigitsSep; modeStr += "0d";
5912                   modeStr += gDigitsSep; modeStr += QString::number(is0d);
5913                   modeStr += gDigitsSep; modeStr += "b";
5914                   modeStr += gDigitsSep; modeStr += QString::number(isB);
5915
5916                   param = vtkParam + "Entities";
5917                   ip->setParameter(entry, param, modeStr.toLatin1().data());
5918
5919                   // Colors
5920                   double r, g, b;
5921                   int delta;
5922
5923                   aSmeshActor->GetSufaceColor(r, g, b, delta);
5924                   QStringList colorStr;
5925                   colorStr << "surface";
5926                   colorStr << QString::number(r);
5927                   colorStr << QString::number(g);
5928                   colorStr << QString::number(b);
5929
5930                   colorStr << "backsurface";
5931                   colorStr << QString::number(delta);
5932
5933                   aSmeshActor->GetVolumeColor(r, g, b, delta);
5934                   colorStr << "volume";
5935                   colorStr << QString::number(r);
5936                   colorStr << QString::number(g);
5937                   colorStr << QString::number(b);
5938                   colorStr << QString::number(delta);
5939
5940                   aSmeshActor->GetEdgeColor(r, g, b);
5941                   colorStr << "edge";
5942                   colorStr << QString::number(r);
5943                   colorStr << QString::number(g);
5944                   colorStr << QString::number(b);
5945
5946                   aSmeshActor->GetNodeColor(r, g, b);
5947                   colorStr << "node";
5948                   colorStr << QString::number(r);
5949                   colorStr << QString::number(g);
5950                   colorStr << QString::number(b);
5951
5952                   aSmeshActor->GetOutlineColor(r, g, b);
5953                   colorStr << "outline";
5954                   colorStr << QString::number(r);
5955                   colorStr << QString::number(g);
5956                   colorStr << QString::number(b);
5957
5958                   aSmeshActor->Get0DColor(r, g, b);
5959                   colorStr << "elem0d";
5960                   colorStr << QString::number(r);
5961                   colorStr << QString::number(g);
5962                   colorStr << QString::number(b);
5963
5964                   aSmeshActor->GetBallColor(r, g, b);
5965                   colorStr << "ball";
5966                   colorStr << QString::number(r);
5967                   colorStr << QString::number(g);
5968                   colorStr << QString::number(b);
5969
5970                   aSmeshActor->GetFacesOrientationColor(r, g, b);
5971                   colorStr << "orientation";
5972                   colorStr << QString::number(r);
5973                   colorStr << QString::number(g);
5974                   colorStr << QString::number(b);
5975
5976                   param = vtkParam + "Colors";
5977                   ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5978
5979                   // Sizes
5980                   QStringList sizeStr;
5981                   sizeStr << "line";
5982                   sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5983                   sizeStr << "outline";
5984                   sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5985                   sizeStr << "elem0d";
5986                   sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5987                   sizeStr << "ball";
5988                   //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5989                   sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5990                   sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5991                   sizeStr << "shrink";
5992                   sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5993                   sizeStr << "orientation";
5994                   sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5995                   sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5996
5997                   param = vtkParam + "Sizes";
5998                   ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5999
6000                   // Point marker
6001                   QString markerStr;
6002
6003                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6004                   if( aMarkerType == VTK::MT_USER ) {
6005                     markerStr += "custom";
6006                     markerStr += gDigitsSep;
6007                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6008                   }
6009                   else {
6010                     markerStr += "std";
6011                     markerStr += gDigitsSep;
6012                     markerStr += QString::number( (int)aMarkerType );
6013                     markerStr += gDigitsSep;
6014                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6015                   }
6016
6017                   param = vtkParam + "PointMarker";
6018                   ip->setParameter(entry, param, markerStr.toLatin1().data());
6019
6020                   // Opacity
6021                   param = vtkParam + "Opacity";
6022                   ip->setParameter(entry, param,
6023                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6024
6025                   // Clipping
6026                   param = vtkParam + "ClippingPlane";
6027                   int aPlaneId = 0;
6028                   if( !aClippingPlaneInfoList.empty() ) {
6029                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6030                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6031                     {
6032                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6033                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6034                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
6035                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6036                         if( aSmeshActor == *anIter2 ) {
6037                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6038                                             QString::number( anId ).toLatin1().constData() );
6039                           break;
6040                         }
6041                       }
6042                     }
6043                   }
6044                   if( aPlaneId == 0 )
6045                     ip->setParameter( entry, param, "Off" );
6046                 } // if (io->hasEntry())
6047               } // SMESH_Actor && hasIO
6048             } // isVisible
6049           } // while.. actors traversal
6050         } // if (vtkView)
6051       } // for (views)
6052       vtkViewers++;
6053     } // if (SVTK view model)
6054   } // for (viewManagers)
6055 }
6056
6057 // data structures for clipping planes processing
6058 typedef struct {
6059   int Id;
6060   int Mode;
6061   bool isOpenGLClipping;
6062   vtkIdType RelativeOrientation;
6063   double Distance;
6064   double Angle[2];
6065   int AbsoluteOrientation;
6066   double X, Y, Z, Dx, Dy, Dz;
6067 } TPlaneData;
6068 typedef std::list<TPlaneData>         TPlaneDataList;
6069 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6070
6071 typedef std::list<vtkActor*>          TActorList;
6072 typedef struct {
6073   int PlaneId;
6074   TActorList ActorList;
6075   SUIT_ViewManager* ViewManager;
6076 } TPlaneInfo;
6077 typedef std::list<TPlaneInfo>         TPlaneInfoList;
6078 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6079
6080 /*!
6081  * \brief Restore visual parameters
6082  *
6083  * This method is called after the study document is opened.
6084  * Restore visual parameters from AttributeParameter attribue(s)
6085  */
6086 void SMESHGUI::restoreVisualParameters (int savePoint)
6087 {
6088   // localizing
6089   Kernel_Utils::Localizer loc;
6090
6091   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6092   if (!appStudy || !appStudy->studyDS())
6093     return;
6094   _PTR(Study) studyDS = appStudy->studyDS();
6095
6096   // componentName is used for encoding of entries when storing them in IParameters
6097   std::string componentName = myComponentSMESH->ComponentDataType();
6098   //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6099   //if (!aSComponent) return;
6100
6101   // IParameters
6102   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6103                                                              componentName.c_str(),
6104                                                              savePoint);
6105   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6106
6107   // restore custom markers and map of clipping planes
6108   TPlaneDataMap aPlaneDataMap;
6109
6110   std::vector<std::string> properties = ip->getProperties();
6111   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6112   {
6113     std::string property = *propIt;
6114     QString aPropertyName( property.c_str() );
6115     QString aPropertyValue( ip->getProperty( property ).c_str() );
6116
6117     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6118     if( aPropertyNameList.isEmpty() )
6119       continue;
6120
6121     QString aPropertyType = aPropertyNameList[0];
6122     if( aPropertyType == "texture" )
6123     {
6124       if( aPropertyNameList.size() != 2 )
6125         continue;
6126
6127       bool ok = false;
6128       int anId = aPropertyNameList[1].toInt( &ok );
6129       if( !ok || anId < 1 )
6130         continue;
6131
6132       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6133       if( aPropertyValueList.size() != 2 )
6134         continue;
6135
6136       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6137       QString aMarkerTextureString = aPropertyValueList[1];
6138       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6139       if( aMarkerTextureStringList.size() != 3 )
6140         continue;
6141
6142       ok = false;
6143       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6144       if( !ok )
6145         continue;
6146
6147       ok = false;
6148       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6149       if( !ok )
6150         continue;
6151
6152       VTK::MarkerTexture aMarkerTexture;
6153       aMarkerTexture.push_back( aWidth );
6154       aMarkerTexture.push_back( aHeight );
6155
6156       QString aMarkerTextureData = aMarkerTextureStringList[2];
6157       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6158       {
6159         QChar aChar = aMarkerTextureData.at( i );
6160         if( aChar.isDigit() )
6161           aMarkerTexture.push_back( aChar.digitValue() );
6162       }
6163
6164       myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6165     }
6166     else if( aPropertyType == "ClippingPlane" )
6167     {
6168       if( aPropertyNameList.size() != 3 )
6169         continue;
6170
6171       bool ok = false;
6172       int aViewId = aPropertyNameList[1].toInt( &ok );
6173       if( !ok || aViewId < 0 )
6174         continue;
6175
6176       ok = false;
6177       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6178       if( !ok || aClippingPlaneId < 0 )
6179         continue;
6180
6181       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6182       if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6183         continue;
6184
6185       TPlaneData aPlaneData;
6186       aPlaneData.AbsoluteOrientation = false;
6187       aPlaneData.RelativeOrientation = 0;
6188       aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6189       aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6190       aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6191
6192       aPlaneData.Id = aClippingPlaneId;
6193
6194       ok = false;
6195       aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6196       if( !ok )
6197         continue;
6198
6199       ok = false;
6200       aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6201       if( !ok )
6202         continue;
6203
6204       if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6205       {
6206         ok = false;
6207         aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6208         if( !ok )
6209           continue;
6210
6211         ok = false;
6212         aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6213         if( !ok )
6214           continue;
6215
6216         ok = false;
6217         aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6218         if( !ok )
6219           continue;
6220
6221         ok = false;
6222         aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6223         if( !ok )
6224           continue;
6225
6226         ok = false;
6227         aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6228         if( !ok )
6229           continue;
6230
6231         ok = false;
6232         aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6233         if( !ok )
6234           continue;
6235
6236         ok = false;
6237         aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6238         if( !ok )
6239           continue;
6240       }
6241       else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6242         ok = false;
6243         aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6244         if( !ok )
6245           continue;
6246
6247         ok = false;
6248         aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6249         if( !ok )
6250           continue;
6251
6252         ok = false;
6253         aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6254         if( !ok )
6255           continue;
6256
6257         ok = false;
6258         aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6259         if( !ok )
6260           continue;
6261       }
6262
6263       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6264       aPlaneDataList.push_back( aPlaneData );
6265     }
6266   }
6267
6268   TPlaneInfoMap aPlaneInfoMap;
6269
6270   std::vector<std::string> entries = ip->getEntries();
6271
6272   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6273   {
6274     // entry is a normal entry - it should be "decoded" (setting base address of component)
6275     QString entry (ip->decodeEntry(*entIt).c_str());
6276
6277     // Check that the entry corresponds to a real object in the Study
6278     // as the object may be deleted or modified after the visual state is saved.
6279     _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6280     if (!so) continue; //Skip the not existent entry
6281
6282     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6283     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6284
6285     std::vector<std::string>::iterator namesIt = paramNames.begin();
6286     std::vector<std::string>::iterator valuesIt = paramValues.begin();
6287
6288     // actors are stored in a map after displaying of them for
6289     // quicker access in the future: map < viewID to actor >
6290     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6291
6292     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6293     {
6294       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6295       // '_' is used as separator and should not be used in viewer type or parameter names.
6296       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6297       if (lst.size() != 3)
6298         continue;
6299
6300       QString viewerTypStr = lst[0];
6301       QString viewIndexStr = lst[1];
6302       QString paramNameStr = lst[2];
6303
6304       bool ok;
6305       int viewIndex = viewIndexStr.toUInt(&ok);
6306       if (!ok) // bad conversion of view index to integer
6307         continue;
6308
6309       // viewers
6310       if (viewerTypStr == SVTK_Viewer::Type())
6311       {
6312         SMESH_Actor* aSmeshActor = 0;
6313         if (vtkActors.IsBound(viewIndex))
6314           aSmeshActor = vtkActors.Find(viewIndex);
6315
6316         QList<SUIT_ViewManager*> lst;
6317         getApp()->viewManagers(viewerTypStr, lst);
6318
6319         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6320         SUIT_ViewManager* vman = NULL;
6321         if (viewIndex >= 0 && viewIndex < lst.count())
6322           vman = lst.at(viewIndex);
6323
6324         if (paramNameStr == "Visibility")
6325         {
6326           if (!aSmeshActor && displayer() && vman)
6327           {
6328             SUIT_ViewModel* vmodel = vman->getViewModel();
6329             // SVTK view model can be casted to SALOME_View
6330             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6331
6332             // store displayed actor in a temporary map for quicker
6333             // access later when restoring other parameters
6334             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6335             vtkRenderer* Renderer = vtkView->getRenderer();
6336             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6337             vtkActorCollection* theActors = aCopy.GetActors();
6338             theActors->InitTraversal();
6339             bool isFound = false;
6340             vtkActor *ac = theActors->GetNextActor();
6341             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6342               if (ac->IsA("SMESH_Actor")) {
6343                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6344                 if (aGeomAc->hasIO()) {
6345                   Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6346                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6347                     isFound = true;
6348                     vtkActors.Bind(viewIndex, aGeomAc);
6349                   }
6350                 }
6351               }
6352             }
6353           }
6354         } // if (paramNameStr == "Visibility")
6355         else
6356         {
6357           // the rest properties "work" with SMESH_Actor
6358           if (aSmeshActor)
6359           {
6360             QString val ((*valuesIt).c_str());
6361
6362             // Representation
6363             if (paramNameStr == "Representation") {
6364               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6365             }
6366             // IsShrunk
6367             else if (paramNameStr == "IsShrunk") {
6368               if (val.toInt()) {
6369                 if (!aSmeshActor->IsShrunk())
6370                   aSmeshActor->SetShrink();
6371               }
6372               else {
6373                 if (aSmeshActor->IsShrunk())
6374                   aSmeshActor->UnShrink();
6375               }
6376             }
6377             // Displayed entities
6378             else if (paramNameStr == "Entities") {
6379               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6380               int aEntityMode = SMESH_Actor::eAllEntity;
6381               for ( int i = 0; i < mode.count(); i+=2 ) {
6382                 if ( i < mode.count()-1 ) {
6383                   QString type = mode[i];
6384                   bool val = mode[i+1].toInt();
6385                   if      ( type == "e" && !val )
6386                     aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6387                   else if ( type == "f" && !val )
6388                     aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6389                   else if ( type == "v" && !val )
6390                     aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6391                   else if ( type == "0d" && !val )
6392                     aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6393                   else if ( type == "b" && !val )
6394                     aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6395                 }
6396               }
6397               aSmeshActor->SetEntityMode( aEntityMode );
6398             }
6399             // Colors
6400             else if (paramNameStr == "Colors") {
6401               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6402               QColor nodeColor;
6403               QColor edgeColor;
6404               QColor faceColor;
6405               QColor volumeColor;
6406               QColor elem0dColor;
6407               QColor ballColor;
6408               QColor outlineColor;
6409               QColor orientationColor;
6410               int deltaF;
6411               int deltaV;
6412               QColor c;
6413               double r, g, b;
6414               bool bOk;
6415               // below lines are required to get default values for delta coefficients
6416               // of backface color for faces and color of reversed volumes
6417               SMESH::GetColor( "SMESH", "fill_color",   c, deltaF, "0,170,255|-100" );
6418               SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6419               for ( int i = 0; i < colors.count(); i++ ) {
6420                 QString type = colors[i];
6421                 if ( type == "surface" ) {
6422                   // face color is set by 3 values r:g:b, where
6423                   // - r,g,b - is rgb color components
6424                   if ( i+1 >= colors.count() ) break;                  // format error
6425                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6426                   if ( i+2 >= colors.count() ) break;                  // format error
6427                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6428                   if ( i+3 >= colors.count() ) break;                  // format error
6429                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6430                   faceColor.setRgbF( r, g, b );
6431                   i += 3;
6432                 }
6433                 else if ( type == "backsurface" ) {
6434                   // backface color can be defined in several ways
6435                   // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6436                   // - in latest versions, it is set as delta coefficient
6437                   bool rgbOk = false, deltaOk;
6438                   if ( i+1 >= colors.count() ) break;                  // format error
6439                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6440                   int delta = colors[i+1].toInt( &deltaOk );
6441                   i++;                                 // shift index
6442                   if ( i+1 < colors.count() )          // index is shifted to 1
6443                     g = colors[i+1].toDouble( &rgbOk );
6444                   if ( rgbOk ) i++;                    // shift index
6445                   if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6446                     b = colors[i+1].toDouble( &rgbOk );
6447                   if ( rgbOk ) i++;
6448                   // - as currently there's no way to set directly backsurface color as it was before,
6449                   // we ignore old dump where r,g,b triple was set
6450                   // - also we check that delta parameter is set properly
6451                   if ( !rgbOk && deltaOk )
6452                     deltaF = delta;
6453                 }
6454                 else if ( type == "volume" ) {
6455                   // volume color is set by 4 values r:g:b:delta, where
6456                   // - r,g,b - is a normal volume rgb color components
6457                   // - delta - is a reversed volume color delta coefficient
6458                   if ( i+1 >= colors.count() ) break;                  // format error
6459                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6460                   if ( i+2 >= colors.count() ) break;                  // format error
6461                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6462                   if ( i+3 >= colors.count() ) break;                  // format error
6463                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6464                   if ( i+4 >= colors.count() ) break;                  // format error
6465                   int delta = colors[i+4].toInt( &bOk );
6466                   if ( !bOk ) break;                                   // format error
6467                   volumeColor.setRgbF( r, g, b );
6468                   deltaV = delta;
6469                   i += 4;
6470                 }
6471                 else if ( type == "edge" ) {
6472                   // edge color is set by 3 values r:g:b, where
6473                   // - r,g,b - is rgb color components
6474                   if ( i+1 >= colors.count() ) break;                  // format error
6475                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6476                   if ( i+2 >= colors.count() ) break;                  // format error
6477                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6478                   if ( i+3 >= colors.count() ) break;                  // format error
6479                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6480                   edgeColor.setRgbF( r, g, b );
6481                   i += 3;
6482                 }
6483                 else if ( type == "node" ) {
6484                   // node color is set by 3 values r:g:b, where
6485                   // - r,g,b - is rgb color components
6486                   if ( i+1 >= colors.count() ) break;                  // format error
6487                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6488                   if ( i+2 >= colors.count() ) break;                  // format error
6489                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6490                   if ( i+3 >= colors.count() ) break;                  // format error
6491                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6492                   nodeColor.setRgbF( r, g, b );
6493                   i += 3;
6494                 }
6495                 else if ( type == "elem0d" ) {
6496                   // 0d element color is set by 3 values r:g:b, where
6497                   // - r,g,b - is rgb color components
6498                   if ( i+1 >= colors.count() ) break;                  // format error
6499                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6500                   if ( i+2 >= colors.count() ) break;                  // format error
6501                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6502                   if ( i+3 >= colors.count() ) break;                  // format error
6503                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6504                   elem0dColor.setRgbF( r, g, b );
6505                   i += 3;
6506                 }
6507                 else if ( type == "ball" ) {
6508                   // ball color is set by 3 values r:g:b, where
6509                   // - r,g,b - is rgb color components
6510                   if ( i+1 >= colors.count() ) break;                  // format error
6511                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6512                   if ( i+2 >= colors.count() ) break;                  // format error
6513                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6514                   if ( i+3 >= colors.count() ) break;                  // format error
6515                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6516                   ballColor.setRgbF( r, g, b );
6517                   i += 3;
6518                 }
6519                 else if ( type == "outline" ) {
6520                   // outline color is set by 3 values r:g:b, where
6521                   // - r,g,b - is rgb color components
6522                   if ( i+1 >= colors.count() ) break;                  // format error
6523                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6524                   if ( i+2 >= colors.count() ) break;                  // format error
6525                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6526                   if ( i+3 >= colors.count() ) break;                  // format error
6527                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6528                   outlineColor.setRgbF( r, g, b );
6529                   i += 3;
6530                 }
6531                 else if ( type == "orientation" ) {
6532                   // orientation color is set by 3 values r:g:b, where
6533                   // - r,g,b - is rgb color components
6534                   if ( i+1 >= colors.count() ) break;                  // format error
6535                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6536                   if ( i+2 >= colors.count() ) break;                  // format error
6537                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6538                   if ( i+3 >= colors.count() ) break;                  // format error
6539                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6540                   orientationColor.setRgbF( r, g, b );
6541                   i += 3;
6542                 }
6543               }
6544               // node color
6545               if ( nodeColor.isValid() )
6546                 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6547               // edge color
6548               if ( edgeColor.isValid() )
6549                 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6550               // face color
6551               if ( faceColor.isValid() )
6552                 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6553               // volume color
6554               if ( volumeColor.isValid() )
6555                 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6556               else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6557                 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6558               // 0d element color
6559               if ( elem0dColor.isValid() )
6560                 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6561               // ball color
6562               if ( ballColor.isValid() )
6563                 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6564               // outline color
6565               if ( outlineColor.isValid() )
6566                 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6567               // orientation color
6568               if ( orientationColor.isValid() )
6569                 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6570             }
6571             // Sizes
6572             else if (paramNameStr == "Sizes") {
6573               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6574               bool bOk;
6575               int lineWidth = -1;
6576               int outlineWidth = -1;
6577               int elem0dSize = -1;
6578               //int ballSize = -1;
6579               double ballDiameter = -1.0;
6580               double ballScale = -1.0;
6581               double shrinkSize = -1;
6582               double orientationSize = -1;
6583               bool orientation3d = false;
6584               for ( int i = 0; i < sizes.count(); i++ ) {
6585                 QString type = sizes[i];
6586                 if ( type == "line" ) {
6587                   // line (wireframe) width is given as single integer value
6588                   if ( i+1 >= sizes.count() ) break;                    // format error
6589                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6590                   lineWidth = v;
6591                   i++;
6592                 }
6593                 if ( type == "outline" ) {
6594                   // outline width is given as single integer value
6595                   if ( i+1 >= sizes.count() ) break;                    // format error
6596                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6597                   outlineWidth = v;
6598                   i++;
6599                 }
6600                 else if ( type == "elem0d" ) {
6601                   // 0d element size is given as single integer value
6602                   if ( i+1 >= sizes.count() ) break;                    // format error
6603                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6604                   elem0dSize = v;
6605                   i++;
6606                 }
6607                 else if ( type == "ball" ) {
6608                   // balls are specified by two values: size:scale, where
6609                   // - size - is a integer value specifying size
6610                   // - scale - is a double value specifying scale factor
6611                   if ( i+1 >= sizes.count() ) break;                       // format error
6612                   //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6613                   double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6614                   if ( i+2 >= sizes.count() ) break;                       // format error
6615                   double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6616                   //ballSize = v1;
6617                   ballDiameter = v1;
6618                   ballScale = v2;
6619                   i += 2;
6620                 }
6621                 else if ( type == "shrink" ) {
6622                   // shrink factor is given as single floating point value
6623                   if ( i+1 >= sizes.count() ) break;                          // format error
6624                   double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break;  // format error
6625                   shrinkSize = v;
6626                   i++;
6627                 }
6628                 else if ( type == "orientation" ) {
6629                   // orientation vectors are specified by two values size:3d, where
6630                   // - size - is a floating point value specifying scale factor
6631                   // - 3d - is a boolean
6632                   if ( i+1 >= sizes.count() ) break;                          // format error
6633                   double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6634                   if ( i+2 >= sizes.count() ) break;                          // format error
6635                   int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break;       // format error
6636                   orientationSize = v1;
6637                   orientation3d = (bool)v2;
6638                   i += 2;
6639                 }
6640               }
6641               // line (wireframe) width
6642               if ( lineWidth > 0 )
6643                 aSmeshActor->SetLineWidth( lineWidth );
6644               // outline width
6645               if ( outlineWidth > 0 )
6646                 aSmeshActor->SetOutlineWidth( outlineWidth );
6647               else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6648                 aSmeshActor->SetOutlineWidth( lineWidth );
6649               // 0d element size
6650               if ( elem0dSize > 0 )
6651                 aSmeshActor->Set0DSize( elem0dSize );
6652               // ball size
6653               /*if ( ballSize > 0 )
6654                 aSmeshActor->SetBallSize( ballSize );*/
6655               // ball diameter
6656               if ( ballDiameter > 0 )
6657                 aSmeshActor->SetBallSize( ballDiameter );
6658               // ball scale
6659               if ( ballScale > 0.0 )
6660                 aSmeshActor->SetBallScale( ballScale );
6661               // shrink factor
6662               if ( shrinkSize > 0 )
6663                 aSmeshActor->SetShrinkFactor( shrinkSize );
6664               // orientation vectors
6665               if ( orientationSize > 0 ) {
6666                 aSmeshActor->SetFacesOrientationScale( orientationSize );
6667                 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6668               }
6669             }
6670             // Point marker
6671             else if (paramNameStr == "PointMarker") {
6672               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6673               if( data.count() >= 2 ) {
6674                 bool ok = false;
6675                 int aParam1 = data[1].toInt( &ok );
6676                 if( ok ) {
6677                   if( data[0] == "std" && data.count() == 3 ) {
6678                     int aParam2 = data[2].toInt( &ok );
6679                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6680                   }
6681                   else if( data[0] == "custom" ) {
6682                     VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6683                     if( markerIt != myMarkerMap.end() ) {
6684                       VTK::MarkerData aMarkerData = markerIt->second;
6685                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6686                     }
6687                   }
6688                 }
6689               }
6690             }
6691             // Opacity
6692             else if (paramNameStr == "Opacity") {
6693               aSmeshActor->SetOpacity(val.toFloat());
6694             }
6695             // Clipping
6696             else if (paramNameStr.startsWith("ClippingPlane")) {
6697               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6698               // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6699               // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6700               // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6701               // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6702               // new format - val looks like "Off" or "0" (plane id)
6703               // (note: in new format "Off" value is used only for consistency,
6704               //  so it is processed together with values in old format)
6705               bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6706               if( anIsOldFormat ) {
6707                 if (paramNameStr == "ClippingPlane1" || val == "Off")
6708                   aSmeshActor->RemoveAllClippingPlanes();
6709                 if (val != "Off") {
6710                   QList<SUIT_ViewManager*> lst;
6711                   getApp()->viewManagers(viewerTypStr, lst);
6712                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6713                   if (viewIndex >= 0 && viewIndex < lst.count()) {
6714                     SUIT_ViewManager* vman = lst.at(viewIndex);
6715                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6716
6717                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6718
6719                     SMESH::TActorList anActorList;
6720                     anActorList.push_back( aSmeshActor );
6721                     SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6722                     aPlane->myViewWindow = vtkView;
6723                     SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6724                     aPlane->PlaneMode = aMode;
6725                     bool isOpenGLClipping = ( bool )vals[1].toInt();
6726                     aPlane->IsOpenGLClipping = isOpenGLClipping;
6727                     if ( aMode == SMESH::Absolute ) {
6728                       aPlane->myAbsoluteOrientation = vals[2].toInt();
6729                       aPlane->X = vals[3].toFloat();
6730                       aPlane->Y = vals[4].toFloat();
6731                       aPlane->Z = vals[5].toFloat();
6732                       aPlane->Dx = vals[6].toFloat();
6733                       aPlane->Dy = vals[7].toFloat();
6734                       aPlane->Dz = vals[8].toFloat();
6735                     }
6736                     else if ( aMode == SMESH::Relative ) {
6737                       aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6738                       aPlane->myDistance = vals[3].toFloat();
6739                       aPlane->myAngle[0] = vals[4].toFloat();
6740                       aPlane->myAngle[1] = vals[5].toFloat();
6741                     }
6742
6743                     if( aPlane ) {
6744                       if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6745                         SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6746                         aClippingPlaneInfo.Plane = aPlane;
6747                         aClippingPlaneInfo.ActorList = anActorList;
6748                         aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6749                       }
6750                     }
6751                   }
6752                 }
6753               }
6754               else {
6755                 bool ok = false;
6756                 int aPlaneId = val.toInt( &ok );
6757                 if( ok && aPlaneId >= 0 ) {
6758                   bool anIsDefinedPlane = false;
6759                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6760                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6761                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6762                     TPlaneInfo& aPlaneInfo = *anIter;
6763                     if( aPlaneInfo.PlaneId == aPlaneId ) {
6764                       aPlaneInfo.ActorList.push_back( aSmeshActor );
6765                       anIsDefinedPlane = true;
6766                       break;
6767                     }
6768                   }
6769                   if( !anIsDefinedPlane ) {
6770                     TPlaneInfo aPlaneInfo;
6771                     aPlaneInfo.PlaneId = aPlaneId;
6772                     aPlaneInfo.ActorList.push_back( aSmeshActor );
6773                     aPlaneInfo.ViewManager = vman;
6774
6775                     // to make the list sorted by plane id
6776                     anIter = aPlaneInfoList.begin();
6777                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6778                       const TPlaneInfo& aPlaneInfoRef = *anIter;
6779                       if( aPlaneInfoRef.PlaneId > aPlaneId )
6780                         break;
6781                     }
6782                     aPlaneInfoList.insert( anIter, aPlaneInfo );
6783                   }
6784                 }
6785               }
6786             }
6787           } // if (aSmeshActor)
6788         } // other parameters than Visibility
6789       }
6790     } // for names/parameters iterator
6791   } // for entries iterator
6792
6793   // take into account planes with empty list of actors referred to them
6794   QList<SUIT_ViewManager*> aVMList;
6795   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6796
6797   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6798   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6799     int aViewId = aPlaneDataIter->first;
6800     if( aViewId >= 0 && aViewId < aVMList.count() ) {
6801       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6802
6803       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6804
6805       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6806       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6807       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6808         const TPlaneData& aPlaneData = *anIter2;
6809         int aPlaneId = aPlaneData.Id;
6810
6811         bool anIsFound = false;
6812         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6813         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6814           const TPlaneInfo& aPlaneInfo = *anIter3;
6815           if( aPlaneInfo.PlaneId == aPlaneId ) {
6816             anIsFound = true;
6817             break;
6818           }
6819         }
6820
6821         if( !anIsFound ) {
6822           TPlaneInfo aPlaneInfo; // ActorList field is empty
6823           aPlaneInfo.PlaneId = aPlaneId;
6824           aPlaneInfo.ViewManager = aViewManager;
6825
6826           // to make the list sorted by plane id
6827           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6828           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6829             const TPlaneInfo& aPlaneInfoRef = *anIter4;
6830             if( aPlaneInfoRef.PlaneId > aPlaneId )
6831               break;
6832           }
6833           aPlaneInfoList.insert( anIter4, aPlaneInfo );
6834         }
6835       }
6836     }
6837   }
6838
6839   // add clipping planes to actors according to the restored parameters
6840   // and update the clipping plane map
6841   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6842   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6843     int aViewId = anIter1->first;
6844     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6845
6846     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6847     if( anIter2 == aPlaneDataMap.end() )
6848       continue;
6849     const TPlaneDataList& aPlaneDataList = anIter2->second;
6850
6851     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6852     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6853       const TPlaneInfo& aPlaneInfo = *anIter3;
6854       int aPlaneId = aPlaneInfo.PlaneId;
6855       const TActorList& anActorList = aPlaneInfo.ActorList;
6856       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6857       if( !aViewManager )
6858         continue;
6859
6860       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6861       if( !aViewWindow )
6862         continue;
6863
6864       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6865
6866       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6867       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6868         const TPlaneData& aPlaneData = *anIter4;
6869         if( aPlaneData.Id == aPlaneId ) {
6870           SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6871           aPlane->myViewWindow = aViewWindow;
6872           aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6873           aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6874           if ( aPlane->PlaneMode == SMESH::Absolute ) {
6875             aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6876             aPlane->X = aPlaneData.X;
6877             aPlane->Y = aPlaneData.Y;
6878             aPlane->Z = aPlaneData.Z;
6879             aPlane->Dx = aPlaneData.Dx;
6880             aPlane->Dy = aPlaneData.Dy;
6881             aPlane->Dz = aPlaneData.Dz;
6882           }
6883           else if ( aPlane->PlaneMode == SMESH::Relative ) {
6884             aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6885             aPlane->myDistance = aPlaneData.Distance;
6886             aPlane->myAngle[0] = aPlaneData.Angle[0];
6887             aPlane->myAngle[1] = aPlaneData.Angle[1];
6888           }
6889           if( aPlane ) {
6890             if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6891               SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6892               aClippingPlaneInfo.Plane = aPlane;
6893               aClippingPlaneInfo.ActorList = anActorList;
6894               aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6895             }
6896           }
6897           break;
6898         }
6899       }
6900
6901     }
6902   }
6903
6904
6905   // update all VTK views
6906   QList<SUIT_ViewManager*> lst;
6907   getApp()->viewManagers(lst);
6908   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6909     SUIT_ViewModel* vmodel = (*it)->getViewModel();
6910     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6911       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6912       // set OpenGL clipping planes
6913       VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6914       vtkActorCollection* anAllActors = aCopy.GetActors();
6915       anAllActors->InitTraversal();
6916       while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6917         if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6918           anActor->SetOpenGLClippingPlane();
6919
6920       vtkView->getRenderer()->ResetCameraClippingRange();
6921       vtkView->Repaint();
6922     }
6923   }
6924 }
6925
6926 /*!
6927   \brief Adds preferences for dfont of VTK viewer
6928   \param label label
6929   \param pIf group identifier
6930   \param param parameter
6931   \return identifier of preferences
6932 */
6933 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6934 {
6935   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6936
6937   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6938
6939   QStringList fam;
6940   fam.append( tr( "SMESH_FONT_ARIAL" ) );
6941   fam.append( tr( "SMESH_FONT_COURIER" ) );
6942   fam.append( tr( "SMESH_FONT_TIMES" ) );
6943
6944   setPreferenceProperty( tfont, "fonts", fam );
6945
6946   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6947   if ( needSize ) f = f | QtxFontEdit::Size;
6948   setPreferenceProperty( tfont, "features", f );
6949
6950   return tfont;
6951 }
6952
6953 /*!
6954   \brief Actions after hypothesis edition
6955   Updates object browser after hypothesis edition
6956 */
6957 void SMESHGUI::onHypothesisEdit( int result )
6958 {
6959   if( result == 1 )
6960     SMESHGUI::Modified();
6961   updateObjBrowser( true );
6962 }
6963
6964 /*!
6965   \brief Actions after choosing menu of control modes
6966   Updates control mode actions according to current selection
6967 */
6968 void SMESHGUI::onUpdateControlActions()
6969 {
6970   SALOME_ListIO selected;
6971   if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6972     aSel->selectedObjects( selected );
6973
6974   SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6975   if ( selected.Extent() ) {
6976     if ( selected.First()->hasEntry() ) {
6977       if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6978         aControl = anActor->GetControlMode();
6979         SALOME_ListIteratorOfListIO it(selected);
6980         for ( it.Next(); it.More(); it.Next() ) {
6981           Handle(SALOME_InteractiveObject) anIO = it.Value();
6982           if ( anIO->hasEntry() ) {
6983             if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6984               if ( aControl != anActor->GetControlMode() ) {
6985                 aControl = SMESH_Actor::eNone;
6986                 break;
6987               }
6988             }
6989           }
6990         }
6991       }
6992     }
6993   }
6994
6995   int anAction = ActionToControl( aControl, true );
6996   if ( anAction)
6997     action( anAction )->setChecked( true );
6998   else {
6999     QMenu* send = (QMenu*)sender();
7000     QList<QAction*> actions = send->actions();
7001     for ( int i = 0; i < actions.size(); i++ )
7002       actions[i]->setChecked( false );
7003   }
7004 }
7005
7006
7007 /*!
7008   \brief Signal handler closing(SUIT_ViewWindow*) of a view
7009   \param pview view being closed
7010 */
7011 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7012 #ifndef DISABLE_PLOT2DVIEWER
7013   //Crear all Plot2d Viewers if need.
7014   SMESH::ClearPlot2Viewers(pview);
7015 #endif
7016   EmitSignalCloseView();
7017 }
7018
7019 void SMESHGUI::message( const QString& msg )
7020 {
7021   // dispatch message
7022   QStringList data = msg.split("/");
7023   if ( data.count() > 0 ) {
7024     if ( data.first() == "mesh_loading" ) {
7025       // get mesh entry
7026       QString entry = data.count() > 1 ? data[1] : QString();
7027       if ( entry.isEmpty() )
7028         return;
7029       // get study
7030       _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7031       // get mesh name
7032       _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7033       QString name;
7034       if ( obj )
7035         name = SMESH::fromUtf8(obj->GetName());
7036       if ( name.isEmpty() )
7037         return;
7038
7039       if ( data.last() == "stop" )
7040         application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7041       else
7042         application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7043       QApplication::processEvents();
7044     }
7045   }
7046 }
7047
7048 /*!
7049   \brief Connects or disconnects signals about activating and cloning view on the module slots
7050   \param pview view which is connected/disconnected
7051 */
7052 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7053   if(!pview)
7054     return;
7055
7056   SUIT_ViewManager* viewMgr = pview->getViewManager();
7057   if ( viewMgr ) {
7058     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7059                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7060
7061     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7062              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7063   }
7064 }
7065
7066 /*!
7067   \brief Return \c true if object can be renamed
7068 */
7069 bool SMESHGUI::renameAllowed( const QString& entry) const {
7070   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7071   if( !anApp )
7072     return false;
7073
7074   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7075   if( !appStudy )
7076     return false;
7077
7078   SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7079
7080   if(!obj)
7081     return false;
7082
7083   if(appStudy->isComponent(entry) || obj->isReference())
7084     return false;
7085
7086   // check type to prevent renaming of inappropriate objects
7087   int aType = SMESHGUI_Selection::type(qPrintable(entry));
7088   if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7089       aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7090       aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7091       aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7092       aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7093     return true;
7094
7095   return false;
7096 }
7097
7098 /*!
7099   Rename object by entry.
7100   \param entry entry of the object
7101   \param name new name of the object
7102   \brief Return \c true if rename operation finished successfully, \c false otherwise.
7103 */
7104 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7105
7106   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7107   if( !anApp )
7108     return false;
7109
7110   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7111
7112   if(!appStudy)
7113     return false;
7114
7115   _PTR(Study) aStudy = appStudy->studyDS();
7116
7117   if(!aStudy)
7118     return false;
7119
7120   bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7121   if ( aLocked ) {
7122     SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7123     return false;
7124   }
7125
7126
7127   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7128   _PTR(GenericAttribute) anAttr;
7129   _PTR(AttributeName) aName;
7130   if ( obj ) {
7131     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7132       aName = anAttr;
7133       // check type to prevent renaming of inappropriate objects
7134       int aType = SMESHGUI_Selection::type( qPrintable(entry));
7135       if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7136           aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7137           aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7138           aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7139           aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7140         if ( !name.isEmpty() ) {
7141           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7142
7143           // update name of group object and its actor
7144           Handle(SALOME_InteractiveObject) IObject =
7145             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7146
7147           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7148           if( !aGroupObject->_is_nil() ) {
7149             aGroupObject->SetName( qUtf8Printable(name) );
7150             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7151               anActor->setName( qUtf8Printable(name) );
7152           }
7153           return true;
7154         }
7155       }
7156     }
7157   }
7158   return false;
7159 }
7160
7161 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7162 {
7163   static QList<QColor> colors;
7164
7165   if ( colors.isEmpty() ) {
7166
7167     for (int s = 0; s < 2 ; s++)
7168     {
7169       for (int v = 100; v >= 40; v = v - 20)
7170       {
7171         for (int h = 0; h < 359 ; h = h + 60)
7172         {
7173           colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7174         }
7175       }
7176     }
7177   }
7178   static int currentColor = randomize( colors.size() );
7179
7180   SALOMEDS::Color color;
7181   color.R = (double)colors[currentColor].red()   / 255.0;
7182   color.G = (double)colors[currentColor].green() / 255.0;
7183   color.B = (double)colors[currentColor].blue()  / 255.0;
7184
7185   currentColor = (currentColor+1) % colors.count();
7186
7187   return color;
7188 }