src/SMESHGUI/SMESHGUI.cxx

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