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