src/SMESHGUI/SMESHGUI.cxx

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