src/SMESHGUI/SMESHGUI.cxx

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