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