src/SMESHGUI/SMESHGUI.cxx

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