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