src/SMESHGUI/SMESHGUI.cxx

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