src/SMESHGUI/SMESHGUI.cxx

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