src/SMESHGUI/SMESHGUI.cxx

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