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