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", 2 );
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   addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
4754   addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
4755   addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
4756   addPreference( tr( "PREF_DUMP_ADD_INFO"  ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
4757
4758   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4759   setPreferenceProperty( segGroup, "columns", 2 );
4760   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4761                               "SMESH", "segmentation" );
4762   setPreferenceProperty( segLen, "min", 1 );
4763   setPreferenceProperty( segLen, "max", 10000000 );
4764   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4765                              "SMESH", "nb_segments_per_edge" );
4766   setPreferenceProperty( nbSeg, "min", 1 );
4767   setPreferenceProperty( nbSeg, "max", 10000000 );
4768
4769   int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4770   addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4771                  "SMESH", "forget_mesh_on_hyp_modif" );
4772
4773
4774   // Quantities with individual precision settings
4775   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4776   setPreferenceProperty( precGroup, "columns", 2 );
4777
4778   const int nbQuantities = 6;
4779   int precs[nbQuantities], ii = 0;
4780   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4781                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4782   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4783                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4784   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4785                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4786   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4787                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4788   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4789                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4790   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4791                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4792
4793   // Set property for precision value for spinboxes
4794   for ( ii = 0; ii < nbQuantities; ii++ ){
4795     setPreferenceProperty( precs[ii], "min", -14 );
4796     setPreferenceProperty( precs[ii], "max", 14 );
4797     setPreferenceProperty( precs[ii], "precision", 2 );
4798   }
4799
4800   int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4801   setPreferenceProperty( previewGroup, "columns", 2 );
4802   int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4803   setPreferenceProperty( chunkSize, "min",  1 );
4804   setPreferenceProperty( chunkSize, "max",  1000 );
4805   setPreferenceProperty( chunkSize, "step", 50 );
4806
4807   int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4808   addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4809
4810   // Mesh tab ------------------------------------------------------------------------
4811   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4812   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4813   setPreferenceProperty( nodeGroup, "columns", 3 );
4814
4815   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4816
4817   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4818
4819   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4820   QList<QVariant> aMarkerTypeIndicesList;
4821   QList<QVariant> aMarkerTypeIconsList;
4822   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4823     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4824     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4825     aMarkerTypeIndicesList << i;
4826     aMarkerTypeIconsList << pixmap;
4827   }
4828   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4829   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
4830
4831   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4832
4833   QList<QVariant> aMarkerScaleIndicesList;
4834   QStringList     aMarkerScaleValuesList;
4835   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4836     aMarkerScaleIndicesList << i;
4837     aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4838   }
4839   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4840   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4841
4842   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4843   //setPreferenceProperty( elemGroup, "columns", 2 );
4844
4845   int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4846   setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4847   ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
4848   setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
4849   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4850   addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
4851   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4852   addPreference( tr( "PREF_WIREFRAME"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4853
4854
4855   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4856   setPreferenceProperty( grpGroup, "columns", 2 );
4857
4858   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4859   addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
4860
4861   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4862                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4863   int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
4864                              LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
4865   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
4866                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
4867   int outW  = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
4868                              LightApp_Preferences::IntSpin, "SMESH", "outline_width");
4869   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4870                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4871
4872   setPreferenceProperty( size0d, "min", 1 );
4873   setPreferenceProperty( size0d, "max", 10 );
4874
4875   setPreferenceProperty( ballSize, "min", 1 );
4876   setPreferenceProperty( ballSize, "max", 10 );
4877
4878   setPreferenceProperty( elemW, "min", 1 );
4879   setPreferenceProperty( elemW, "max", 5 );
4880
4881   setPreferenceProperty( outW, "min", 1 );
4882   setPreferenceProperty( outW, "max", 5 );
4883
4884   setPreferenceProperty( shrink, "min", 0 );
4885   setPreferenceProperty( shrink, "max", 100 );
4886
4887   int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
4888   setPreferenceProperty( numGroup, "columns", 6 );
4889   QStringList fonts;
4890   fonts << tr( "SMESH_ARIAL" ) << tr( "SMESH_COURIER" ) << tr( "SMESH_TIMES" );
4891   indices.clear(); indices << 0 << 1 << 2;
4892   // ...
4893   addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
4894   int NumNodeSize = addPreference( tr( "PREF_NUMBERING_SIZE" ), numGroup, LightApp_Preferences::IntSpin, "SMESH", "numbering_node_size" );
4895   setPreferenceProperty( NumNodeSize, "min", 1 );
4896   setPreferenceProperty( NumNodeSize, "max", 100 );
4897   int NumFontNode = addPreference( tr( "PREF_NUMBERING_FONT" ), numGroup, LightApp_Preferences::Selector, "SMESH", "numbering_node_font" );
4898   setPreferenceProperty( NumFontNode, "strings", fonts );
4899   setPreferenceProperty( NumFontNode, "indexes", indices );
4900   addPreference( tr( "PREF_NUMBERING_BOLD" ), numGroup, LightApp_Preferences::Bool, "SMESH", "numbering_node_bold" );
4901   addPreference( tr( "PREF_NUMBERING_ITALIC" ), numGroup, LightApp_Preferences::Bool, "SMESH", "numbering_node_italic" );
4902   addPreference( tr( "PREF_NUMBERING_SHADOW" ), numGroup, LightApp_Preferences::Bool, "SMESH", "numbering_node_shadow" );
4903   // ...
4904   addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
4905   int NumElemSize = addPreference( tr( "PREF_NUMBERING_SIZE" ), numGroup, LightApp_Preferences::IntSpin, "SMESH", "numbering_elem_size" );
4906   setPreferenceProperty( NumElemSize, "min", 1 );
4907   setPreferenceProperty( NumElemSize, "max", 100 );
4908   int NumFontElem = addPreference( tr( "PREF_NUMBERING_FONT" ), numGroup, LightApp_Preferences::Selector, "SMESH", "numbering_elem_font" );
4909   setPreferenceProperty( NumFontElem, "strings", fonts );
4910   setPreferenceProperty( NumFontElem, "indexes", indices );
4911   addPreference( tr( "PREF_NUMBERING_BOLD" ), numGroup, LightApp_Preferences::Bool, "SMESH", "numbering_elem_bold" );
4912   addPreference( tr( "PREF_NUMBERING_ITALIC" ), numGroup, LightApp_Preferences::Bool, "SMESH", "numbering_elem_italic" );
4913   addPreference( tr( "PREF_NUMBERING_SHADOW" ), numGroup, LightApp_Preferences::Bool, "SMESH", "numbering_elem_shadow" );
4914
4915   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4916   setPreferenceProperty( orientGroup, "columns", 1 );
4917
4918   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4919   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4920
4921   setPreferenceProperty( orientScale, "min", 0.05 );
4922   setPreferenceProperty( orientScale, "max", 0.5 );
4923   setPreferenceProperty( orientScale, "step", 0.05 );
4924
4925   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4926
4927   // Selection tab ------------------------------------------------------------------------
4928   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4929
4930   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4931   setPreferenceProperty( selGroup, "columns", 2 );
4932
4933   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4934   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4935
4936   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4937   setPreferenceProperty( preGroup, "columns", 2 );
4938
4939   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4940
4941   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4942   setPreferenceProperty( precSelGroup, "columns", 2 );
4943
4944   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4945   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4946   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4947
4948   // Scalar Bar tab ------------------------------------------------------------------------
4949   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4950   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4951   setPreferenceProperty( fontGr, "columns", 2 );
4952
4953   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4954   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4955
4956   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4957   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4958
4959   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4960   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4961
4962   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4963   setPreferenceProperty( numcol, "min", 2 );
4964   setPreferenceProperty( numcol, "max", 256 );
4965
4966   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4967   setPreferenceProperty( numlab, "min", 2 );
4968   setPreferenceProperty( numlab, "max", 65 );
4969
4970   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4971   setPreferenceProperty( orientGr, "columns", 2 );
4972   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4973   QStringList orients;
4974   orients.append( tr( "SMESH_VERTICAL" ) );
4975   orients.append( tr( "SMESH_HORIZONTAL" ) );
4976   indices.clear(); indices.append( 0 ); indices.append( 1 );
4977   setPreferenceProperty( orient, "strings", orients );
4978   setPreferenceProperty( orient, "indexes", indices );
4979
4980   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4981   setPreferenceProperty( posVSizeGr, "columns", 2 );
4982   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4983   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4984   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4985   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4986   setPreferenceProperty( xv, "step", 0.1 );
4987   setPreferenceProperty( xv, "min", 0.0 );
4988   setPreferenceProperty( xv, "max", 1.0 );
4989   setPreferenceProperty( yv, "step", 0.1 );
4990   setPreferenceProperty( yv, "min", 0.0 );
4991   setPreferenceProperty( yv, "max", 1.0 );
4992   setPreferenceProperty( wv, "step", 0.1 );
4993   setPreferenceProperty( wv, "min", 0.0 );
4994   setPreferenceProperty( wv, "max", 1.0 );
4995   setPreferenceProperty( hv, "min", 0.0 );
4996   setPreferenceProperty( hv, "max", 1.0 );
4997   setPreferenceProperty( hv, "step", 0.1 );
4998
4999   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5000   setPreferenceProperty( posHSizeGr, "columns", 2 );
5001   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5002   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5003   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5004   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5005   setPreferenceProperty( xv, "min", 0.0 );
5006   setPreferenceProperty( xv, "max", 1.0 );
5007   setPreferenceProperty( xv, "step", 0.1 );
5008   setPreferenceProperty( xh, "min", 0.0 );
5009   setPreferenceProperty( xh, "max", 1.0 );
5010   setPreferenceProperty( xh, "step", 0.1 );
5011   setPreferenceProperty( yh, "min", 0.0 );
5012   setPreferenceProperty( yh, "max", 1.0 );
5013   setPreferenceProperty( yh, "step", 0.1 );
5014   setPreferenceProperty( wh, "min", 0.0 );
5015   setPreferenceProperty( wh, "max", 1.0 );
5016   setPreferenceProperty( wh, "step", 0.1 );
5017   setPreferenceProperty( hh, "min", 0.0 );
5018   setPreferenceProperty( hh, "max", 1.0 );
5019   setPreferenceProperty( hh, "step", 0.1 );
5020
5021   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5022   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5023   setPreferenceProperty( distributionGr, "columns", 3 );
5024   QStringList types;
5025   types.append( tr( "SMESH_MONOCOLOR" ) );
5026   types.append( tr( "SMESH_MULTICOLOR" ) );
5027   indices.clear(); indices.append( 0 ); indices.append( 1 );
5028   setPreferenceProperty( coloringType, "strings", types );
5029   setPreferenceProperty( coloringType, "indexes", indices );
5030   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5031
5032 }
5033
5034 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5035 {
5036   if( sect=="SMESH" ) {
5037     float sbX1,sbY1,sbW,sbH;
5038     float aTol = 1.00000009999999;
5039     std::string aWarning;
5040     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5041     if( name=="selection_object_color" || name=="selection_element_color" ||
5042         name=="highlight_color" ||
5043         name=="selection_precision_node" || name=="selection_precision_element" ||
5044         name=="selection_precision_object")
5045       SMESH::UpdateSelectionProp( this );
5046     else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5047       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5048       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5049       if(sbX1+sbW > aTol){
5050         aWarning = "Origin and Size Vertical: X+Width > 1\n";
5051         sbX1=0.01;
5052         sbW=0.08;
5053         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5054         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5055       }
5056     }
5057     else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5058       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5059       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5060       if(sbY1+sbH > aTol){
5061         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5062         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5063         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5064       }
5065     }
5066     else if(name ==  QString("scalar_bar_horizontal_x") || name ==  QString("scalar_bar_horizontal_width")){
5067       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5068       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5069       if(sbX1+sbW > aTol){
5070         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5071         sbX1=0.1;
5072         sbW=0.08;
5073         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5074         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5075       }
5076     }
5077     else if(name ==  QString("scalar_bar_horizontal_y") || name ==  QString("scalar_bar_horizontal_height")){
5078       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5079       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5080       if(sbY1+sbH > aTol){
5081         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5082         sbY1=0.01;
5083         sbH=0.08;
5084         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5085         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5086       }
5087     }
5088     else if ( name == "segmentation" ) {
5089       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5090       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5091     }
5092     else if ( name == "nb_segments_per_edge" ) {
5093       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5094       myComponentSMESH->SetDefaultNbSegments( nbSeg );
5095     }
5096     else if ( name == "historical_python_dump" ||
5097               name == "forget_mesh_on_hyp_modif") {
5098       QString val = aResourceMgr->stringValue( "SMESH", name );
5099       myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5100     }
5101     else if(name ==  QString("numbering_node_color")  || name ==  QString("numbering_node_size") ||
5102             name ==  QString("numbering_node_font")   || name ==  QString("numbering_node_bold") ||
5103             name ==  QString("numbering_node_italic") || name ==  QString("numbering_node_shadow") ) {
5104       SMESH::UpdateFontProp( this );
5105     }
5106     else if(name ==  QString("numbering_elem_color")  || name ==  QString("numbering_elem_size") ||
5107             name ==  QString("numbering_elem_font")   || name ==  QString("numbering_elem_bold") ||
5108             name ==  QString("numbering_elem_italic") || name ==  QString("numbering_elem_shadow") ) {
5109       SMESH::UpdateFontProp( this );
5110     }
5111
5112     if(aWarning.size() != 0){
5113       aWarning += "The default values are applied instead.";
5114       SUIT_MessageBox::warning(SMESHGUI::desktop(),
5115                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5116                                QObject::tr(aWarning.c_str()));
5117     }
5118   }
5119 }
5120
5121 //================================================================================
5122 /*!
5123  * \brief Update something in accordance with update flags
5124   * \param theFlags - update flags
5125 *
5126 * Update viewer or/and object browser etc. in accordance with update flags ( see
5127 * LightApp_UpdateFlags enumeration ).
5128 */
5129 //================================================================================
5130 void SMESHGUI::update( const int flags )
5131 {
5132   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5133     SMESH::UpdateView();
5134   else
5135     SalomeApp_Module::update( flags );
5136 }
5137
5138 //================================================================================
5139 /*!
5140  * \brief Set default selection mode
5141 *
5142 * SLOT called when operation commited. Sets default selection mode
5143 */
5144 //================================================================================
5145 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5146 {
5147   SVTK_ViewWindow* vtkWnd =
5148     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5149   if ( vtkWnd )
5150     vtkWnd->SetSelectionMode( ActorSelection );
5151 }
5152
5153 //================================================================================
5154 /*!
5155  * \brief Set default selection mode
5156 *
5157 * SLOT called when operation aborted. Sets default selection mode
5158 */
5159 //================================================================================
5160 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5161 {
5162   SVTK_ViewWindow* vtkWnd =
5163     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5164   if ( vtkWnd )
5165     vtkWnd->SetSelectionMode( ActorSelection );
5166 }
5167
5168 //================================================================================
5169 /*!
5170  * \brief Creates operation with given identifier
5171   * \param id - identifier of operation to be started
5172   * \return Pointer on created operation or NULL if operation is not created
5173 *
5174 * Virtual method redefined from the base class creates operation with given id.
5175 * It is called called automatically from startOperation method of base class.
5176 */
5177 //================================================================================
5178 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5179 {
5180   LightApp_Operation* op = 0;
5181   // to do : create operation here
5182   switch( id )
5183   {
5184     case 417: //convert to quadratic
5185       op = new SMESHGUI_ConvToQuadOp();
5186     break;
5187     case 418: // create 2D mesh as boundary on 3D
5188       op = new SMESHGUI_Make2DFrom3DOp();
5189     break;
5190     case 420: // Reorient faces
5191       op = new SMESHGUI_ReorientFacesOp();
5192       break;
5193     case 701: // Compute mesh
5194       op = new SMESHGUI_ComputeOp();
5195     break;
5196     case 702: // Create mesh
5197       op = new SMESHGUI_MeshOp( true, true );
5198     break;
5199     case 703: // Create sub-mesh
5200       op = new SMESHGUI_MeshOp( true, false );
5201     break;
5202     case 704: // Edit mesh/sub-mesh
5203       op = new SMESHGUI_MeshOp( false );
5204     break;
5205     case 711: // Precompute mesh
5206       op = new SMESHGUI_PrecomputeOp();
5207     break;
5208     case 712: // Evaluate mesh
5209       op = new SMESHGUI_EvaluateOp();
5210     break;
5211     case 713: // Evaluate mesh
5212       op = new SMESHGUI_MeshOrderOp();
5213     break;
5214     case 806: // Create group on geom
5215       op = new SMESHGUI_GroupOnShapeOp();
5216       break;
5217     case 904: // Find element
5218       op = new SMESHGUI_FindElemByPointOp();
5219       break;
5220     case 4067: // Make mesh pass through point
5221       op = new SMESHGUI_MakeNodeAtPointOp();
5222       break;
5223     case 4070: // Create 0D elements on all nodes
5224       op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5225       break;
5226     default:
5227     break;
5228   }
5229
5230   if( !op )
5231     op = SalomeApp_Module::createOperation( id );
5232   return op;
5233 }
5234
5235 //================================================================================
5236 /*!
5237  * \brief Stops current operations and starts a given one
5238   * \param id - The id of the operation to start
5239  */
5240 //================================================================================
5241
5242 void SMESHGUI::switchToOperation(int id)
5243 {
5244   if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5245     activeStudy()->abortAllOperations();
5246   startOperation( id );
5247 }
5248
5249 LightApp_Displayer* SMESHGUI::displayer()
5250 {
5251   if( !myDisplayer )
5252     myDisplayer = new SMESHGUI_Displayer( getApp() );
5253   return myDisplayer;
5254 }
5255
5256 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5257 {
5258   int aHue = -1;
5259   int aTolerance = 64;
5260   int anIterations = 0;
5261   int aPeriod = 5;
5262
5263   while( 1 )
5264   {
5265     anIterations++;
5266     if( anIterations % aPeriod == 0 )
5267     {
5268       aTolerance /= 2;
5269       if( aTolerance < 1 )
5270         break;
5271     }
5272
5273     aHue = (int)( 360.0 * rand() / RAND_MAX );
5274
5275     bool ok = true;
5276     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5277     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5278     for( ; it != itEnd; ++it )
5279     {
5280       SALOMEDS::Color anAutoColor = *it;
5281       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5282
5283       int h, s, v;
5284       aQColor.getHsv( &h, &s, &v );
5285       if( abs( h - aHue ) < aTolerance )
5286       {
5287         ok = false;
5288         break;
5289       }
5290     }
5291
5292     if( ok )
5293       break;
5294   }
5295
5296   QColor aColor;
5297   aColor.setHsv( aHue, 255, 255 );
5298
5299   SALOMEDS::Color aSColor;
5300   aSColor.R = aColor.redF();
5301   aSColor.G = aColor.greenF();
5302   aSColor.B = aColor.blueF();
5303
5304   return aSColor;
5305 }
5306
5307 const char* gSeparator = "_"; // character used to separate parameter names
5308 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5309 const char* gPathSep   = "|"; // character used to separate paths
5310
5311 /*!
5312  * \brief Store visual parameters
5313  *
5314  * This method is called just before the study document is saved.
5315  * Store visual parameters in AttributeParameter attribue(s)
5316  */
5317 void SMESHGUI::storeVisualParameters (int savePoint)
5318 {
5319   // localizing
5320   Kernel_Utils::Localizer loc;
5321
5322   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5323   if (!appStudy || !appStudy->studyDS())
5324     return;
5325   _PTR(Study) studyDS = appStudy->studyDS();
5326
5327   // componentName is used for encoding of entries when storing them in IParameters
5328   std::string componentName = myComponentSMESH->ComponentDataType();
5329   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5330   //if (!aSComponent) return;
5331
5332   // IParameters
5333   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5334                                                              componentName.c_str(),
5335                                                              savePoint);
5336   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5337
5338   // store map of custom markers
5339   const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5340   if( !aMarkerMap.empty() )
5341   {
5342     VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5343     for( ; anIter != aMarkerMap.end(); anIter++ )
5344     {
5345       int anId = anIter->first;
5346       VTK::MarkerData aMarkerData = anIter->second;
5347       std::string aMarkerFileName = aMarkerData.first;
5348       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5349       if( aMarkerTexture.size() < 3 )
5350         continue; // should contain at least width, height and the first value
5351
5352       QString aPropertyName( "texture" );
5353       aPropertyName += gSeparator;
5354       aPropertyName += QString::number( anId );
5355
5356       QString aPropertyValue = aMarkerFileName.c_str();
5357       aPropertyValue += gPathSep;
5358
5359       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5360       ushort aWidth = *aTextureIter++;
5361       ushort aHeight = *aTextureIter++;
5362       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5363       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5364       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5365         aPropertyValue += QString::number( *aTextureIter );
5366
5367       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5368     }
5369   }
5370
5371   // viewers counters are used for storing view_numbers in IParameters
5372   int vtkViewers = 0;
5373
5374   // main cycle to store parameters of displayed objects
5375   QList<SUIT_ViewManager*> lst;
5376   QList<SUIT_ViewManager*>::Iterator it;
5377   getApp()->viewManagers(lst);
5378   for (it = lst.begin(); it != lst.end(); it++)
5379   {
5380     SUIT_ViewManager* vman = *it;
5381     QString vType = vman->getType();
5382
5383     // saving VTK actors properties
5384     if (vType == SVTK_Viewer::Type())
5385     {
5386       // store the clipping planes attached to the view manager
5387       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5388       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5389       if( anIter != myClippingPlaneInfoMap.end() )
5390         aClippingPlaneInfoList = anIter->second;
5391
5392       if( !aClippingPlaneInfoList.empty() ) {
5393         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5394         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5395         {
5396           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5397           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5398
5399           QString aPropertyName( "ClippingPlane" );
5400           aPropertyName += gSeparator;
5401           aPropertyName += QString::number( vtkViewers );
5402           aPropertyName += gSeparator;
5403           aPropertyName += QString::number( anId );
5404
5405           QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5406           aPropertyValue += gDigitsSep;
5407           aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5408           aPropertyValue += gDigitsSep;
5409           aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5410           aPropertyValue += gDigitsSep;
5411           aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5412
5413           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5414         }
5415       }
5416
5417       QVector<SUIT_ViewWindow*> views = vman->getViews();
5418       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5419       {
5420         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5421         {
5422           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5423           vtkActorCollection* allActors = aCopy.GetActors();
5424           allActors->InitTraversal();
5425           while (vtkActor* actor = allActors->GetNextActor())
5426           {
5427             if (actor->GetVisibility()) // store only visible actors
5428             {
5429               SMESH_Actor* aSmeshActor = 0;
5430               if (actor->IsA("SMESH_Actor"))
5431                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5432               if (aSmeshActor && aSmeshActor->hasIO())
5433               {
5434                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5435                 if (io->hasEntry())
5436                 {
5437                   // entry is "encoded" = it does NOT contain component adress,
5438                   // since it is a subject to change on next component loading
5439                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5440
5441                   std::string param, vtkParam = vType.toLatin1().data();
5442                   vtkParam += gSeparator;
5443                   vtkParam += QString::number(vtkViewers).toLatin1().data();
5444                   vtkParam += gSeparator;
5445
5446                   // Visibility
5447                   param = vtkParam + "Visibility";
5448                   ip->setParameter(entry, param, "On");
5449
5450                   // Representation
5451                   param = vtkParam + "Representation";
5452                   ip->setParameter(entry, param, QString::number
5453                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5454
5455                   // IsShrunk
5456                   param = vtkParam + "IsShrunk";
5457                   ip->setParameter(entry, param, QString::number
5458                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5459
5460                   // Displayed entities
5461                   unsigned int aMode = aSmeshActor->GetEntityMode();
5462                   bool isE  = aMode & SMESH_Actor::eEdges;
5463                   bool isF  = aMode & SMESH_Actor::eFaces;
5464                   bool isV  = aMode & SMESH_Actor::eVolumes;
5465                   bool is0d = aMode & SMESH_Actor::e0DElements;
5466                   bool isB  = aMode & SMESH_Actor::eBallElem;
5467
5468                   QString modeStr ("e");
5469                   modeStr += gDigitsSep; modeStr += QString::number(isE);
5470                   modeStr += gDigitsSep; modeStr += "f";
5471                   modeStr += gDigitsSep; modeStr += QString::number(isF);
5472                   modeStr += gDigitsSep; modeStr += "v";
5473                   modeStr += gDigitsSep; modeStr += QString::number(isV);
5474                   modeStr += gDigitsSep; modeStr += "0d";
5475                   modeStr += gDigitsSep; modeStr += QString::number(is0d);
5476                   modeStr += gDigitsSep; modeStr += "b";
5477                   modeStr += gDigitsSep; modeStr += QString::number(isB);
5478
5479                   param = vtkParam + "Entities";
5480                   ip->setParameter(entry, param, modeStr.toLatin1().data());
5481
5482                   // Colors
5483                   vtkFloatingPointType r, g, b;
5484                   int delta;
5485
5486                   aSmeshActor->GetSufaceColor(r, g, b, delta);
5487                   QStringList colorStr;
5488                   colorStr << "surface";
5489                   colorStr << QString::number(r);
5490                   colorStr << QString::number(g);
5491                   colorStr << QString::number(b);
5492
5493                   colorStr << "backsurface";
5494                   colorStr << QString::number(delta);
5495
5496                   aSmeshActor->GetVolumeColor(r, g, b, delta);
5497                   colorStr << "volume";
5498                   colorStr << QString::number(r);
5499                   colorStr << QString::number(g);
5500                   colorStr << QString::number(b);
5501                   colorStr << QString::number(delta);
5502
5503                   aSmeshActor->GetEdgeColor(r, g, b);
5504                   colorStr << "edge";
5505                   colorStr << QString::number(r);
5506                   colorStr << QString::number(g);
5507                   colorStr << QString::number(b);
5508
5509                   aSmeshActor->GetNodeColor(r, g, b);
5510                   colorStr << "node";
5511                   colorStr << QString::number(r);
5512                   colorStr << QString::number(g);
5513                   colorStr << QString::number(b);
5514
5515                   aSmeshActor->GetOutlineColor(r, g, b);
5516                   colorStr << "outline";
5517                   colorStr << QString::number(r);
5518                   colorStr << QString::number(g);
5519                   colorStr << QString::number(b);
5520
5521                   aSmeshActor->Get0DColor(r, g, b);
5522                   colorStr << "elem0d";
5523                   colorStr << QString::number(r);
5524                   colorStr << QString::number(g);
5525                   colorStr << QString::number(b);
5526
5527                   aSmeshActor->GetBallColor(r, g, b);
5528                   colorStr << "ball";
5529                   colorStr << QString::number(r);
5530                   colorStr << QString::number(g);
5531                   colorStr << QString::number(b);
5532
5533                   aSmeshActor->GetFacesOrientationColor(r, g, b);
5534                   colorStr << "orientation";
5535                   colorStr << QString::number(r);
5536                   colorStr << QString::number(g);
5537                   colorStr << QString::number(b);
5538
5539                   param = vtkParam + "Colors";
5540                   ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5541
5542                   // Sizes
5543                   QStringList sizeStr;
5544                   sizeStr << "line";
5545                   sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5546                   sizeStr << "outline";
5547                   sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5548                   sizeStr << "elem0d";
5549                   sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5550                   sizeStr << "ball";
5551                   sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5552                   sizeStr << "shrink";
5553                   sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5554                   sizeStr << "orientation";
5555                   sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5556                   sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5557
5558                   param = vtkParam + "Sizes";
5559                   ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5560
5561                   // Point marker
5562                   QString markerStr;
5563
5564                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5565                   if( aMarkerType == VTK::MT_USER ) {
5566                     markerStr += "custom";
5567                     markerStr += gDigitsSep;
5568                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5569                   }
5570                   else {
5571                     markerStr += "std";
5572                     markerStr += gDigitsSep;
5573                     markerStr += QString::number( (int)aMarkerType );
5574                     markerStr += gDigitsSep;
5575                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5576                   }
5577
5578                   param = vtkParam + "PointMarker";
5579                   ip->setParameter(entry, param, markerStr.toLatin1().data());
5580
5581                   // Opacity
5582                   param = vtkParam + "Opacity";
5583                   ip->setParameter(entry, param,
5584                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5585
5586                   // Clipping
5587                   param = vtkParam + "ClippingPlane";
5588                   int aPlaneId = 0;
5589                   if( !aClippingPlaneInfoList.empty() ) {
5590                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5591                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5592                     {
5593                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5594                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5595                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
5596                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5597                         if( aSmeshActor == *anIter2 ) {
5598                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5599                                             QString::number( anId ).toLatin1().constData() );
5600                           break;
5601                         }
5602                       }
5603                     }
5604                   }
5605                   if( aPlaneId == 0 )
5606                     ip->setParameter( entry, param, "Off" );
5607                 } // if (io->hasEntry())
5608               } // SMESH_Actor && hasIO
5609             } // isVisible
5610           } // while.. actors traversal
5611         } // if (vtkView)
5612       } // for (views)
5613       vtkViewers++;
5614     } // if (SVTK view model)
5615   } // for (viewManagers)
5616 }
5617
5618 // data structures for clipping planes processing
5619 typedef struct {
5620   int Id;
5621   vtkIdType Orientation;
5622   vtkFloatingPointType Distance;
5623   vtkFloatingPointType Angle[2];
5624 } TPlaneData;
5625 typedef std::list<TPlaneData>         TPlaneDataList;
5626 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5627
5628 typedef std::list<vtkActor*>          TActorList;
5629 typedef struct {
5630   int PlaneId;
5631   TActorList ActorList;
5632   SUIT_ViewManager* ViewManager;
5633 } TPlaneInfo;
5634 typedef std::list<TPlaneInfo>         TPlaneInfoList;
5635 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5636
5637 /*!
5638  * \brief Restore visual parameters
5639  *
5640  * This method is called after the study document is opened.
5641  * Restore visual parameters from AttributeParameter attribue(s)
5642  */
5643 void SMESHGUI::restoreVisualParameters (int savePoint)
5644 {
5645   // localizing
5646   Kernel_Utils::Localizer loc;
5647
5648   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5649   if (!appStudy || !appStudy->studyDS())
5650     return;
5651   _PTR(Study) studyDS = appStudy->studyDS();
5652
5653   // componentName is used for encoding of entries when storing them in IParameters
5654   std::string componentName = myComponentSMESH->ComponentDataType();
5655   //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5656   //if (!aSComponent) return;
5657
5658   // IParameters
5659   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5660                                                              componentName.c_str(),
5661                                                              savePoint);
5662   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5663
5664   // restore map of custom markers and map of clipping planes
5665   VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5666   TPlaneDataMap aPlaneDataMap;
5667
5668   std::vector<std::string> properties = ip->getProperties();
5669   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5670   {
5671     std::string property = *propIt;
5672     QString aPropertyName( property.c_str() );
5673     QString aPropertyValue( ip->getProperty( property ).c_str() );
5674
5675     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5676     if( aPropertyNameList.isEmpty() )
5677       continue;
5678
5679     QString aPropertyType = aPropertyNameList[0];
5680     if( aPropertyType == "texture" )
5681     {
5682       if( aPropertyNameList.size() != 2 )
5683         continue;
5684
5685       bool ok = false;
5686       int anId = aPropertyNameList[1].toInt( &ok );
5687       if( !ok || anId < 1 )
5688         continue;
5689
5690       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5691       if( aPropertyValueList.size() != 2 )
5692         continue;
5693
5694       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5695       QString aMarkerTextureString = aPropertyValueList[1];
5696       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5697       if( aMarkerTextureStringList.size() != 3 )
5698         continue;
5699
5700       ok = false;
5701       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5702       if( !ok )
5703         continue;
5704
5705       ok = false;
5706       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5707       if( !ok )
5708         continue;
5709
5710       VTK::MarkerTexture aMarkerTexture;
5711       aMarkerTexture.push_back( aWidth );
5712       aMarkerTexture.push_back( aHeight );
5713
5714       QString aMarkerTextureData = aMarkerTextureStringList[2];
5715       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5716       {
5717         QChar aChar = aMarkerTextureData.at( i );
5718         if( aChar.isDigit() )
5719           aMarkerTexture.push_back( aChar.digitValue() );
5720       }
5721
5722       aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5723     }
5724     else if( aPropertyType == "ClippingPlane" )
5725     {
5726       if( aPropertyNameList.size() != 3 )
5727         continue;
5728
5729       bool ok = false;
5730       int aViewId = aPropertyNameList[1].toInt( &ok );
5731       if( !ok || aViewId < 0 )
5732         continue;
5733
5734       ok = false;
5735       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5736       if( !ok || aClippingPlaneId < 0 )
5737         continue;
5738
5739       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5740       if( aPropertyValueList.size() != 4 )
5741         continue;
5742
5743       TPlaneData aPlaneData;
5744       aPlaneData.Id = aClippingPlaneId;
5745
5746       ok = false;
5747       aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5748       if( !ok )
5749         continue;
5750
5751       ok = false;
5752       aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5753       if( !ok )
5754         continue;
5755
5756       ok = false;
5757       aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5758       if( !ok )
5759         continue;
5760
5761       ok = false;
5762       aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5763       if( !ok )
5764         continue;
5765
5766       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5767       aPlaneDataList.push_back( aPlaneData );
5768     }
5769   }
5770
5771   TPlaneInfoMap aPlaneInfoMap;
5772
5773   std::vector<std::string> entries = ip->getEntries();
5774
5775   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5776   {
5777     // entry is a normal entry - it should be "decoded" (setting base adress of component)
5778     QString entry (ip->decodeEntry(*entIt).c_str());
5779
5780     // Check that the entry corresponds to a real object in the Study
5781     // as the object may be deleted or modified after the visual state is saved.
5782     _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5783     if (!so) continue; //Skip the not existent entry
5784
5785     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5786     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5787
5788     std::vector<std::string>::iterator namesIt = paramNames.begin();
5789     std::vector<std::string>::iterator valuesIt = paramValues.begin();
5790
5791     // actors are stored in a map after displaying of them for
5792     // quicker access in the future: map < viewID to actor >
5793     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5794
5795     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5796     {
5797       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5798       // '_' is used as separator and should not be used in viewer type or parameter names.
5799       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5800       if (lst.size() != 3)
5801         continue;
5802
5803       QString viewerTypStr = lst[0];
5804       QString viewIndexStr = lst[1];
5805       QString paramNameStr = lst[2];
5806
5807       bool ok;
5808       int viewIndex = viewIndexStr.toUInt(&ok);
5809       if (!ok) // bad conversion of view index to integer
5810         continue;
5811
5812       // viewers
5813       if (viewerTypStr == SVTK_Viewer::Type())
5814       {
5815         SMESH_Actor* aSmeshActor = 0;
5816         if (vtkActors.IsBound(viewIndex))
5817           aSmeshActor = vtkActors.Find(viewIndex);
5818
5819         QList<SUIT_ViewManager*> lst;
5820         getApp()->viewManagers(viewerTypStr, lst);
5821
5822         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5823         SUIT_ViewManager* vman = NULL;
5824         if (viewIndex >= 0 && viewIndex < lst.count())
5825           vman = lst.at(viewIndex);
5826
5827         if (paramNameStr == "Visibility")
5828         {
5829           if (!aSmeshActor && displayer() && vman)
5830           {
5831             SUIT_ViewModel* vmodel = vman->getViewModel();
5832             // SVTK view model can be casted to SALOME_View
5833             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5834
5835             // store displayed actor in a temporary map for quicker
5836             // access later when restoring other parameters
5837             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5838             vtkRenderer* Renderer = vtkView->getRenderer();
5839             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5840             vtkActorCollection* theActors = aCopy.GetActors();
5841             theActors->InitTraversal();
5842             bool isFound = false;
5843             vtkActor *ac = theActors->GetNextActor();
5844             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5845               if (ac->IsA("SMESH_Actor")) {
5846                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5847                 if (aGeomAc->hasIO()) {
5848                   Handle(SALOME_InteractiveObject) io =
5849                     Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5850                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5851                     isFound = true;
5852                     vtkActors.Bind(viewIndex, aGeomAc);
5853                   }
5854                 }
5855               }
5856             }
5857           }
5858         } // if (paramNameStr == "Visibility")
5859         else
5860         {
5861           // the rest properties "work" with SMESH_Actor
5862           if (aSmeshActor)
5863           {
5864             QString val ((*valuesIt).c_str());
5865
5866             // Representation
5867             if (paramNameStr == "Representation") {
5868               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5869             }
5870             // IsShrunk
5871             else if (paramNameStr == "IsShrunk") {
5872               if (val.toInt()) {
5873                 if (!aSmeshActor->IsShrunk())
5874                   aSmeshActor->SetShrink();
5875               }
5876               else {
5877                 if (aSmeshActor->IsShrunk())
5878                   aSmeshActor->UnShrink();
5879               }
5880             }
5881             // Displayed entities
5882             else if (paramNameStr == "Entities") {
5883               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5884               int aEntityMode = SMESH_Actor::eAllEntity;
5885               for ( int i = 0; i < mode.count(); i+=2 ) {
5886                 if ( i < mode.count()-1 ) {
5887                   QString type = mode[i];
5888                   bool val = mode[i+1].toInt();
5889                   if      ( type == "e" && !val )
5890                     aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
5891                   else if ( type == "f" && !val )
5892                     aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
5893                   else if ( type == "v" && !val )
5894                     aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
5895                   else if ( type == "0d" && !val )
5896                     aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
5897                   else if ( type == "b" && !val )
5898                     aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
5899                 }
5900               }
5901               aSmeshActor->SetEntityMode( aEntityMode );
5902             }
5903             // Colors
5904             else if (paramNameStr == "Colors") {
5905               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5906               QColor nodeColor;
5907               QColor edgeColor;
5908               QColor faceColor;
5909               QColor volumeColor;
5910               QColor elem0dColor;
5911               QColor ballColor;
5912               QColor outlineColor;
5913               QColor orientationColor;
5914               int deltaF;
5915               int deltaV;
5916               QColor c;
5917               double r, g, b;
5918               bool bOk;
5919               // below lines are required to get default values for delta coefficients
5920               // of backface color for faces and color of reversed volumes
5921               SMESH::GetColor( "SMESH", "fill_color",   c, deltaF, "0,170,255|-100" );
5922               SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
5923               for ( int i = 0; i < colors.count(); i++ ) {
5924                 QString type = colors[i];
5925                 if ( type == "surface" ) {
5926                   // face color is set by 3 values r:g:b, where
5927                   // - r,g,b - is rgb color components
5928                   if ( i+1 >= colors.count() ) break;                  // format error
5929                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5930                   if ( i+2 >= colors.count() ) break;                  // format error
5931                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5932                   if ( i+3 >= colors.count() ) break;                  // format error
5933                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5934                   faceColor.setRgbF( r, g, b );
5935                   i += 3;
5936                 }
5937                 else if ( type == "backsurface" ) {
5938                   // backface color can be defined in several ways
5939                   // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
5940                   // - in latest versions, it is set as delta coefficient
5941                   bool rgbOk = false, deltaOk;
5942                   if ( i+1 >= colors.count() ) break;                  // format error
5943                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5944                   int delta = colors[i+1].toInt( &deltaOk );
5945                   i++;                                 // shift index
5946                   if ( i+1 < colors.count() )          // index is shifted to 1
5947                     g = colors[i+1].toDouble( &rgbOk );
5948                   if ( rgbOk ) i++;                    // shift index
5949                   if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
5950                     b = colors[i+1].toDouble( &rgbOk );
5951                   if ( rgbOk ) i++;
5952                   // - as currently there's no way to set directly backsurface color as it was before,
5953                   // we ignore old dump where r,g,b triple was set
5954                   // - also we check that delta parameter is set properly
5955                   if ( !rgbOk && deltaOk )
5956                     deltaF = delta;
5957                 }
5958                 else if ( type == "volume" ) {
5959                   // volume color is set by 4 values r:g:b:delta, where
5960                   // - r,g,b - is a normal volume rgb color components
5961                   // - delta - is a reversed volume color delta coefficient
5962                   if ( i+1 >= colors.count() ) break;                  // format error
5963                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5964                   if ( i+2 >= colors.count() ) break;                  // format error
5965                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5966                   if ( i+3 >= colors.count() ) break;                  // format error
5967                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5968                   if ( i+4 >= colors.count() ) break;                  // format error
5969                   int delta = colors[i+4].toInt( &bOk );
5970                   if ( !bOk ) break;                                   // format error
5971                   volumeColor.setRgbF( r, g, b );
5972                   deltaV = delta;
5973                   i += 4;
5974                 }
5975                 else if ( type == "edge" ) {
5976                   // edge color is set by 3 values r:g:b, where
5977                   // - r,g,b - is rgb color components
5978                   if ( i+1 >= colors.count() ) break;                  // format error
5979                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5980                   if ( i+2 >= colors.count() ) break;                  // format error
5981                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5982                   if ( i+3 >= colors.count() ) break;                  // format error
5983                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5984                   edgeColor.setRgbF( r, g, b );
5985                   i += 3;
5986                 }
5987                 else if ( type == "node" ) {
5988                   // node color is set by 3 values r:g:b, where
5989                   // - r,g,b - is rgb color components
5990                   if ( i+1 >= colors.count() ) break;                  // format error
5991                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5992                   if ( i+2 >= colors.count() ) break;                  // format error
5993                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5994                   if ( i+3 >= colors.count() ) break;                  // format error
5995                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5996                   nodeColor.setRgbF( r, g, b );
5997                   i += 3;
5998                 }
5999                 else if ( type == "elem0d" ) {
6000                   // 0d element color is set by 3 values r:g:b, where
6001                   // - r,g,b - is rgb color components
6002                   if ( i+1 >= colors.count() ) break;                  // format error
6003                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6004                   if ( i+2 >= colors.count() ) break;                  // format error
6005                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6006                   if ( i+3 >= colors.count() ) break;                  // format error
6007                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6008                   elem0dColor.setRgbF( r, g, b );
6009                   i += 3;
6010                 }
6011                 else if ( type == "ball" ) {
6012                   // ball color is set by 3 values r:g:b, where
6013                   // - r,g,b - is rgb color components
6014                   if ( i+1 >= colors.count() ) break;                  // format error
6015                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6016                   if ( i+2 >= colors.count() ) break;                  // format error
6017                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6018                   if ( i+3 >= colors.count() ) break;                  // format error
6019                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6020                   ballColor.setRgbF( r, g, b );
6021                   i += 3;
6022                 }
6023                 else if ( type == "outline" ) {
6024                   // outline color is set by 3 values r:g:b, where
6025                   // - r,g,b - is rgb color components
6026                   if ( i+1 >= colors.count() ) break;                  // format error
6027                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6028                   if ( i+2 >= colors.count() ) break;                  // format error
6029                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6030                   if ( i+3 >= colors.count() ) break;                  // format error
6031                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6032                   outlineColor.setRgbF( r, g, b );
6033                   i += 3;
6034                 }
6035                 else if ( type == "orientation" ) {
6036                   // orientation color is set by 3 values r:g:b, where
6037                   // - r,g,b - is rgb color components
6038                   if ( i+1 >= colors.count() ) break;                  // format error
6039                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6040                   if ( i+2 >= colors.count() ) break;                  // format error
6041                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6042                   if ( i+3 >= colors.count() ) break;                  // format error
6043                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6044                   orientationColor.setRgbF( r, g, b );
6045                   i += 3;
6046                 }
6047               }
6048               // node color
6049               if ( nodeColor.isValid() )
6050                 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6051               // edge color
6052               if ( edgeColor.isValid() )
6053                 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6054               // face color
6055               if ( faceColor.isValid() )
6056                 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6057               // volume color
6058               if ( volumeColor.isValid() )
6059                 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6060               else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6061                 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6062               // 0d element color
6063               if ( elem0dColor.isValid() )
6064                 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6065               // ball color
6066               if ( ballColor.isValid() )
6067                 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6068               // outline color
6069               if ( outlineColor.isValid() )
6070                 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6071               // orientation color
6072               if ( orientationColor.isValid() )
6073                 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6074             }
6075             // Sizes
6076             else if (paramNameStr == "Sizes") {
6077               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6078               bool bOk;
6079               int lineWidth = -1;
6080               int outlineWidth = -1;
6081               int elem0dSize = -1;
6082               int ballSize = -1;
6083               double shrinkSize = -1;
6084               double orientationSize = -1;
6085               bool orientation3d = false;
6086               for ( int i = 0; i < sizes.count(); i++ ) {
6087                 QString type = sizes[i];
6088                 if ( type == "line" ) {
6089                   // line (wireframe) width is given as single integer value
6090                   if ( i+1 >= sizes.count() ) break;                    // format error
6091                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6092                   lineWidth = v;
6093                   i++;
6094                 }
6095                 if ( type == "outline" ) {
6096                   // outline width is given as single integer value
6097                   if ( i+1 >= sizes.count() ) break;                    // format error
6098                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6099                   outlineWidth = v;
6100                   i++;
6101                 }
6102                 else if ( type == "elem0d" ) {
6103                   // 0d element size is given as single integer value
6104                   if ( i+1 >= sizes.count() ) break;                    // format error
6105                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6106                   elem0dSize = v;
6107                   i++;
6108                 }
6109                 else if ( type == "ball" ) {
6110                   // ball size is given as single integer value
6111                   if ( i+1 >= sizes.count() ) break;                    // format error
6112                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6113                   ballSize = v;
6114                   i++;
6115                 }
6116                 else if ( type == "shrink" ) {
6117                   // shrink factor is given as single floating point value
6118                   if ( i+1 >= sizes.count() ) break;                          // format error
6119                   double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break;  // format error
6120                   shrinkSize = v;
6121                   i++;
6122                 }
6123                 else if ( type == "orientation" ) {
6124                   // orientation vectors are specified by two values size:3d, where
6125                   // - size - is a floating point value specifying scale factor
6126                   // - 3d - is a boolean
6127                   if ( i+1 >= sizes.count() ) break;                          // format error
6128                   double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6129                   if ( i+2 >= sizes.count() ) break;                          // format error
6130                   int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break;       // format error
6131                   orientationSize = v1;
6132                   orientation3d = (bool)v2;
6133                   i += 2;
6134                 }
6135               }
6136               // line (wireframe) width
6137               if ( lineWidth > 0 )
6138                 aSmeshActor->SetLineWidth( lineWidth );
6139               // outline width
6140               if ( outlineWidth > 0 )
6141                 aSmeshActor->SetOutlineWidth( outlineWidth );
6142               else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6143                 aSmeshActor->SetOutlineWidth( lineWidth );
6144               // 0d element size
6145               if ( elem0dSize > 0 )
6146                 aSmeshActor->Set0DSize( elem0dSize );
6147               // ball size
6148               if ( ballSize > 0 )
6149                 aSmeshActor->SetBallSize( ballSize );
6150               // shrink factor
6151               if ( shrinkSize > 0 )
6152                 aSmeshActor->SetShrinkFactor( shrinkSize );
6153               // orientation vectors
6154               if ( orientationSize > 0 ) {
6155                 aSmeshActor->SetFacesOrientationScale( orientationSize );
6156                 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6157               }
6158             }
6159             // Point marker
6160             else if (paramNameStr == "PointMarker") {
6161               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6162               if( data.count() >= 2 ) {
6163                 bool ok = false;
6164                 int aParam1 = data[1].toInt( &ok );
6165                 if( ok ) {
6166                   if( data[0] == "std" && data.count() == 3 ) {
6167                     int aParam2 = data[2].toInt( &ok );
6168                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6169                   }
6170                   else if( data[0] == "custom" ) {
6171                     VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6172                     if( markerIt != aMarkerMap.end() ) {
6173                       VTK::MarkerData aMarkerData = markerIt->second;
6174                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6175                     }
6176                   }
6177                 }
6178               }
6179             }
6180             // Opacity
6181             else if (paramNameStr == "Opacity") {
6182               aSmeshActor->SetOpacity(val.toFloat());
6183             }
6184             // Clipping
6185             else if (paramNameStr.startsWith("ClippingPlane")) {
6186               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6187               // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
6188               // new format - val looks like "Off" or "0" (plane id)
6189               // (note: in new format "Off" value is used only for consistency,
6190               //  so it is processed together with values in old format)
6191               bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
6192               if( anIsOldFormat ) {
6193                 if (paramNameStr == "ClippingPlane1" || val == "Off")
6194                   aSmeshActor->RemoveAllClippingPlanes();
6195                 if (val != "Off") {
6196                   SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
6197                   double aDistance = vals[1].toFloat();
6198                   vtkFloatingPointType anAngle[2];
6199                   anAngle[0] = vals[2].toFloat();
6200                   anAngle[1] = vals[3].toFloat();
6201
6202                   QList<SUIT_ViewManager*> lst;
6203                   getApp()->viewManagers(viewerTypStr, lst);
6204                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6205                   if (viewIndex >= 0 && viewIndex < lst.count()) {
6206                     SUIT_ViewManager* vman = lst.at(viewIndex);
6207                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6208
6209                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6210
6211                     SMESH::TActorList anActorList;
6212                     anActorList.push_back( aSmeshActor );
6213                     SMESH::OrientedPlane* aPlane =
6214                       SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
6215                     if( aPlane ) {
6216                       SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6217                       aClippingPlaneInfo.Plane = aPlane;
6218                       aClippingPlaneInfo.ActorList = anActorList;
6219                       aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6220                     }
6221                   }
6222                 }
6223               }
6224               else {
6225                 bool ok = false;
6226                 int aPlaneId = val.toInt( &ok );
6227                 if( ok && aPlaneId >= 0 ) {
6228                   bool anIsDefinedPlane = false;
6229                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6230                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6231                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6232                     TPlaneInfo& aPlaneInfo = *anIter;
6233                     if( aPlaneInfo.PlaneId == aPlaneId ) {
6234                       aPlaneInfo.ActorList.push_back( aSmeshActor );
6235                       anIsDefinedPlane = true;
6236                       break;
6237                     }
6238                   }
6239                   if( !anIsDefinedPlane ) {
6240                     TPlaneInfo aPlaneInfo;
6241                     aPlaneInfo.PlaneId = aPlaneId;
6242                     aPlaneInfo.ActorList.push_back( aSmeshActor );
6243                     aPlaneInfo.ViewManager = vman;
6244
6245                     // to make the list sorted by plane id
6246                     anIter = aPlaneInfoList.begin();
6247                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6248                       const TPlaneInfo& aPlaneInfoRef = *anIter;
6249                       if( aPlaneInfoRef.PlaneId > aPlaneId )
6250                         break;
6251                     }
6252                     aPlaneInfoList.insert( anIter, aPlaneInfo );
6253                   }
6254                 }
6255               }
6256             }
6257           } // if (aSmeshActor)
6258         } // other parameters than Visibility
6259       }
6260     } // for names/parameters iterator
6261   } // for entries iterator
6262
6263   // take into account planes with empty list of actors referred to them
6264   QList<SUIT_ViewManager*> aVMList;
6265   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6266
6267   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6268   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6269     int aViewId = aPlaneDataIter->first;
6270     if( aViewId >= 0 && aViewId < aVMList.count() ) {
6271       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6272
6273       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6274
6275       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6276       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6277       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6278         const TPlaneData& aPlaneData = *anIter2;
6279         int aPlaneId = aPlaneData.Id;
6280
6281         bool anIsFound = false;
6282         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6283         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6284           const TPlaneInfo& aPlaneInfo = *anIter3;
6285           if( aPlaneInfo.PlaneId == aPlaneId ) {
6286             anIsFound = true;
6287             break;
6288           }
6289         }
6290
6291         if( !anIsFound ) {
6292           TPlaneInfo aPlaneInfo; // ActorList field is empty
6293           aPlaneInfo.PlaneId = aPlaneId;
6294           aPlaneInfo.ViewManager = aViewManager;
6295
6296           // to make the list sorted by plane id
6297           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6298           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6299             const TPlaneInfo& aPlaneInfoRef = *anIter4;
6300             if( aPlaneInfoRef.PlaneId > aPlaneId )
6301               break;
6302           }
6303           aPlaneInfoList.insert( anIter4, aPlaneInfo );
6304         }
6305       }
6306     }
6307   }
6308
6309   // add clipping planes to actors according to the restored parameters
6310   // and update the clipping plane map
6311   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6312   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6313     int aViewId = anIter1->first;
6314     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6315
6316     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6317     if( anIter2 == aPlaneDataMap.end() )
6318       continue;
6319     const TPlaneDataList& aPlaneDataList = anIter2->second;
6320
6321     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6322     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6323       const TPlaneInfo& aPlaneInfo = *anIter3;
6324       int aPlaneId = aPlaneInfo.PlaneId;
6325       const TActorList& anActorList = aPlaneInfo.ActorList;
6326       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6327       if( !aViewManager )
6328         continue;
6329
6330       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6331       if( !aViewWindow )
6332         continue;
6333
6334       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6335
6336       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6337       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6338         const TPlaneData& aPlaneData = *anIter4;
6339         if( aPlaneData.Id == aPlaneId ) {
6340           SMESH::OrientedPlane* aPlane =
6341             SMESHGUI_ClippingDlg::AddPlane( anActorList,
6342                                             aViewWindow,
6343                                             (SMESH::Orientation)aPlaneData.Orientation,
6344                                             aPlaneData.Distance,
6345                                             aPlaneData.Angle );
6346           if( aPlane ) {
6347             SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6348             aClippingPlaneInfo.Plane = aPlane;
6349             aClippingPlaneInfo.ActorList = anActorList;
6350             aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6351           }
6352           break;
6353         }
6354       }
6355     }
6356   }
6357
6358   // update all VTK views
6359   QList<SUIT_ViewManager*> lst;
6360   getApp()->viewManagers(lst);
6361   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6362     SUIT_ViewModel* vmodel = (*it)->getViewModel();
6363     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6364       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6365       vtkView->getRenderer()->ResetCameraClippingRange();
6366       vtkView->Repaint();
6367     }
6368   }
6369 }
6370
6371 /*!
6372   \brief Adds preferences for dfont of VTK viewer
6373   \param label label
6374   \param pIf group identifier
6375   \param param parameter
6376   \return identifier of preferences
6377 */
6378 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
6379 {
6380   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6381
6382   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6383
6384   QStringList fam;
6385   fam.append( tr( "SMESH_FONT_ARIAL" ) );
6386   fam.append( tr( "SMESH_FONT_COURIER" ) );
6387   fam.append( tr( "SMESH_FONT_TIMES" ) );
6388
6389   setPreferenceProperty( tfont, "fonts", fam );
6390
6391   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6392   setPreferenceProperty( tfont, "features", f );
6393
6394   return tfont;
6395 }
6396
6397 /*!
6398   \brief Actions after hypothesis edition
6399   Updates object browser after hypothesis edition
6400 */
6401 void SMESHGUI::onHypothesisEdit( int result )
6402 {
6403   if( result == 1 )
6404     SMESHGUI::Modified();
6405   updateObjBrowser( true );
6406 }
6407
6408
6409 /*!
6410   \brief Signal handler closing(SUIT_ViewWindow*) of a view
6411   \param pview view being closed
6412 */
6413 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6414 #ifndef DISABLE_PLOT2DVIEWER
6415   //Crear all Plot2d Viewers if need.
6416   SMESH::ClearPlot2Viewers(pview);
6417 #endif
6418 }
6419
6420 void SMESHGUI::message( const QString& msg )
6421 {
6422   // dispatch message
6423   QStringList data = msg.split("/");
6424   if ( data.count() > 0 ) {
6425     if ( data.first() == "mesh_loading" ) {
6426       // get mesh entry
6427       QString entry = data.count() > 1 ? data[1] : QString();
6428       if ( entry.isEmpty() )
6429         return;
6430       // get study
6431       _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6432       // get mesh name
6433       _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6434       QString name;
6435       if ( obj )
6436         name = obj->GetName().c_str();
6437       if ( name.isEmpty() )
6438         return;
6439
6440       if ( data.last() == "stop" )
6441         application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6442       else
6443         application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6444       QApplication::processEvents();
6445     }
6446   }
6447 }
6448
6449 /*!
6450   \brief Connects or disconnects signals about activating and cloning view on the module slots
6451   \param pview view which is connected/disconnected
6452 */
6453 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6454   if(!pview)
6455     return;
6456
6457   SUIT_ViewManager* viewMgr = pview->getViewManager();
6458   if ( viewMgr ) {
6459     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6460                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6461
6462     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6463              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6464   }
6465 }
6466
6467 /*!
6468   \brief Return \c true if object can be renamed
6469 */
6470 bool SMESHGUI::renameAllowed( const QString& entry) const {
6471   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6472   if( !anApp )
6473     return false;
6474
6475   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6476   if( !appStudy )
6477     return false;
6478
6479   SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6480
6481   if(!obj)
6482     return false;
6483
6484   if(appStudy->isComponent(entry) || obj->isReference())
6485     return false;
6486
6487   // check type to prevent renaming of inappropriate objects
6488   int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6489   if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6490       aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6491       aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6492       aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6493       aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6494     return true;
6495
6496   return false;
6497 }
6498
6499 /*!
6500   Rename object by entry.
6501   \param entry entry of the object
6502   \param name new name of the object
6503   \brief Return \c true if rename operation finished successfully, \c false otherwise.
6504 */
6505 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6506
6507   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6508   if( !anApp )
6509     return false;
6510
6511   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6512
6513   if(!appStudy)
6514     return false;
6515
6516   _PTR(Study) aStudy = appStudy->studyDS();
6517
6518   if(!aStudy)
6519     return false;
6520
6521   bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6522   if ( aLocked ) {
6523     SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6524     return false;
6525   }
6526
6527
6528   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6529   _PTR(GenericAttribute) anAttr;
6530   _PTR(AttributeName) aName;
6531   if ( obj ) {
6532     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6533       aName = anAttr;
6534       // check type to prevent renaming of inappropriate objects
6535       int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6536       if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6537           aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6538           aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6539           aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6540           aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6541         if ( !name.isEmpty() ) {
6542           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6543
6544           // update name of group object and its actor
6545           Handle(SALOME_InteractiveObject) IObject =
6546             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6547
6548           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6549           if( !aGroupObject->_is_nil() ) {
6550             aGroupObject->SetName( qPrintable(name) );
6551             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6552               anActor->setName( qPrintable(name) );
6553           }
6554           return true;
6555         }
6556       }
6557     }
6558   }
6559   return false;
6560 }