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