src/SMESHGUI/SMESHGUI.cxx

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