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