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