src/SMESHGUI/SMESHGUI.cxx

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