src/SMESHGUI/SMESHGUI.cxx

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