src/SMESHGUI/SMESHGUI.cxx

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