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         else
2517         {
2518           SMESH::SMESH_GroupOnFilter_var aGroup =
2519             SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2520           if (!aGroup->_is_nil()) {
2521             SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2522             aDlg->show();
2523           }
2524         }
2525       }
2526       break;
2527     }
2528
2529     case 810: // Union Groups
2530     case 811: // Intersect groups
2531     case 812: // Cut groups
2532     {
2533       if ( !vtkwnd )
2534       {
2535         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2536                                   tr( "NOT_A_VTK_VIEWER" ) );
2537         break;
2538       }
2539
2540       if ( checkLock( aStudy ) )
2541         break;
2542
2543       EmitSignalDeactivateDialog();
2544
2545       SMESHGUI_GroupOpDlg* aDlg = 0;
2546       if ( theCommandID == 810 )
2547         aDlg = new SMESHGUI_UnionGroupsDlg( this );
2548       else if ( theCommandID == 811 )
2549         aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2550       else
2551         aDlg = new SMESHGUI_CutGroupsDlg( this );
2552
2553       aDlg->show();
2554
2555       break;
2556     }
2557
2558     case 814: // Create groups of entities from existing groups of superior dimensions
2559     {
2560       if ( checkLock( aStudy ) )
2561         break;
2562
2563       EmitSignalDeactivateDialog();
2564       SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2565       aDlg->show();
2566
2567       break;
2568     }
2569
2570     case 813: // Delete groups with their contents
2571     {
2572       if ( !vtkwnd )
2573       {
2574         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2575                                   tr( "NOT_A_VTK_VIEWER" ) );
2576         break;
2577       }
2578
2579       if ( checkLock( aStudy ) )
2580         break;
2581
2582       EmitSignalDeactivateDialog();
2583
2584       ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2585       break;
2586     }
2587
2588   case 900:                                     // MESH INFOS
2589   case 903:                                     // WHAT IS
2590     {
2591       int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2592       EmitSignalDeactivateDialog();
2593       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2594       SALOME_ListIO selected;
2595       if( aSel )
2596         aSel->selectedObjects( selected );
2597
2598       if ( selected.Extent() > 1 ) { // a dlg for each IO
2599         SALOME_ListIteratorOfListIO It( selected );
2600         for ( ; It.More(); It.Next() ) {
2601           SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2602           dlg->showInfo( It.Value() );
2603           dlg->show();
2604         }
2605       }
2606       else {
2607         SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2608         dlg->show();
2609       }
2610       break;
2611     }
2612     /*
2613   case 902:                                     // STANDARD MESH INFOS
2614     {
2615       EmitSignalDeactivateDialog();
2616       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2617       SALOME_ListIO selected;
2618       if( aSel )
2619         aSel->selectedObjects( selected );
2620
2621       if ( selected.Extent() > 1 ) { // a dlg for each IO
2622         SALOME_ListIO IOs;
2623         SALOME_ListIteratorOfListIO It (selected);
2624         for ( ; It.More(); It.Next() ) {
2625           IOs.Clear();
2626           IOs.Append( It.Value() );
2627           aSel->setSelectedObjects( IOs );
2628           ( new SMESHGUI_StandardMeshInfosDlg( this ) )->show();
2629         }
2630         // restore selection
2631         aSel->setSelectedObjects( selected );
2632       }
2633       else
2634         ( new SMESHGUI_StandardMeshInfosDlg( this ) )->show();
2635       break;
2636     }
2637   case 903:                                     // WHAT IS
2638     {
2639       EmitSignalDeactivateDialog();
2640       ( new SMESHGUI_WhatIsDlg( this ) )->show();
2641       break;
2642     }
2643     */
2644
2645   case 904:                                     // FIND ELEM
2646     {
2647       startOperation( theCommandID );
2648       break;
2649     }
2650
2651   case 1100:                                    // EDIT HYPOTHESIS
2652     {
2653       if(checkLock(aStudy)) break;
2654
2655       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2656       SALOME_ListIO selected;
2657       if( aSel )
2658         aSel->selectedObjects( selected );
2659
2660       int nbSel = selected.Extent();
2661
2662       if (nbSel == 1) {
2663         Handle(SALOME_InteractiveObject) anIObject = selected.First();
2664         SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
2665
2666         /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
2667         /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects                   */
2668         /* Warning : however by internal mechanism all subMeshes icons are changed !                     */
2669         if ( !aHypothesis->_is_nil() )
2670         {
2671           // BUG 0020378
2672           //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2673           SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2674           if (aCreator) {
2675             aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
2676           }
2677           else
2678           {
2679             // report error
2680           }
2681         }
2682       }
2683       break;
2684     }
2685   case 1102:                                    // REMOVE HYPOTHESIS / ALGORITHMS
2686     {
2687       if(checkLock(aStudy)) break;
2688       SUIT_OverrideCursor wc;
2689
2690       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2691       SALOME_ListIO selected;
2692       if( aSel )
2693         aSel->selectedObjects( selected, QString::null, false );
2694
2695       SALOME_ListIteratorOfListIO It(selected);
2696       for (int i = 0; It.More(); It.Next(), i++) {
2697         Handle(SALOME_InteractiveObject) IObject = It.Value();
2698         SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2699       }
2700       SALOME_ListIO l1;
2701       aSel->setSelectedObjects( l1 );
2702       updateObjBrowser();
2703       break;
2704     }
2705
2706   case 4009:                                    // ELEM0D
2707   case 4010:                                    // GEOM::EDGE
2708   case 4021:                                    // TRIANGLE
2709   case 4022:                                    // QUAD
2710   case 4023:                                    // POLYGON
2711   case 4031:                                    // TETRA
2712   case 4032:                                    // HEXA
2713     {
2714       if(checkLock(aStudy)) break;
2715       if ( vtkwnd ) {
2716         EmitSignalDeactivateDialog();
2717         SMDSAbs_ElementType type    = SMDSAbs_Edge;
2718         int                 nbNodes = 2;
2719         switch (theCommandID) {
2720         case 4009:                                      // ELEM0D
2721           type = SMDSAbs_0DElement; nbNodes = 1; break;
2722         case 4021:                                      // TRIANGLE
2723           type = SMDSAbs_Face; nbNodes = 3; break;
2724         case 4022:                                      // QUAD
2725           type = SMDSAbs_Face; nbNodes = 4; break;
2726         case 4031:                                      // TETRA
2727           type = SMDSAbs_Volume; nbNodes = 4; break;
2728         case 4023:                                      // POLYGON
2729           type = SMDSAbs_Face; nbNodes = 5; break;     // 5 - identificator for POLYGON
2730         case 4032:                                      // HEXA
2731           type = SMDSAbs_Volume; nbNodes = 8; break;
2732         case 4033:                                      // POLYHEDRE
2733           type = SMDSAbs_Volume; nbNodes = 9; break; // 9 - identificator for POLYHEDRE
2734         default:;
2735         }
2736         ( new SMESHGUI_AddMeshElementDlg( this, type, nbNodes ) )->show();
2737       }
2738       else {
2739         SUIT_MessageBox::warning(desktop(),
2740                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2741       }
2742       break;
2743     }
2744   case 4033:                                    // POLYHEDRON
2745     {
2746       if(checkLock(aStudy)) break;
2747       if ( vtkwnd ) {
2748         EmitSignalDeactivateDialog();
2749         ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
2750       }
2751       else {
2752         SUIT_MessageBox::warning(SMESHGUI::desktop(),
2753                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2754       }
2755       break;
2756     }
2757   case 4034:     // QUADRATIC EDGE
2758   case 4035:     // QUADRATIC TRIANGLE
2759   case 4036:     // QUADRATIC QUADRANGLE
2760   case 4037:     // QUADRATIC TETRAHEDRON
2761   case 4038:     // QUADRATIC PYRAMID
2762   case 4039:     // QUADRATIC PENTAHEDRON
2763   case 4040:     // QUADRATIC HEXAHEDRON
2764     {
2765       if(checkLock(aStudy)) break;
2766       if ( vtkwnd ) {
2767         EmitSignalDeactivateDialog();
2768         int type;
2769
2770         switch (theCommandID) {
2771         case 4034:
2772           type = QUAD_EDGE; break;
2773         case 4035:
2774           type = QUAD_TRIANGLE; break;
2775         case 4036:
2776           type = QUAD_QUADRANGLE; break;
2777         case 4037:
2778           type = QUAD_TETRAHEDRON; break;
2779         case 4038:
2780           type = QUAD_PYRAMID; break;
2781         case 4039:
2782           type = QUAD_PENTAHEDRON; break;
2783         case 4040:
2784           type = QUAD_HEXAHEDRON;
2785           break;
2786         default:;
2787         }
2788          ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
2789       }
2790       else {
2791         SUIT_MessageBox::warning(SMESHGUI::desktop(),
2792                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2793       }
2794       break;
2795     }
2796   case 4041:                                    // REMOVES NODES
2797     {
2798       if(checkLock(aStudy)) break;
2799       if ( vtkwnd ) {
2800         EmitSignalDeactivateDialog();
2801         ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
2802       }
2803       else {
2804         SUIT_MessageBox::warning(SMESHGUI::desktop(),
2805                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2806       }
2807       break;
2808     }
2809   case 4042:                                    // REMOVES ELEMENTS
2810     {
2811       if(checkLock(aStudy)) break;
2812       if( vtkwnd ) {
2813         EmitSignalDeactivateDialog();
2814         ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
2815       }
2816       else
2817         {
2818           SUIT_MessageBox::warning(SMESHGUI::desktop(),
2819                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2820         }
2821       break;
2822     }
2823   case 4043: {                                // CLEAR_MESH
2824
2825     if(checkLock(aStudy)) break;
2826
2827     SALOME_ListIO selected;
2828     if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
2829       aSel->selectedObjects( selected );
2830
2831     SUIT_OverrideCursor wc;
2832     SALOME_ListIteratorOfListIO It (selected);
2833     for ( ; It.More(); It.Next() )
2834     {
2835       Handle(SALOME_InteractiveObject) IOS = It.Value();
2836       SMESH::SMESH_Mesh_var aMesh =
2837         SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
2838       if ( aMesh->_is_nil()) continue;
2839       try {
2840         SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
2841         aMesh->Clear();
2842         _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
2843         SMESH::ModifiedMesh( aMeshSObj, false, true);
2844         // hide groups and submeshes
2845         _PTR(ChildIterator) anIter =
2846           SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
2847         for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
2848         {
2849           _PTR(SObject) so = anIter->Value();
2850           SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
2851         }
2852       }
2853       catch (const SALOME::SALOME_Exception& S_ex){
2854         wc.suspend();
2855         SalomeApp_Tools::QtCatchCorbaException(S_ex);
2856         wc.resume();
2857       }
2858     }
2859     SMESH::UpdateView();
2860     updateObjBrowser();
2861     break;
2862   }
2863   case 4044:                                     // REMOVE ORPHAN NODES
2864     {
2865       if(checkLock(aStudy)) break;
2866       SALOME_ListIO selected;
2867       if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
2868         aSel->selectedObjects( selected );
2869       if ( selected.Extent() == 1 ) {
2870         Handle(SALOME_InteractiveObject) anIO = selected.First();
2871         SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
2872         if ( !aMesh->_is_nil() ) {
2873           bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
2874                                                     tr( "SMESH_WARNING" ),
2875                                                     tr( "REMOVE_ORPHAN_NODES_QUESTION"),
2876                                                     SUIT_MessageBox::Yes |
2877                                                     SUIT_MessageBox::No,
2878                                                     SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
2879           if( confirm ) {
2880             try {
2881               SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
2882               int removed = aMeshEditor->RemoveOrphanNodes();
2883               SUIT_MessageBox::information(SMESHGUI::desktop(),
2884                                            tr("SMESH_INFORMATION"),
2885                                            tr("NB_NODES_REMOVED").arg(removed));
2886               if ( removed > 0 ) {
2887                 SMESH::UpdateView();
2888                 SMESHGUI::Modified();
2889               }
2890             }
2891             catch (const SALOME::SALOME_Exception& S_ex) {
2892               SalomeApp_Tools::QtCatchCorbaException(S_ex);
2893             }
2894             catch (...) {
2895             }
2896           }
2897         }
2898       }
2899       break;
2900     }
2901   case 4051:                                    // RENUMBERING NODES
2902     {
2903       if(checkLock(aStudy)) break;
2904       if( vtkwnd ) {
2905         EmitSignalDeactivateDialog();
2906         ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
2907       }
2908       else
2909         {
2910           SUIT_MessageBox::warning(SMESHGUI::desktop(),
2911                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2912         }
2913       break;
2914     }
2915   case 4052:                                    // RENUMBERING ELEMENTS
2916     {
2917       if(checkLock(aStudy)) break;
2918       if ( vtkwnd ) {
2919         EmitSignalDeactivateDialog();
2920         ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
2921       }
2922       else
2923         {
2924           SUIT_MessageBox::warning(SMESHGUI::desktop(),
2925                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2926         }
2927       break;
2928     }
2929   case 4061:                                   // TRANSLATION
2930     {
2931       if(checkLock(aStudy)) break;
2932       if ( vtkwnd ) {
2933         EmitSignalDeactivateDialog();
2934         ( new SMESHGUI_TranslationDlg( this ) )->show();
2935       }
2936       else {
2937         SUIT_MessageBox::warning(SMESHGUI::desktop(),
2938                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2939       }
2940       break;
2941     }
2942   case 4062:                                   // ROTATION
2943     {
2944       if(checkLock(aStudy)) break;
2945       if( vtkwnd ) {
2946         EmitSignalDeactivateDialog();
2947         ( new SMESHGUI_RotationDlg( this ) )->show();
2948       }
2949       else {
2950         SUIT_MessageBox::warning(SMESHGUI::desktop(),
2951                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2952       }
2953       break;
2954     }
2955   case 4063:                                   // SYMMETRY
2956     {
2957       if(checkLock(aStudy)) break;
2958       if(vtkwnd) {
2959         EmitSignalDeactivateDialog();
2960         ( new SMESHGUI_SymmetryDlg( this ) )->show();
2961       }
2962       else {
2963         SUIT_MessageBox::warning(SMESHGUI::desktop(),
2964                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2965       }
2966       break;
2967     }
2968   case 4064:                                   // SEWING
2969     {
2970       if(checkLock(aStudy)) break;
2971       if(vtkwnd) {
2972         EmitSignalDeactivateDialog();
2973         ( new SMESHGUI_SewingDlg( this ) )->show();
2974       }
2975       else {
2976         SUIT_MessageBox::warning(SMESHGUI::desktop(),
2977                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2978       }
2979       break;
2980     }
2981   case 4065:                                   // MERGE NODES
2982     {
2983       if(checkLock(aStudy)) break;
2984       if(vtkwnd) {
2985         EmitSignalDeactivateDialog();
2986         ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
2987       }
2988       else {
2989         SUIT_MessageBox::warning(SMESHGUI::desktop(),
2990                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2991       }
2992       break;
2993     }
2994   case 4066:                                   // MERGE EQUAL ELEMENTS
2995     {
2996       if (checkLock(aStudy)) break;
2997       if (vtkwnd) {
2998         EmitSignalDeactivateDialog();
2999         ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3000       } else {
3001         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3002                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3003       }
3004       break;
3005     }
3006
3007   case 4067: // MAKE MESH PASS THROUGH POINT
3008     startOperation( 4067 );
3009     break;
3010
3011   case 4068: // SCALE
3012     {
3013       if(checkLock(aStudy)) break;
3014       if ( vtkwnd ) {
3015         EmitSignalDeactivateDialog();
3016         ( new SMESHGUI_ScaleDlg( this ) )->show();
3017       }
3018       else {
3019         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3020                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3021       }
3022       break;
3023     }
3024
3025   case 4069: // DUPLICATE NODES
3026     {
3027       if(checkLock(aStudy)) break;
3028       if ( vtkwnd ) {
3029         EmitSignalDeactivateDialog();
3030         ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3031       }
3032       else {
3033         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3034                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3035       }
3036       break;
3037     }
3038
3039   case 5105: // Library of selection filters
3040   {
3041     static QList<int> aTypes;
3042     if ( aTypes.isEmpty() )
3043     {
3044       aTypes.append( SMESH::NODE );
3045       aTypes.append( SMESH::EDGE );
3046       aTypes.append( SMESH::FACE );
3047       aTypes.append( SMESH::VOLUME );
3048     }
3049     if (!myFilterLibraryDlg)
3050       myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3051     else if (myFilterLibraryDlg->isHidden())
3052       myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3053     myFilterLibraryDlg->raise();
3054   }
3055   break;
3056
3057   case 6017:                                    // CONTROLS
3058   case 6016:
3059   case 6015:
3060   case 6014:
3061   case 6013:
3062   case 6012:
3063   case 6011:
3064   case 6001:
3065   case 6018:
3066   case 6019:
3067   case 6002:
3068   case 6003:
3069   case 6004:
3070   case 6005:
3071   case 6009:
3072   case 6021:
3073   case 6022:
3074   case 6023:
3075   case 6024:
3076   case 6025:
3077   case 6026:
3078   case 6027:
3079     if ( vtkwnd ) {
3080
3081       LightApp_SelectionMgr* mgr = selectionMgr();
3082       SALOME_ListIO selected; mgr->selectedObjects( selected );
3083
3084       if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3085         _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3086         if ( SO ) {
3087           CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3088           SMESH::SMESH_Mesh_var      aMesh    = SMESH::SMESH_Mesh::_narrow( aObject );
3089           SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3090           SMESH::SMESH_GroupBase_var aGroup   = SMESH::SMESH_GroupBase::_narrow( aObject );
3091           if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3092             ::Control( theCommandID );
3093             break;
3094           }
3095         }
3096       }
3097       SUIT_MessageBox::warning(desktop(),
3098                                tr( "SMESH_WRN_WARNING" ),
3099                                tr( "SMESH_BAD_SELECTION" ) );
3100       break;
3101     }
3102     else {
3103       SUIT_MessageBox::warning(desktop(),
3104                                tr( "SMESH_WRN_WARNING" ),
3105                                tr( "NOT_A_VTK_VIEWER" ) );
3106     }
3107     break;
3108   case 9010:
3109     {
3110       LightApp_SelectionMgr* mgr = selectionMgr();
3111       SALOME_ListIO selected; mgr->selectedObjects( selected );
3112
3113       SALOME_ListIteratorOfListIO it(selected);
3114       for( ; it.More(); it.Next()) {
3115         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3116         if(anIObject->hasEntry()) {
3117           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3118             anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3119           }
3120         }
3121       }
3122       break;
3123     }
3124   case 9011:
3125     {
3126       LightApp_SelectionMgr* mgr = selectionMgr();
3127       SALOME_ListIO selected; mgr->selectedObjects( selected );
3128
3129       SALOME_ListIteratorOfListIO it(selected);
3130       for( ; it.More(); it.Next()) {
3131         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3132         if(anIObject->hasEntry())
3133           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3134             anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3135           }
3136       }
3137       break;
3138     }
3139   case 501:
3140   case 502:
3141     {
3142       int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3143       EmitSignalDeactivateDialog();
3144       SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3145       dlg->show();
3146       break;
3147     }
3148   }
3149
3150   anApp->updateActions(); //SRN: To update a Save button in the toolbar
3151   //updateObjBrowser();
3152   return true;
3153 }
3154
3155 //=============================================================================
3156 /*!
3157  *
3158  */
3159 //=============================================================================
3160 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3161 {
3162   return false;
3163 }
3164
3165 //=============================================================================
3166 /*!
3167  *
3168  */
3169 //=============================================================================
3170 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3171 {
3172   return true;
3173 }
3174
3175 //=============================================================================
3176 /*!
3177  *
3178  */
3179 //=============================================================================
3180 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3181 {
3182   return true;
3183 }
3184
3185 //=============================================================================
3186 /*! Method:  BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3187  *  Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3188  */
3189 //=============================================================================
3190 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3191                                   SUIT_ViewWindow* wnd )
3192 {
3193   if(theIO->hasEntry()){
3194     //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3195     SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3196   }
3197 }
3198
3199 //=======================================================================
3200 // function : createSMESHAction
3201 // purpose  :
3202 //=======================================================================
3203 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3204                                   const int key, const bool toggle, const QString& shortcutAction  )
3205 {
3206   QIcon icon;
3207   QWidget* parent = application()->desktop();
3208   SUIT_ResourceMgr* resMgr = resourceMgr();
3209   QPixmap pix;
3210   if ( !icon_id.isEmpty() )
3211     pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3212   else
3213     pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3214   if ( !pix.isNull() )
3215     icon = QIcon( pix );
3216
3217   QString tooltip    = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3218           menu       = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3219           status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3220
3221   createAction( id, tooltip, icon, menu, status_bar, key, parent,
3222                 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3223 }
3224
3225 //=======================================================================
3226 // function : createPopupItem
3227 // purpose  :
3228 //=======================================================================
3229 void SMESHGUI::createPopupItem( const int id,
3230                                 const QString& clients,
3231                                 const QString& types,
3232                                 const QString& theRule,
3233                                 const int pId )
3234 {
3235   int parentId = pId;
3236   if( pId!=-1 )
3237     parentId = popupMgr()->actionId( action( pId ) );
3238
3239   if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3240     popupMgr()->insert( action( id ), parentId, 0 );
3241
3242   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
3243   QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3244   QString rule = "(%1) and (%2) and (%3)";
3245   rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3246   if( clients.isEmpty() )
3247     rule = rule.arg( QString( "true" ) );
3248   else
3249     rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3250   rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3251   rule += theRule;
3252
3253   bool cont = myRules.contains( id );
3254   if( cont )
3255     rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3256
3257   popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3258   myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3259 }
3260
3261 //=======================================================================
3262 // function : initialize
3263 // purpose  :
3264 //=======================================================================
3265 void SMESHGUI::initialize( CAM_Application* app )
3266 {
3267   SalomeApp_Module::initialize( app );
3268
3269 //   SUIT_ResourceMgr* mgr = app->resourceMgr();
3270 //   if ( mgr )
3271   /* Automatic Update flag */
3272 //     myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3273
3274   // ----- create actions --------------
3275
3276   createSMESHAction(  111, "DAT", "", (Qt::CTRL+Qt::Key_B) );
3277   createSMESHAction(  112, "UNV", "", (Qt::CTRL+Qt::Key_U) );
3278   createSMESHAction(  113, "MED", "", (Qt::CTRL+Qt::Key_M) );
3279   createSMESHAction(  114, "NUM" );
3280   createSMESHAction(  121, "DAT" );
3281   createSMESHAction(  122, "MED" );
3282   createSMESHAction(  123, "UNV" );
3283   createSMESHAction(  140, "STL" );
3284   createSMESHAction(  124, "EXPORT_DAT" );
3285   createSMESHAction(  125, "EXPORT_MED" );
3286   createSMESHAction(  126, "EXPORT_UNV" );
3287   createSMESHAction(  141, "EXPORT_STL" );
3288   createSMESHAction(  150, "FILE_INFO" );
3289   createSMESHAction(   33, "DELETE",          "ICON_DELETE", Qt::Key_Delete );
3290   createSMESHAction( 5105, "SEL_FILTER_LIB" );
3291   createSMESHAction(  701, "COMPUTE",         "ICON_COMPUTE" );
3292   createSMESHAction(  702, "CREATE_MESH",     "ICON_DLG_INIT_MESH" );
3293   createSMESHAction(  703, "CREATE_SUBMESH",  "ICON_DLG_ADD_SUBMESH" );
3294   createSMESHAction(  704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3295   createSMESHAction(  705, "COPY_MESH",       "ICON_COPY_MESH" );
3296   createSMESHAction(  710, "BUILD_COMPOUND",  "ICON_BUILD_COMPOUND" );
3297   createSMESHAction(  711, "PRECOMPUTE",      "ICON_PRECOMPUTE" );
3298   createSMESHAction(  712, "EVALUATE",        "ICON_COMPUTE" );
3299   createSMESHAction(  713, "MESH_ORDER",      "ICON_COMPUTE" );
3300   createSMESHAction(  806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3301   createSMESHAction(  801, "CREATE_GROUP",    "ICON_CREATE_GROUP" );
3302   createSMESHAction(  802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3303   createSMESHAction(  803, "EDIT_GROUP",      "ICON_EDIT_GROUP" );
3304   createSMESHAction(  815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3305   createSMESHAction(  804, "ADD" );
3306   createSMESHAction(  805, "REMOVE" );
3307   createSMESHAction(  810, "UN_GROUP",        "ICON_UNION" );
3308   createSMESHAction(  811, "INT_GROUP",       "ICON_INTERSECT" );
3309   createSMESHAction(  812, "CUT_GROUP",       "ICON_CUT" );
3310   createSMESHAction(  814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3311   createSMESHAction(  813, "DEL_GROUP",       "ICON_DEL_GROUP" );
3312   createSMESHAction(  900, "ADV_INFO",        "ICON_ADV_INFO" );
3313   //createSMESHAction(  902, "STD_INFO",        "ICON_STD_INFO" );
3314   //createSMESHAction(  903, "WHAT_IS",         "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3315   createSMESHAction(  904, "FIND_ELEM",       "ICON_FIND_ELEM" );
3316   createSMESHAction( 6001, "LENGTH",          "ICON_LENGTH",        0, true );
3317   createSMESHAction( 6002, "FREE_EDGE",       "ICON_FREE_EDGE",     0, true );
3318   createSMESHAction( 6021, "FREE_FACES",      "ICON_FREE_FACES",    0, true );
3319   createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3320   createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3321   createSMESHAction( 6024, "BARE_BORDER_VOLUME","ICON_BARE_BORDER_VOLUME", 0, true );
3322   createSMESHAction( 6025, "BARE_BORDER_FACE","ICON_BARE_BORDER_FACE", 0, true );
3323   createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3324   createSMESHAction( 6027, "OVER_CONSTRAINED_FACE","ICON_OVER_CONSTRAINED_FACE", 0, true );
3325   createSMESHAction( 6003, "FREE_BORDER",     "ICON_FREE_EDGE_2D",  0, true );
3326   createSMESHAction( 6004, "CONNECTION",      "ICON_CONNECTION",    0, true );
3327   createSMESHAction( 6005, "FREE_NODE",       "ICON_FREE_NODE",     0, true );
3328   createSMESHAction( 6011, "AREA",            "ICON_AREA",          0, true );
3329   createSMESHAction( 6012, "TAPER",           "ICON_TAPER",         0, true );
3330   createSMESHAction( 6013, "ASPECT",          "ICON_ASPECT",        0, true );
3331   createSMESHAction( 6014, "MIN_ANG",         "ICON_ANGLE",         0, true );
3332   createSMESHAction( 6015, "WARP",            "ICON_WARP",          0, true );
3333   createSMESHAction( 6016, "SKEW",            "ICON_SKEW",          0, true );
3334   createSMESHAction( 6017, "ASPECT_3D",       "ICON_ASPECT_3D",     0, true );
3335   createSMESHAction( 6018, "LENGTH_2D",       "ICON_LENGTH_2D",     0, true );
3336   createSMESHAction( 6019, "CONNECTION_2D",   "ICON_CONNECTION_2D", 0, true );
3337   createSMESHAction( 6009, "VOLUME_3D",       "ICON_VOLUME_3D",     0, true );
3338   createSMESHAction( 4000, "NODE",            "ICON_DLG_NODE" );
3339   createSMESHAction( 4009, "ELEM0D",          "ICON_DLG_ELEM0D" );
3340   createSMESHAction( 4010, "EDGE",            "ICON_DLG_EDGE" );
3341   createSMESHAction( 4021, "TRIANGLE",        "ICON_DLG_TRIANGLE" );
3342   createSMESHAction( 4022, "QUAD",            "ICON_DLG_QUADRANGLE" );
3343   createSMESHAction( 4023, "POLYGON",         "ICON_DLG_POLYGON" );
3344   createSMESHAction( 4031, "TETRA",           "ICON_DLG_TETRAS" );
3345   createSMESHAction( 4032, "HEXA",            "ICON_DLG_HEXAS" );
3346   createSMESHAction( 4041, "REMOVE_NODES",    "ICON_DLG_REM_NODE" );
3347   createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3348   createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3349   createSMESHAction( 4043, "CLEAR_MESH"    ,  "ICON_CLEAR_MESH" );
3350   createSMESHAction( 4051, "RENUM_NODES",     "ICON_DLG_RENUMBERING_NODES" );
3351   createSMESHAction( 4052, "RENUM_ELEMENTS",  "ICON_DLG_RENUMBERING_ELEMENTS" );
3352   createSMESHAction( 4061, "TRANS",           "ICON_SMESH_TRANSLATION_VECTOR" );
3353   createSMESHAction( 4062, "ROT",             "ICON_DLG_MESH_ROTATION" );
3354   createSMESHAction( 4063, "SYM",             "ICON_SMESH_SYMMETRY_PLANE" );
3355   createSMESHAction( 4064, "SEW",             "ICON_SMESH_SEWING_FREEBORDERS" );
3356   createSMESHAction( 4065, "MERGE",           "ICON_SMESH_MERGE_NODES" );
3357   createSMESHAction( 4066, "MERGE_ELEMENTS",  "ICON_DLG_MERGE_ELEMENTS" );
3358   createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3359   createSMESHAction( 4068, "SCALE",           "ICON_DLG_MESH_SCALE" );
3360   createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3361   createSMESHAction(  407, "INV",             "ICON_DLG_MESH_DIAGONAL" );
3362   createSMESHAction(  408, "UNION2",          "ICON_UNION2TRI" );
3363   createSMESHAction(  409, "ORIENT",          "ICON_DLG_MESH_ORIENTATION" );
3364   createSMESHAction(  410, "UNION",           "ICON_UNIONTRI" );
3365   createSMESHAction(  411, "CUT",             "ICON_CUTQUAD" );
3366   createSMESHAction(  412, "SMOOTH",          "ICON_DLG_SMOOTHING" );
3367   createSMESHAction(  413, "EXTRUSION",       "ICON_EXTRUSION" );
3368   createSMESHAction(  414, "REVOLUTION",      "ICON_REVOLUTION" );
3369   createSMESHAction(  415, "MAP",             "ICON_MAP" );
3370   createSMESHAction(  416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3371   createSMESHAction(  417, "CONV_TO_QUAD",    "ICON_CONV_TO_QUAD" );
3372   createSMESHAction(  418, "2D_FROM_3D",      "ICON_2D_FROM_3D" );
3373   createSMESHAction(  419, "SPLIT_TO_TETRA",  "ICON_SPLIT_TO_TETRA" );
3374   createSMESHAction(  200, "RESET" );
3375   createSMESHAction(  201, "SCALAR_BAR_PROP" );
3376   createSMESHAction(  2021, "SAVE_DISTRIBUTION" );
3377   createSMESHAction(  2022, "SHOW_DISTRIBUTION","",0, true );
3378 #ifndef DISABLE_PLOT2DVIEWER
3379   createSMESHAction(  2023, "PLOT_DISTRIBUTION" );
3380 #endif
3381   createSMESHAction(  211, "WIRE",           "ICON_WIRE", 0, true );
3382   createSMESHAction(  212, "SHADE",          "ICON_SHADE", 0, true );
3383   createSMESHAction(  213, "SHRINK",         "ICON_SHRINK", 0, true );
3384   createSMESHAction(  214, "UPDATE",         "ICON_UPDATE" );
3385   createSMESHAction(  215, "NODES",          "ICON_POINTS", 0, true );
3386   createSMESHAction(  216, "ELEMS0D",        "ICON_DLG_ELEM0D", 0, true );
3387   createSMESHAction(  217, "EDGES",          "ICON_DLG_EDGE", 0, true );
3388   createSMESHAction(  218, "FACES",          "ICON_DLG_TRIANGLE", 0, true );
3389   createSMESHAction(  219, "VOLUMES",        "ICON_DLG_TETRAS", 0, true );
3390   createSMESHAction(  220, "ALL" );
3391   createSMESHAction(  221, "FACE_ORIENTATION", "", 0, true );
3392
3393   createSMESHAction(  231, "LINE_REPRESENTATION", "", 0, true );
3394   createSMESHAction(  232, "ARC_REPRESENTATION", "", 0, true );
3395
3396   createSMESHAction( 1100, "EDIT_HYPO" );
3397   createSMESHAction( 1102, "UNASSIGN" );
3398   createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3399   createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3400   createSMESHAction( 1131, "DISPMODE" );
3401   createSMESHAction( 1132, "COLORS" );
3402   createSMESHAction( 1133, "TRANSP" );
3403   createSMESHAction( 1134, "CLIP" );
3404   createSMESHAction( 1135, "DISP_ENT" );
3405   createSMESHAction( 1136, "AUTO_COLOR" );
3406   createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3407   createSMESHAction( 2000, "CTRL" );
3408
3409   createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3410   createSMESHAction( 502, "MEASURE_BND_BOX",  "ICON_MEASURE_BND_BOX" );
3411
3412   createSMESHAction( 300, "ERASE" );
3413   createSMESHAction( 301, "DISPLAY" );
3414   createSMESHAction( 302, "DISPLAY_ONLY" );
3415   createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3416   createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3417   createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3418   createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3419   createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3420   createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3421   createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3422   createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3423
3424   // ----- create menu --------------
3425   int fileId    = createMenu( tr( "MEN_FILE" ),    -1,  1 ),
3426       editId    = createMenu( tr( "MEN_EDIT" ),    -1,  3 ),
3427       toolsId   = createMenu( tr( "MEN_TOOLS" ),   -1,  5, 50 ),
3428       meshId    = createMenu( tr( "MEN_MESH" ),    -1, 70, 10 ),
3429       ctrlId    = createMenu( tr( "MEN_CTRL" ),    -1, 60, 10 ),
3430       modifyId  = createMenu( tr( "MEN_MODIFY" ),  -1, 40, 10 ),
3431       measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3432       viewId    = createMenu( tr( "MEN_VIEW" ),    -1,  2 );
3433
3434   createMenu( separator(), fileId );
3435
3436   int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3437       exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3438       nodeId   = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3439       edgeId   = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3440       faceId   = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3441       volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3442       addId    = createMenu( tr( "MEN_ADD" ),    modifyId, 402 ),
3443       removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3444       renumId  = createMenu( tr( "MEN_RENUM" ),  modifyId, 404 ),
3445       transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3446
3447   createMenu( 111, importId, -1 );
3448   createMenu( 112, importId, -1 );
3449   createMenu( 113, importId, -1 );
3450   createMenu( 140, importId, -1 );
3451
3452   createMenu( 121, exportId, -1 );
3453   createMenu( 122, exportId, -1 );
3454   createMenu( 123, exportId, -1 );
3455   createMenu( 141, exportId, -1 ); // export to stl STL
3456
3457   createMenu( separator(), fileId, 10 );
3458
3459   createMenu( 33, editId, -1 );
3460
3461   createMenu( 5105, toolsId, -1 );
3462
3463   createMenu( 702, meshId, -1 ); // "Mesh" menu
3464   createMenu( 703, meshId, -1 );
3465   createMenu( 704, meshId, -1 );
3466   createMenu( 710, meshId, -1 );
3467   createMenu( 705, meshId, -1 );
3468   createMenu( separator(), meshId, -1 );
3469   createMenu( 701, meshId, -1 );
3470   createMenu( 711, meshId, -1 );
3471   createMenu( 712, meshId, -1 );
3472   createMenu( 713, meshId, -1 );
3473   createMenu( separator(), meshId, -1 );
3474   createMenu( 801, meshId, -1 );
3475   createMenu( 806, meshId, -1 );
3476   createMenu( 802, meshId, -1 );
3477   createMenu( 803, meshId, -1 );
3478   createMenu( 815, meshId, -1 );
3479   createMenu( separator(), meshId, -1 );
3480   createMenu( 810, meshId, -1 );
3481   createMenu( 811, meshId, -1 );
3482   createMenu( 812, meshId, -1 );
3483   createMenu( separator(), meshId, -1 );
3484   createMenu( 814, meshId, -1 );
3485   createMenu( separator(), meshId, -1 );
3486   createMenu( 900, meshId, -1 );
3487   //createMenu( 902, meshId, -1 );
3488   //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3489   createMenu( 904, meshId, -1 );
3490   createMenu( separator(), meshId, -1 );
3491
3492   createMenu( 6005, nodeId, -1 );
3493   createMenu( 6002, edgeId, -1 );
3494   createMenu( 6003, edgeId, -1 );
3495   createMenu( 6001, edgeId, -1 );
3496   createMenu( 6004, edgeId, -1 );
3497   createMenu( 6021, faceId, -1 );
3498   createMenu( 6025, faceId, -1 );
3499   createMenu( 6027, faceId, -1 );
3500   createMenu( 6018, faceId, -1 );
3501   createMenu( 6019, faceId, -1 );
3502   createMenu( 6011, faceId, -1 );
3503   createMenu( 6012, faceId, -1 );
3504   createMenu( 6013, faceId, -1 );
3505   createMenu( 6014, faceId, -1 );
3506   createMenu( 6015, faceId, -1 );
3507   createMenu( 6016, faceId, -1 );
3508   createMenu( 6022, faceId, -1 );
3509   createMenu( 6017, volumeId, -1 );
3510   createMenu( 6009, volumeId, -1 );
3511   createMenu( 6023, volumeId, -1 );
3512   createMenu( 6024, volumeId, -1 );
3513   createMenu( 6026, volumeId, -1 );
3514
3515   createMenu( 4000, addId, -1 );
3516   createMenu( 4009, addId, -1 );
3517   createMenu( 4010, addId, -1 );
3518   createMenu( 4021, addId, -1 );
3519   createMenu( 4022, addId, -1 );
3520   createMenu( 4023, addId, -1 );
3521   createMenu( 4031, addId, -1 );
3522   createMenu( 4032, addId, -1 );
3523   createMenu( 4033, addId, -1 );
3524   createMenu( separator(), addId, -1 );
3525   createMenu( 4034, addId, -1 );
3526   createMenu( 4035, addId, -1 );
3527   createMenu( 4036, addId, -1 );
3528   createMenu( 4037, addId, -1 );
3529   createMenu( 4038, addId, -1 );
3530   createMenu( 4039, addId, -1 );
3531   createMenu( 4040, addId, -1 );
3532
3533   createMenu( 4041, removeId, -1 );
3534   createMenu( 4042, removeId, -1 );
3535   createMenu( 4044, removeId, -1 );
3536   createMenu( separator(), removeId, -1 );
3537   createMenu( 813, removeId, -1 );
3538   createMenu( separator(), removeId, -1 );
3539   createMenu( 4043, removeId, -1 );
3540
3541   createMenu( 4051, renumId, -1 );
3542   createMenu( 4052, renumId, -1 );
3543
3544   createMenu( 4061, transfId, -1 );
3545   createMenu( 4062, transfId, -1 );
3546   createMenu( 4063, transfId, -1 );
3547   createMenu( 4068, transfId, -1 );
3548   createMenu( 4064, transfId, -1 );
3549   createMenu( 4065, transfId, -1 );
3550   createMenu( 4066, transfId, -1 );
3551   createMenu( 4069, transfId, -1 );
3552
3553   createMenu( 4067,modifyId, -1 );
3554   createMenu( 407, modifyId, -1 );
3555   createMenu( 408, modifyId, -1 );
3556   createMenu( 409, modifyId, -1 );
3557   createMenu( 410, modifyId, -1 );
3558   createMenu( 411, modifyId, -1 );
3559   createMenu( 419, modifyId, -1 );
3560   createMenu( 412, modifyId, -1 );
3561   createMenu( 413, modifyId, -1 );
3562   createMenu( 416, modifyId, -1 );
3563   createMenu( 414, modifyId, -1 );
3564   createMenu( 415, modifyId, -1 );
3565   createMenu( 417, modifyId, -1 );
3566   createMenu( 418, modifyId, -1 );
3567
3568   createMenu( 501, measureId, -1 );
3569   createMenu( 502, measureId, -1 );
3570   createMenu( 214, viewId, -1 );
3571
3572   // ----- create toolbars --------------
3573   int meshTb     = createTool( tr( "TB_MESH" ) ),
3574       ctrlTb     = createTool( tr( "TB_CTRL" ) ),
3575       addRemTb   = createTool( tr( "TB_ADD_REMOVE" ) ),
3576       modifyTb   = createTool( tr( "TB_MODIFY" ) ),
3577       dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
3578
3579   createTool( 702, meshTb );
3580   createTool( 703, meshTb );
3581   createTool( 704, meshTb );
3582   createTool( 710, meshTb );
3583   createTool( 705, meshTb );
3584   createTool( separator(), meshTb );
3585   createTool( 701, meshTb );
3586   createTool( 711, meshTb );
3587   createTool( 712, meshTb );
3588   createTool( 713, meshTb );
3589   createTool( separator(), meshTb );
3590   createTool( 801, meshTb );
3591   createTool( 806, meshTb );
3592   createTool( 802, meshTb );
3593   createTool( 803, meshTb );
3594   //createTool( 815, meshTb );
3595   createTool( separator(), meshTb );
3596   createTool( 900, meshTb );
3597   //createTool( 902, meshTb );
3598   //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3599   createTool( 904, meshTb );
3600   createTool( separator(), meshTb );
3601
3602   createTool( 6005, ctrlTb );
3603   createTool( separator(), ctrlTb );
3604   createTool( 6002, ctrlTb );
3605   createTool( 6003, ctrlTb );
3606   createTool( 6001, ctrlTb );
3607   createTool( 6004, ctrlTb );
3608   createTool( separator(), ctrlTb );
3609   createTool( 6021, ctrlTb );
3610   createTool( 6025, ctrlTb );
3611   createTool( 6027, ctrlTb );
3612   createTool( 6018, ctrlTb );
3613   createTool( 6019, ctrlTb );
3614   createTool( 6011, ctrlTb );
3615   createTool( 6012, ctrlTb );
3616   createTool( 6013, ctrlTb );
3617   createTool( 6014, ctrlTb );
3618   createTool( 6015, ctrlTb );
3619   createTool( 6016, ctrlTb );
3620   createTool( 6022, ctrlTb );
3621   createTool( separator(), ctrlTb );
3622   createTool( 6017, ctrlTb );
3623   createTool( 6009, ctrlTb );
3624   createTool( 6023, ctrlTb );
3625   createTool( 6024, ctrlTb );
3626   createTool( 6026, ctrlTb );
3627   createTool( separator(), ctrlTb );
3628
3629   createTool( 4000, addRemTb );
3630   createTool( 4009, addRemTb );
3631   createTool( 4010, addRemTb );
3632   createTool( 4021, addRemTb );
3633   createTool( 4022, addRemTb );
3634   createTool( 4023, addRemTb );
3635   createTool( 4031, addRemTb );
3636   createTool( 4032, addRemTb );
3637   createTool( 4033, addRemTb );
3638   createTool( separator(), addRemTb );
3639   createTool( 4034, addRemTb );
3640   createTool( 4035, addRemTb );
3641   createTool( 4036, addRemTb );
3642   createTool( 4037, addRemTb );
3643   createTool( 4038, addRemTb );
3644   createTool( 4039, addRemTb );
3645   createTool( 4040, addRemTb );
3646   createTool( separator(), addRemTb );
3647   createTool( 4041, addRemTb );
3648   createTool( 4042, addRemTb );
3649   createTool( 4044, addRemTb );
3650   createTool( 4043, addRemTb );
3651   createTool( separator(), addRemTb );
3652   createTool( 4051, addRemTb );
3653   createTool( 4052, addRemTb );
3654   createTool( separator(), addRemTb );
3655   createTool( 4061, addRemTb );
3656   createTool( 4062, addRemTb );
3657   createTool( 4063, addRemTb );
3658   createTool( 4068, addRemTb );
3659   createTool( 4064, addRemTb );
3660   createTool( 4065, addRemTb );
3661   createTool( 4066, addRemTb );
3662   createTool( 4069, addRemTb );
3663   createTool( separator(), addRemTb );
3664
3665   createTool( 4067,modifyTb );
3666   createTool( 407, modifyTb );
3667   createTool( 408, modifyTb );
3668   createTool( 409, modifyTb );
3669   createTool( 410, modifyTb );
3670   createTool( 411, modifyTb );
3671   createTool( 419, modifyTb );
3672   createTool( 412, modifyTb );
3673   createTool( 413, modifyTb );
3674   createTool( 416, modifyTb );
3675   createTool( 414, modifyTb );
3676   createTool( 415, modifyTb );
3677   createTool( 417, modifyTb );
3678   createTool( 418, modifyTb );
3679
3680   createTool( 214, dispModeTb );
3681
3682   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
3683   QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3684
3685   myRules.clear();
3686   QString OB = "'ObjectBrowser'",
3687           View = "'" + SVTK_Viewer::Type() + "'",
3688           pat = "'%1'",
3689           mesh    = pat.arg( SMESHGUI_Selection::typeName( MESH ) ),
3690           group   = pat.arg( SMESHGUI_Selection::typeName( GROUP ) ),
3691           hypo    = pat.arg( SMESHGUI_Selection::typeName( HYPOTHESIS ) ),
3692           algo    = pat.arg( SMESHGUI_Selection::typeName( ALGORITHM ) ),
3693           elems   = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
3694                        arg( SMESHGUI_Selection::typeName( SUBMESH_VERTEX ) ).
3695                        arg( SMESHGUI_Selection::typeName( SUBMESH_EDGE ) ).
3696                        arg( SMESHGUI_Selection::typeName( SUBMESH_FACE ) ).
3697                        arg( SMESHGUI_Selection::typeName( SUBMESH_SOLID ) ).
3698                        arg( SMESHGUI_Selection::typeName( SUBMESH_COMPOUND ) ).
3699                        arg( SMESHGUI_Selection::typeName( SUBMESH ) ),
3700           subMesh = elems,
3701           mesh_part = mesh + " " + subMesh + " " + group,
3702           mesh_group = mesh + " " + group,
3703           hyp_alg = hypo + " " + algo;
3704
3705   // popup for object browser
3706   QString
3707     isInvisible("not( isVisible )"),
3708     isEmpty("numberOfNodes = 0"),
3709     isNotEmpty("numberOfNodes <> 0"),
3710
3711     // has nodes, edges, etc in VISIBLE! actor
3712     hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
3713     hasElems("(count( elemTypes ) > 0)"),
3714     hasDifferentElems("(count( elemTypes ) > 1)"),
3715     hasElems0d("({'Elem0d'} in elemTypes)"),
3716     hasEdges("({'Edge'} in elemTypes)"),
3717     hasFaces("({'Face'} in elemTypes)"),
3718     hasVolumes("({'Volume'} in elemTypes)");
3719
3720   createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" );      // FILE INFORMATION
3721   createPopupItem( 703, OB, mesh, "&& isComputable");      // CREATE_SUBMESH
3722   createPopupItem( 704, OB, mesh, "&& isComputable");      // EDIT_MESHSUBMESH
3723   createPopupItem( 704, OB, subMesh, "&& isComputable" );  // EDIT_MESHSUBMESH
3724   createPopupItem( 803, OB, group );                       // EDIT_GROUP
3725   createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
3726
3727   popupMgr()->insert( separator(), -1, 0 );
3728   createPopupItem( 701, OB, mesh, "&& isComputable" );     // COMPUTE
3729   createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
3730   createPopupItem( 712, OB, mesh, "&& isComputable" );     // EVALUATE
3731   createPopupItem( 713, OB, mesh, "&& isComputable" );     // MESH ORDER
3732   createPopupItem( 214, OB, mesh_part );                   // UPDATE
3733   createPopupItem( 900, OB, mesh_part );                   // ADV_INFO
3734   createPopupItem( 904, OB, mesh_group );                  // FIND_ELEM
3735   popupMgr()->insert( separator(), -1, 0 );
3736   createPopupItem( 801, OB, mesh );                        // CREATE_GROUP
3737   createPopupItem( 806, OB, mesh );                        // CREATE_GEO_GROUP
3738   createPopupItem( 802, OB, subMesh );                     // CONSTRUCT_GROUP
3739   popupMgr()->insert( separator(), -1, 0 );
3740   createPopupItem( 1100, OB, hypo);                        // EDIT HYPOTHESIS
3741   createPopupItem( 1102, OB, hyp_alg );                    // REMOVE HYPOTHESIS / ALGORITHMS
3742   popupMgr()->insert( separator(), -1, 0 );
3743   createPopupItem( 4043, OB, mesh );                       // CLEAR_MESH
3744   popupMgr()->insert( separator(), -1, 0 );
3745   createPopupItem( 417, OB, mesh + " " + subMesh );        // convert to quadratic
3746   createPopupItem( 418, OB, mesh + " " + group,            // create 2D mesh from 3D
3747                    "&& dim>=2");
3748   popupMgr()->insert( separator(), -1, 0 );
3749
3750   QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
3751   QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
3752   QString only_one_2D        = only_one_non_empty + " && dim>1";
3753
3754   createPopupItem( 125, OB, mesh_group, multiple_non_empty );   // EXPORT_MED
3755   createPopupItem( 126, OB, mesh_group, only_one_non_empty );   // EXPORT_UNV
3756   createPopupItem( 141, OB, mesh_group, only_one_2D );          // EXPORT_STL
3757   createPopupItem(  33, OB, mesh_part + " " + hyp_alg );        // DELETE
3758   popupMgr()->insert( separator(), -1, 0 );
3759
3760   // popup for viewer
3761   createPopupItem( 803, View, group ); // EDIT_GROUP
3762   createPopupItem( 804, View, elems ); // ADD
3763   createPopupItem( 805, View, elems ); // REMOVE
3764
3765   popupMgr()->insert( separator(), -1, 0 );
3766   createPopupItem( 214, View, mesh_part );  // UPDATE
3767   createPopupItem( 900, View, mesh_part );  // ADV_INFO
3768   createPopupItem( 904, View, mesh );       // FIND_ELEM
3769   popupMgr()->insert( separator(), -1, 0 );
3770
3771   createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
3772   createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" );       // DISABLE_AUTO_COLOR
3773   popupMgr()->insert( separator(), -1, 0 );
3774
3775   int anId;
3776   QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
3777   QString aType = QString( "%1type in {%2}" ).arg( lc );
3778   aType = aType.arg( mesh_part );
3779   QString aMeshInVTK = aClient + "&&" + aType;
3780
3781   aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
3782   QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
3783   QString aSelCount = QString( "%1 > 0" ).arg( dc );
3784
3785   //-------------------------------------------------
3786   // Numbering
3787   //-------------------------------------------------
3788   anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
3789
3790   popupMgr()->insert( action( 9010 ), anId, -1 );
3791   popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
3792   popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
3793
3794   popupMgr()->insert( action( 9011 ), anId, -1 );
3795   popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
3796   popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
3797
3798   popupMgr()->insert( separator(), -1, -1 );
3799
3800   //-------------------------------------------------
3801   // Display Mode
3802   //-------------------------------------------------
3803   anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
3804
3805   popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
3806   popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
3807   popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
3808
3809   popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
3810   popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
3811   popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
3812
3813   popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
3814   popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
3815   popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
3816
3817   popupMgr()->insert( separator(), anId, -1 );
3818
3819   popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
3820   popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
3821   popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
3822
3823   //-------------------------------------------------
3824   // Display Entity
3825   //-------------------------------------------------
3826   QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
3827
3828   anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
3829
3830   popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
3831   popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
3832   popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
3833
3834   popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
3835   popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
3836   popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
3837
3838   popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
3839   popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
3840   popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
3841
3842   popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
3843   popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
3844   popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
3845
3846   popupMgr()->insert( separator(), anId, -1 );
3847
3848   popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
3849   popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
3850
3851
3852   //-------------------------------------------------
3853   // Representation of the 2D Quadratic elements
3854   //-------------------------------------------------
3855   anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
3856   popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
3857   popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
3858   popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
3859
3860   popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
3861   popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
3862   popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
3863
3864   //-------------------------------------------------
3865   // Orientation of faces
3866   //-------------------------------------------------
3867   popupMgr()->insert( action( 221 ), -1, -1 );
3868   popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
3869   popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
3870
3871   //-------------------------------------------------
3872   // Color / Size
3873   //-------------------------------------------------
3874   popupMgr()->insert( action( 1132 ), -1, -1 );
3875   popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
3876
3877   //-------------------------------------------------
3878   // Transparency
3879   //-------------------------------------------------
3880   popupMgr()->insert( action( 1133 ), -1, -1 );
3881   popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
3882
3883   //-------------------------------------------------
3884   // Controls
3885   //-------------------------------------------------
3886   QString
3887     aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
3888     aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
3889     aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
3890     aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
3891
3892   anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
3893
3894   popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
3895   popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
3896
3897   popupMgr()->insert( separator(), anId, -1 );
3898
3899   int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
3900
3901   popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
3902   popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
3903   popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
3904
3905   aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
3906
3907   popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
3908   popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
3909   popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
3910
3911   popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
3912   popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
3913   popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
3914
3915   popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
3916   popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
3917   popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
3918
3919   popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
3920   popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
3921   popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
3922
3923   aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
3924
3925   popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
3926   popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
3927                                        QtxPopupMgr::VisibleRule );
3928   popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
3929
3930   popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
3931   popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3932   popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
3933
3934   popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
3935   popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3936   popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
3937
3938   popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
3939   popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3940   popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
3941
3942   popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
3943   popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3944   popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
3945
3946   popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
3947   popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3948   popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
3949
3950   popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
3951   popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3952   popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
3953
3954   popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
3955   popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3956   popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
3957
3958   popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
3959   popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3960   popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
3961
3962   popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
3963   popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3964   popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
3965
3966   popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
3967   popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3968   popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
3969
3970   popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
3971   popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3972   popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
3973
3974   aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
3975
3976   popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
3977   popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3978   popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
3979
3980   popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
3981   popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3982   popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
3983
3984   popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
3985   popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3986   popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
3987
3988   popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
3989   popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3990   popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
3991
3992   popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
3993   popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3994   popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
3995
3996   popupMgr()->insert( separator(), anId, -1 );
3997
3998   popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
3999   popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4000
4001   popupMgr()->insert( separator(), anId, -1 );
4002
4003   aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4004
4005   popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4006   popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4007
4008   popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4009   popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4010   popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4011
4012 #ifndef DISABLE_PLOT2DVIEWER
4013   popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4014   popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4015 #endif
4016
4017   //-------------------------------------------------
4018   // Display / Erase
4019   //-------------------------------------------------
4020   popupMgr()->insert( separator(), -1, -1 );
4021   QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4022     aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4023   popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4024   popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4025
4026   popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4027   popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4028
4029   popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4030   popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4031
4032   popupMgr()->insert( separator(), -1, -1 );
4033
4034   //-------------------------------------------------
4035   // Clipping
4036   //-------------------------------------------------
4037   popupMgr()->insert( action( 1134 ), -1, -1 );
4038   popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4039
4040   popupMgr()->insert( separator(), -1, -1 );
4041
4042   connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4043            this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4044
4045   connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4046            this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4047 }
4048
4049 //================================================================================
4050 /*!
4051  * \brief Return true if SMESH or GEOM objects are selected.
4052  * Is called form LightApp_Module::activateModule() which clear selection if
4053  * not isSelectionCompatible()
4054  */
4055 //================================================================================
4056
4057 bool SMESHGUI::isSelectionCompatible()
4058 {
4059   bool isCompatible = true;
4060   SALOME_ListIO selected;
4061   if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4062     Sel->selectedObjects( selected );
4063
4064   SALOME_ListIteratorOfListIO It( selected );
4065   for ( ; isCompatible && It.More(); It.Next())
4066     isCompatible =
4067       ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4068       ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4069
4070   return isCompatible;
4071 }
4072
4073
4074 bool SMESHGUI::reusableOperation( const int id )
4075 {
4076   // compute, evaluate and precompute are not reusable operations
4077   return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4078 }
4079
4080 bool SMESHGUI::activateModule( SUIT_Study* study )
4081 {
4082   bool res = SalomeApp_Module::activateModule( study );
4083
4084   setMenuShown( true );
4085   setToolShown( true );
4086
4087   // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4088   PyGILState_STATE gstate = PyGILState_Ensure();
4089   PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4090   if(pluginsmanager==NULL)
4091     PyErr_Print();
4092   else
4093     {
4094       PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4095       if(result==NULL)
4096         PyErr_Print();
4097       Py_XDECREF(result);
4098     }
4099   PyGILState_Release(gstate);
4100   // end of GEOM plugins loading
4101
4102   // Reset actions accelerator keys
4103   action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4104   action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4105   action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4106
4107   action(  33)->setEnabled(true); // Delete: Key_Delete
4108
4109   //  0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4110   GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4111   if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4112     if ( _PTR(Study) aStudy = s->studyDS()) {
4113       GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4114       updateObjBrowser(); // objects can be removed
4115     }
4116
4117   // get all view currently opened in the study and connect their signals  to
4118   // the corresponding slots of the class.
4119   SUIT_Desktop* aDesk = study->application()->desktop();
4120   if ( aDesk ) {
4121     QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4122     SUIT_ViewWindow* wnd;
4123     foreach ( wnd, wndList )
4124       connectView( wnd );
4125   }
4126
4127   return res;
4128 }
4129
4130 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4131 {
4132   setMenuShown( false );
4133   setToolShown( false );
4134
4135   EmitSignalCloseAllDialogs();
4136
4137   // Unset actions accelerator keys
4138   action(111)->setShortcut(QKeySequence()); // Import DAT
4139   action(112)->setShortcut(QKeySequence()); // Import UNV
4140   action(113)->setShortcut(QKeySequence()); // Import MED
4141
4142   action(  33)->setEnabled(false); // Delete: Key_Delete
4143
4144   return SalomeApp_Module::deactivateModule( study );
4145 }
4146
4147 void SMESHGUI::studyClosed( SUIT_Study* s )
4148 {
4149   SMESH::RemoveVisuData( s->id() );
4150   SalomeApp_Module::studyClosed( s );
4151 }
4152
4153 void SMESHGUI::OnGUIEvent()
4154 {
4155   const QObject* obj = sender();
4156   if ( !obj || !obj->inherits( "QAction" ) )
4157     return;
4158   int id = actionId((QAction*)obj);
4159   if ( id != -1 )
4160     OnGUIEvent( id );
4161 }
4162
4163 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4164 {
4165   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4166   if ( CORBA::is_nil( myComponentSMESH ) )
4167     {
4168       SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4169       if ( aStudy )
4170         aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4171       return aGUI.myComponentSMESH;
4172     }
4173   if ( aStudy )
4174     myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4175   return myComponentSMESH;
4176 }
4177
4178 QString SMESHGUI::engineIOR() const
4179 {
4180   CORBA::ORB_var anORB = getApp()->orb();
4181   CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4182   return QString( anIOR.in() );
4183 }
4184
4185 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4186 {
4187   SalomeApp_Module::contextMenuPopup( client, menu, title );
4188   SALOME_ListIO lst;
4189   selectionMgr()->selectedObjects( lst );
4190   if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4191     Handle(SALOME_InteractiveObject) io = lst.First();
4192     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4193     _PTR(Study) study = appStudy->studyDS();
4194     _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4195     if ( obj ) {
4196       QString aName = QString( obj->GetName().c_str() );
4197       while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4198           aName.remove( (aName.length() - 1), 1 );
4199       title = aName;
4200     }
4201   }
4202 }
4203
4204 LightApp_Selection* SMESHGUI::createSelection() const
4205 {
4206   return new SMESHGUI_Selection();
4207 }
4208
4209 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4210 {
4211   aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4212   aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4213 }
4214
4215 void SMESHGUI::viewManagers( QStringList& list ) const
4216 {
4217   list.append( SVTK_Viewer::Type() );
4218 }
4219
4220 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4221 {
4222   if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4223     SMESH::UpdateSelectionProp( this );
4224
4225     QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4226     for(int i = 0; i < aViews.count() ; i++){
4227       SUIT_ViewWindow *sf = aViews[i];
4228       connectView( sf );
4229     }
4230   }
4231 }
4232
4233 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4234 {
4235   if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4236     myClippingPlaneInfoMap.erase( theViewManager );
4237 }
4238
4239 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4240 {
4241   theActor->AddObserver( SMESH::DeleteActorEvent,
4242                          myEventCallbackCommand.GetPointer(),
4243                          myPriority );
4244 }
4245
4246 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4247                               unsigned long theEvent,
4248                               void* theClientData,
4249                               void* theCallData )
4250 {
4251   if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4252     if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4253       if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4254         SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4255         SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4256         for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4257           SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4258           SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4259           for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4260             SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4261             std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4262             SMESH::TActorList::iterator anIter3 = anActorList.begin();
4263             for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4264               if( anActor == *anIter3 ) {
4265                 anActorList.erase( anIter3 );
4266                 break;
4267               }
4268             }
4269           }
4270         }
4271       }
4272     }
4273   }
4274 }
4275
4276 void SMESHGUI::createPreferences()
4277 {
4278   // General tab ------------------------------------------------------------------------
4279   int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4280
4281   int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4282   int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4283   setPreferenceProperty( lim, "min",  0 );
4284   setPreferenceProperty( lim, "max",  100000000 );
4285   setPreferenceProperty( lim, "step", 1000 );
4286   setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4287
4288   int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4289   setPreferenceProperty( qaGroup, "columns", 2 );
4290   addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4291   addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4292   int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4293   setPreferenceProperty( prec, "min", 0 );
4294   setPreferenceProperty( prec, "max", 16 );
4295
4296   int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4297   setPreferenceProperty( dispgroup, "columns", 2 );
4298   int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4299   QStringList modes;
4300   modes.append( "Wireframe" );
4301   modes.append( "Shading" );
4302   modes.append( "Nodes" );
4303   modes.append( "Shrink" );
4304   QList<QVariant> indices;
4305   indices.append( 0 );
4306   indices.append( 1 );
4307   indices.append( 2 );
4308   indices.append( 3 );
4309   setPreferenceProperty( dispmode, "strings", modes );
4310   setPreferenceProperty( dispmode, "indexes", indices );
4311
4312   int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4313   setPreferenceProperty( arcgroup, "columns", 2 );
4314   int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4315   QStringList quadraticModes;
4316   quadraticModes.append("Lines");
4317   quadraticModes.append("Arcs");
4318   indices.clear();
4319   indices.append( 0 );
4320   indices.append( 1 );
4321   setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4322   setPreferenceProperty( quadraticmode, "indexes", indices );
4323
4324   int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4325                               "SMESH", "max_angle" );
4326   setPreferenceProperty( maxAngle, "min", 1 );
4327   setPreferenceProperty( maxAngle, "max", 90 );
4328
4329
4330
4331   int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4332   setPreferenceProperty( exportgroup, "columns", 2 );
4333   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4334   addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4335
4336   int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4337   setPreferenceProperty( computeGroup, "columns", 2 );
4338   int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4339   modes.clear();
4340   modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4341   modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4342   modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4343   indices.clear();
4344   indices.append( 0 );
4345   indices.append( 1 );
4346   indices.append( 2 );
4347   setPreferenceProperty( notifyMode, "strings", modes );
4348   setPreferenceProperty( notifyMode, "indexes", indices );
4349
4350   int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4351   setPreferenceProperty( computeGroup, "columns", 2 );
4352   int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4353   modes.clear();
4354   modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4355   modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4356   indices.clear();
4357   indices.append( 0 );
4358   indices.append( 1 );
4359   setPreferenceProperty( elemInfo, "strings", modes );
4360   setPreferenceProperty( elemInfo, "indexes", indices );
4361
4362   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4363   setPreferenceProperty( segGroup, "columns", 2 );
4364   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4365                               "SMESH", "segmentation" );
4366   setPreferenceProperty( segLen, "min", 1 );
4367   setPreferenceProperty( segLen, "max", 10000000 );
4368   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4369                              "SMESH", "nb_segments_per_edge" );
4370   setPreferenceProperty( nbSeg, "min", 1 );
4371   setPreferenceProperty( nbSeg, "max", 10000000 );
4372
4373   // Quantities with individual precision settings
4374   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4375   setPreferenceProperty( precGroup, "columns", 2 );
4376
4377   const int nbQuantities = 6;
4378   int precs[nbQuantities], ii = 0;
4379   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4380                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4381   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4382                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4383   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4384                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4385   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4386                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4387   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4388                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4389   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4390                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4391
4392   // Set property for precision value for spinboxes
4393   for ( ii = 0; ii < nbQuantities; ii++ ){
4394     setPreferenceProperty( precs[ii], "min", -14 );
4395     setPreferenceProperty( precs[ii], "max", 14 );
4396     setPreferenceProperty( precs[ii], "precision", 2 );
4397   }
4398
4399   // Mesh tab ------------------------------------------------------------------------
4400   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4401   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4402   setPreferenceProperty( nodeGroup, "columns", 3 );
4403
4404   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4405
4406   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4407
4408   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4409   QList<QVariant> aMarkerTypeIndicesList;
4410   QList<QVariant> aMarkerTypeIconsList;
4411   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4412     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4413     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4414     aMarkerTypeIndicesList << i;
4415     aMarkerTypeIconsList << pixmap;
4416   }
4417   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4418   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
4419
4420   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4421
4422   QList<QVariant> aMarkerScaleIndicesList;
4423   QStringList     aMarkerScaleValuesList;
4424   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4425     aMarkerScaleIndicesList << i;
4426     aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4427   }
4428   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4429   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4430
4431   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4432   setPreferenceProperty( elemGroup, "columns", 2 );
4433
4434   addPreference( tr( "PREF_FILL"     ), elemGroup, LightApp_Preferences::Color, "SMESH", "fill_color" );
4435   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4436   addPreference( tr( "PREF_BACKFACE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "backface_color" );
4437   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4438
4439   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4440   setPreferenceProperty( grpGroup, "columns", 2 );
4441
4442   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4443
4444   //int sp = addPreference( "", elemGroup, LightApp_Preferences::Space );
4445   //setPreferenceProperty( sp, "hstretch", 0 );
4446   //setPreferenceProperty( sp, "vstretch", 0 );
4447
4448   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4449                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4450   int sp = addPreference( "", elemGroup, LightApp_Preferences::Space );
4451   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
4452                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
4453   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4454                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4455
4456   setPreferenceProperty( size0d, "min", 1 );
4457   setPreferenceProperty( size0d, "max", 10 );
4458
4459   setPreferenceProperty( sp, "hstretch", 0 );
4460   setPreferenceProperty( sp, "vstretch", 0 );
4461
4462   setPreferenceProperty( elemW, "min", 1 );
4463   setPreferenceProperty( elemW, "max", 5 );
4464
4465   setPreferenceProperty( shrink, "min", 0 );
4466   setPreferenceProperty( shrink, "max", 100 );
4467
4468   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4469   setPreferenceProperty( orientGroup, "columns", 1 );
4470
4471   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4472   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4473
4474   setPreferenceProperty( orientScale, "min", 0.05 );
4475   setPreferenceProperty( orientScale, "max", 0.5 );
4476   setPreferenceProperty( orientScale, "step", 0.05 );
4477
4478   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4479
4480   // Selection tab ------------------------------------------------------------------------
4481   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4482
4483   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4484   setPreferenceProperty( selGroup, "columns", 2 );
4485
4486   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4487   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4488   int selW = addPreference( tr( "PREF_WIDTH" ), selGroup, LightApp_Preferences::IntSpin, "SMESH", "selection_width" );
4489
4490   setPreferenceProperty( selW, "min", 1 );
4491   setPreferenceProperty( selW, "max", 5 );
4492
4493   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4494   setPreferenceProperty( preGroup, "columns", 2 );
4495
4496   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4497   int preW = addPreference( tr( "PREF_WIDTH" ), preGroup, LightApp_Preferences::IntSpin, "SMESH", "highlight_width" );
4498
4499   setPreferenceProperty( preW, "min", 1 );
4500   setPreferenceProperty( preW, "max", 5 );
4501
4502   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4503   setPreferenceProperty( precSelGroup, "columns", 2 );
4504
4505   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4506   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4507   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4508
4509   // Scalar Bar tab ------------------------------------------------------------------------
4510   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4511   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4512   setPreferenceProperty( fontGr, "columns", 2 );
4513
4514   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4515   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4516
4517   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4518   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4519
4520   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4521   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4522
4523   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4524   setPreferenceProperty( numcol, "min", 2 );
4525   setPreferenceProperty( numcol, "max", 256 );
4526
4527   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4528   setPreferenceProperty( numlab, "min", 2 );
4529   setPreferenceProperty( numlab, "max", 65 );
4530
4531   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4532   setPreferenceProperty( orientGr, "columns", 2 );
4533   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4534   QStringList orients;
4535   orients.append( tr( "SMESH_VERTICAL" ) );
4536   orients.append( tr( "SMESH_HORIZONTAL" ) );
4537   indices.clear(); indices.append( 0 ); indices.append( 1 );
4538   setPreferenceProperty( orient, "strings", orients );
4539   setPreferenceProperty( orient, "indexes", indices );
4540
4541   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4542   setPreferenceProperty( posVSizeGr, "columns", 2 );
4543   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4544   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4545   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4546   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4547   setPreferenceProperty( xv, "step", 0.1 );
4548   setPreferenceProperty( xv, "min", 0.0 );
4549   setPreferenceProperty( xv, "max", 1.0 );
4550   setPreferenceProperty( yv, "step", 0.1 );
4551   setPreferenceProperty( yv, "min", 0.0 );
4552   setPreferenceProperty( yv, "max", 1.0 );
4553   setPreferenceProperty( wv, "step", 0.1 );
4554   setPreferenceProperty( wv, "min", 0.0 );
4555   setPreferenceProperty( wv, "max", 1.0 );
4556   setPreferenceProperty( hv, "min", 0.0 );
4557   setPreferenceProperty( hv, "max", 1.0 );
4558   setPreferenceProperty( hv, "step", 0.1 );
4559
4560   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
4561   setPreferenceProperty( posHSizeGr, "columns", 2 );
4562   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
4563   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
4564   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
4565   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
4566   setPreferenceProperty( xv, "min", 0.0 );
4567   setPreferenceProperty( xv, "max", 1.0 );
4568   setPreferenceProperty( xv, "step", 0.1 );
4569   setPreferenceProperty( xh, "min", 0.0 );
4570   setPreferenceProperty( xh, "max", 1.0 );
4571   setPreferenceProperty( xh, "step", 0.1 );
4572   setPreferenceProperty( yh, "min", 0.0 );
4573   setPreferenceProperty( yh, "max", 1.0 );
4574   setPreferenceProperty( yh, "step", 0.1 );
4575   setPreferenceProperty( wh, "min", 0.0 );
4576   setPreferenceProperty( wh, "max", 1.0 );
4577   setPreferenceProperty( wh, "step", 0.1 );
4578   setPreferenceProperty( hh, "min", 0.0 );
4579   setPreferenceProperty( hh, "max", 1.0 );
4580   setPreferenceProperty( hh, "step", 0.1 );
4581
4582   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
4583   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
4584   setPreferenceProperty( distributionGr, "columns", 3 );
4585   QStringList types;
4586   types.append( tr( "SMESH_MONOCOLOR" ) );
4587   types.append( tr( "SMESH_MULTICOLOR" ) );
4588   indices.clear(); indices.append( 0 ); indices.append( 1 );
4589   setPreferenceProperty( coloringType, "strings", types );
4590   setPreferenceProperty( coloringType, "indexes", indices );
4591   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
4592
4593 }
4594
4595 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
4596 {
4597   if( sect=="SMESH" ) {
4598     float sbX1,sbY1,sbW,sbH;
4599     float aTol = 1.00000009999999;
4600     std::string aWarning;
4601     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4602     if( name=="selection_object_color" || name=="selection_element_color" ||
4603         name=="selection_width" || name=="highlight_color" || name=="highlight_width" ||
4604         name=="selection_precision_node" || name=="selection_precision_element" ||
4605         name=="selection_precision_object")
4606       SMESH::UpdateSelectionProp( this );
4607     else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
4608       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
4609       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
4610       if(sbX1+sbW > aTol){
4611         aWarning = "Origin and Size Vertical: X+Width > 1\n";
4612         sbX1=0.01;
4613         sbW=0.08;
4614         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
4615         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
4616       }
4617     }
4618     else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
4619       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
4620       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
4621       if(sbY1+sbH > aTol){
4622         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
4623         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
4624         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
4625       }
4626     }
4627     else if(name ==  QString("scalar_bar_horizontal_x") || name ==  QString("scalar_bar_horizontal_width")){
4628       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4629       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
4630       if(sbX1+sbW > aTol){
4631         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
4632         sbX1=0.1;
4633         sbW=0.08;
4634         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4635         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
4636       }
4637     }
4638     else if(name ==  QString("scalar_bar_horizontal_y") || name ==  QString("scalar_bar_horizontal_height")){
4639       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4640       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
4641       if(sbY1+sbH > aTol){
4642         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
4643         sbY1=0.01;
4644         sbH=0.08;
4645         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4646         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
4647       }
4648     }
4649     else if ( name == "segmentation" ) {
4650       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
4651       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
4652     }
4653     else if ( name == "nb_segments_per_edge" ) {
4654       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
4655       myComponentSMESH->SetDefaultNbSegments( nbSeg );
4656     }
4657
4658     if(aWarning.size() != 0){
4659       aWarning += "The default values are applied instead.";
4660       SUIT_MessageBox::warning(SMESHGUI::desktop(),
4661                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
4662                                QObject::tr(aWarning.c_str()));
4663     }
4664   }
4665 }
4666
4667 //================================================================================
4668 /*!
4669  * \brief Update something in accordance with update flags
4670   * \param theFlags - update flags
4671 *
4672 * Update viewer or/and object browser etc. in accordance with update flags ( see
4673 * LightApp_UpdateFlags enumeration ).
4674 */
4675 //================================================================================
4676 void SMESHGUI::update( const int flags )
4677 {
4678   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
4679     SMESH::UpdateView();
4680   else
4681     SalomeApp_Module::update( flags );
4682 }
4683
4684 //================================================================================
4685 /*!
4686  * \brief Set default selection mode
4687 *
4688 * SLOT called when operation commited. Sets default selection mode
4689 */
4690 //================================================================================
4691 void SMESHGUI::onOperationCommited( SUIT_Operation* )
4692 {
4693   SVTK_ViewWindow* vtkWnd =
4694     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4695   if ( vtkWnd )
4696     vtkWnd->SetSelectionMode( ActorSelection );
4697 }
4698
4699 //================================================================================
4700 /*!
4701  * \brief Set default selection mode
4702 *
4703 * SLOT called when operation aborted. Sets default selection mode
4704 */
4705 //================================================================================
4706 void SMESHGUI::onOperationAborted( SUIT_Operation* )
4707 {
4708   SVTK_ViewWindow* vtkWnd =
4709     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4710   if ( vtkWnd )
4711     vtkWnd->SetSelectionMode( ActorSelection );
4712 }
4713
4714 //================================================================================
4715 /*!
4716  * \brief Creates operation with given identifier
4717   * \param id - identifier of operation to be started
4718   * \return Pointer on created operation or NULL if operation is not created
4719 *
4720 * Virtual method redefined from the base class creates operation with given id.
4721 * It is called called automatically from startOperation method of base class.
4722 */
4723 //================================================================================
4724 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
4725 {
4726   LightApp_Operation* op = 0;
4727   // to do : create operation here
4728   switch( id )
4729   {
4730     case 417: //convert to quadratic
4731       op = new SMESHGUI_ConvToQuadOp();
4732     break;
4733     case 418: // create 2D mesh as boundary on 3D
4734       op = new SMESHGUI_Make2DFrom3DOp();
4735     break;
4736     case 701: // Compute mesh
4737       op = new SMESHGUI_ComputeOp();
4738     break;
4739     case 702: // Create mesh
4740       op = new SMESHGUI_MeshOp( true, true );
4741     break;
4742     case 703: // Create sub-mesh
4743       op = new SMESHGUI_MeshOp( true, false );
4744     break;
4745     case 704: // Edit mesh/sub-mesh
4746       op = new SMESHGUI_MeshOp( false );
4747     break;
4748     case 711: // Precompute mesh
4749       op = new SMESHGUI_PrecomputeOp();
4750     break;
4751     case 712: // Evaluate mesh
4752       op = new SMESHGUI_EvaluateOp();
4753     break;
4754     case 713: // Evaluate mesh
4755       op = new SMESHGUI_MeshOrderOp();
4756     break;
4757     case 806: // Create group on geom
4758       op = new SMESHGUI_GroupOnShapeOp();
4759       break;
4760     case 904: // Find element
4761       op = new SMESHGUI_FindElemByPointOp();
4762       break;
4763     case 4067: // make mesh pass through point
4764       op = new SMESHGUI_MakeNodeAtPointOp();
4765       break;
4766     default:
4767     break;
4768   }
4769
4770   if( !op )
4771     op = SalomeApp_Module::createOperation( id );
4772   return op;
4773 }
4774
4775 //================================================================================
4776 /*!
4777  * \brief Stops current operations and starts a given one
4778   * \param id - The id of the operation to start
4779  */
4780 //================================================================================
4781
4782 void SMESHGUI::switchToOperation(int id)
4783 {
4784   if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
4785     activeStudy()->abortAllOperations();
4786   startOperation( id );
4787 }
4788
4789 LightApp_Displayer* SMESHGUI::displayer()
4790 {
4791   if( !myDisplayer )
4792     myDisplayer = new SMESHGUI_Displayer( getApp() );
4793   return myDisplayer;
4794 }
4795
4796 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
4797 {
4798   int aHue = -1;
4799   int aTolerance = 64;
4800   int anIterations = 0;
4801   int aPeriod = 5;
4802
4803   while( 1 )
4804   {
4805     anIterations++;
4806     if( anIterations % aPeriod == 0 )
4807     {
4808       aTolerance /= 2;
4809       if( aTolerance < 1 )
4810         break;
4811     }
4812
4813     aHue = (int)( 360.0 * rand() / RAND_MAX );
4814
4815     bool ok = true;
4816     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
4817     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
4818     for( ; it != itEnd; ++it )
4819     {
4820       SALOMEDS::Color anAutoColor = *it;
4821       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
4822
4823       int h, s, v;
4824       aQColor.getHsv( &h, &s, &v );
4825       if( abs( h - aHue ) < aTolerance )
4826       {
4827         ok = false;
4828         break;
4829       }
4830     }
4831
4832     if( ok )
4833       break;
4834   }
4835
4836   QColor aColor;
4837   aColor.setHsv( aHue, 255, 255 );
4838
4839   SALOMEDS::Color aSColor;
4840   aSColor.R = (double)aColor.red() / 255.0;
4841   aSColor.G = (double)aColor.green() / 255.0;
4842   aSColor.B = (double)aColor.blue() / 255.0;
4843
4844   return aSColor;
4845 }
4846
4847 const char gSeparator = '_'; // character used to separate parameter names
4848 const char gDigitsSep = ':'; // character used to separate numeric parameter values (color = r:g:b)
4849 const char gPathSep   = '|'; // character used to separate paths
4850
4851 /*!
4852  * \brief Store visual parameters
4853  *
4854  * This method is called just before the study document is saved.
4855  * Store visual parameters in AttributeParameter attribue(s)
4856  */
4857 void SMESHGUI::storeVisualParameters (int savePoint)
4858 {
4859   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
4860   if (!appStudy || !appStudy->studyDS())
4861     return;
4862   _PTR(Study) studyDS = appStudy->studyDS();
4863
4864   // componentName is used for encoding of entries when storing them in IParameters
4865   std::string componentName = myComponentSMESH->ComponentDataType();
4866   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
4867   //if (!aSComponent) return;
4868
4869   // IParameters
4870   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
4871                                                              componentName.c_str(),
4872                                                              savePoint);
4873   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
4874
4875   // store map of custom markers
4876   const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
4877   if( !aMarkerMap.empty() )
4878   {
4879     VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
4880     for( ; anIter != aMarkerMap.end(); anIter++ )
4881     {
4882       int anId = anIter->first;
4883       VTK::MarkerData aMarkerData = anIter->second;
4884       std::string aMarkerFileName = aMarkerData.first;
4885       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
4886       if( aMarkerTexture.size() < 3 )
4887         continue; // should contain at least width, height and the first value
4888
4889       QString aPropertyName( "texture" );
4890       aPropertyName += gSeparator;
4891       aPropertyName += QString::number( anId );
4892
4893       QString aPropertyValue = aMarkerFileName.c_str();
4894       aPropertyValue += gPathSep;
4895
4896       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
4897       ushort aWidth = *aTextureIter++;
4898       ushort aHeight = *aTextureIter++;
4899       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
4900       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
4901       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
4902         aPropertyValue += QString::number( *aTextureIter );
4903
4904       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
4905     }
4906   }
4907
4908   // viewers counters are used for storing view_numbers in IParameters
4909   int vtkViewers = 0;
4910
4911   // main cycle to store parameters of displayed objects
4912   QList<SUIT_ViewManager*> lst;
4913   QList<SUIT_ViewManager*>::Iterator it;
4914   getApp()->viewManagers(lst);
4915   for (it = lst.begin(); it != lst.end(); it++)
4916   {
4917     SUIT_ViewManager* vman = *it;
4918     QString vType = vman->getType();
4919
4920     // saving VTK actors properties
4921     if (vType == SVTK_Viewer::Type())
4922     {
4923       // store the clipping planes attached to the view manager
4924       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
4925       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
4926       if( anIter != myClippingPlaneInfoMap.end() )
4927         aClippingPlaneInfoList = anIter->second;
4928
4929       if( !aClippingPlaneInfoList.empty() ) {
4930         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
4931         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
4932         {
4933           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
4934           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
4935
4936           QString aPropertyName( "ClippingPlane" );
4937           aPropertyName += gSeparator;
4938           aPropertyName += QString::number( vtkViewers );
4939           aPropertyName += gSeparator;
4940           aPropertyName += QString::number( anId );
4941
4942           QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
4943           aPropertyValue += gDigitsSep;
4944           aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
4945           aPropertyValue += gDigitsSep;
4946           aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
4947           aPropertyValue += gDigitsSep;
4948           aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
4949
4950           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
4951         }
4952       }
4953
4954       QVector<SUIT_ViewWindow*> views = vman->getViews();
4955       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
4956       {
4957         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
4958         {
4959           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
4960           vtkActorCollection* allActors = aCopy.GetActors();
4961           allActors->InitTraversal();
4962           while (vtkActor* actor = allActors->GetNextActor())
4963           {
4964             if (actor->GetVisibility()) // store only visible actors
4965             {
4966               SMESH_Actor* aSmeshActor = 0;
4967               if (actor->IsA("SMESH_Actor"))
4968                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
4969               if (aSmeshActor && aSmeshActor->hasIO())
4970               {
4971                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
4972                 if (io->hasEntry())
4973                 {
4974                   // entry is "encoded" = it does NOT contain component adress,
4975                   // since it is a subject to change on next component loading
4976                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
4977
4978                   std::string param, vtkParam = vType.toLatin1().data();
4979                   vtkParam += gSeparator;
4980                   vtkParam += QString::number(vtkViewers).toLatin1().data();
4981                   vtkParam += gSeparator;
4982
4983                   // Visibility
4984                   param = vtkParam + "Visibility";
4985                   ip->setParameter(entry, param, "On");
4986
4987                   // Representation
4988                   param = vtkParam + "Representation";
4989                   ip->setParameter(entry, param, QString::number
4990                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
4991
4992                   // IsShrunk
4993                   param = vtkParam + "IsShrunk";
4994                   ip->setParameter(entry, param, QString::number
4995                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
4996
4997                   // Displayed entities
4998                   unsigned int aMode = aSmeshActor->GetEntityMode();
4999                   bool isE = aMode & SMESH_Actor::eEdges;
5000                   bool isF = aMode & SMESH_Actor::eFaces;
5001                   bool isV = aMode & SMESH_Actor::eVolumes;
5002
5003                   QString modeStr ("e");
5004                   modeStr += gDigitsSep; modeStr += QString::number(isE);
5005                   modeStr += gDigitsSep; modeStr += "f";
5006                   modeStr += gDigitsSep; modeStr += QString::number(isF);
5007                   modeStr += gDigitsSep; modeStr += "v";
5008                   modeStr += gDigitsSep; modeStr += QString::number(isV);
5009
5010                   param = vtkParam + "Entities";
5011                   ip->setParameter(entry, param, modeStr.toLatin1().data());
5012
5013                   // Colors (surface:edge:)
5014                   vtkFloatingPointType r, g, b;
5015
5016                   aSmeshActor->GetSufaceColor(r, g, b);
5017                   QString colorStr ("surface");
5018                   colorStr += gDigitsSep; colorStr += QString::number(r);
5019                   colorStr += gDigitsSep; colorStr += QString::number(g);
5020                   colorStr += gDigitsSep; colorStr += QString::number(b);
5021
5022                   aSmeshActor->GetBackSufaceColor(r, g, b);
5023                   colorStr += gDigitsSep; colorStr += "backsurface";
5024                   colorStr += gDigitsSep; colorStr += QString::number(r);
5025                   colorStr += gDigitsSep; colorStr += QString::number(g);
5026                   colorStr += gDigitsSep; colorStr += QString::number(b);
5027
5028                   aSmeshActor->GetEdgeColor(r, g, b);
5029                   colorStr += gDigitsSep; colorStr += "edge";
5030                   colorStr += gDigitsSep; colorStr += QString::number(r);
5031                   colorStr += gDigitsSep; colorStr += QString::number(g);
5032                   colorStr += gDigitsSep; colorStr += QString::number(b);
5033
5034                   aSmeshActor->GetNodeColor(r, g, b);
5035                   colorStr += gDigitsSep; colorStr += "node";
5036                   colorStr += gDigitsSep; colorStr += QString::number(r);
5037                   colorStr += gDigitsSep; colorStr += QString::number(g);
5038                   colorStr += gDigitsSep; colorStr += QString::number(b);
5039
5040                   param = vtkParam + "Colors";
5041                   ip->setParameter(entry, param, colorStr.toLatin1().data());
5042
5043                   // Sizes of lines and points
5044                   QString sizeStr ("line");
5045                   sizeStr += gDigitsSep; sizeStr += QString::number((int)aSmeshActor->GetLineWidth());
5046                   sizeStr += gDigitsSep; sizeStr += "shrink";
5047                   sizeStr += gDigitsSep; sizeStr += QString::number(aSmeshActor->GetShrinkFactor());
5048
5049                   param = vtkParam + "Sizes";
5050                   ip->setParameter(entry, param, sizeStr.toLatin1().data());
5051
5052                   // Point marker
5053                   QString markerStr;
5054
5055                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5056                   if( aMarkerType == VTK::MT_USER ) {
5057                     markerStr += "custom";
5058                     markerStr += gDigitsSep;
5059                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5060                   }
5061                   else {
5062                     markerStr += "std";
5063                     markerStr += gDigitsSep;
5064                     markerStr += QString::number( (int)aMarkerType );
5065                     markerStr += gDigitsSep;
5066                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5067                   }
5068
5069                   param = vtkParam + "PointMarker";
5070                   ip->setParameter(entry, param, markerStr.toLatin1().data());
5071
5072                   // Opacity
5073                   param = vtkParam + "Opacity";
5074                   ip->setParameter(entry, param,
5075                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5076
5077                   // Clipping
5078                   param = vtkParam + "ClippingPlane";
5079                   int aPlaneId = 0;
5080                   if( !aClippingPlaneInfoList.empty() ) {
5081                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5082                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5083                     {
5084                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5085                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5086                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
5087                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5088                         if( aSmeshActor == *anIter2 ) {
5089                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5090                                             QString::number( anId ).toLatin1().constData() );
5091                           break;
5092                         }
5093                       }
5094                     }
5095                   }
5096                   if( aPlaneId == 0 )
5097                     ip->setParameter( entry, param, "Off" );
5098                 } // if (io->hasEntry())
5099               } // SMESH_Actor && hasIO
5100             } // isVisible
5101           } // while.. actors traversal
5102         } // if (vtkView)
5103       } // for (views)
5104       vtkViewers++;
5105     } // if (SVTK view model)
5106   } // for (viewManagers)
5107 }
5108
5109 // data structures for clipping planes processing
5110 typedef struct {
5111   int Id;
5112   vtkIdType Orientation;
5113   vtkFloatingPointType Distance;
5114   vtkFloatingPointType Angle[2];
5115 } TPlaneData;
5116 typedef std::list<TPlaneData>         TPlaneDataList;
5117 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5118
5119 typedef std::list<vtkActor*>          TActorList;
5120 typedef struct {
5121   int PlaneId;
5122   TActorList ActorList;
5123   SUIT_ViewManager* ViewManager;
5124 } TPlaneInfo;
5125 typedef std::list<TPlaneInfo>         TPlaneInfoList;
5126 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5127
5128 /*!
5129  * \brief Restore visual parameters
5130  *
5131  * This method is called after the study document is opened.
5132  * Restore visual parameters from AttributeParameter attribue(s)
5133  */
5134 void SMESHGUI::restoreVisualParameters (int savePoint)
5135 {
5136   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5137   if (!appStudy || !appStudy->studyDS())
5138     return;
5139   _PTR(Study) studyDS = appStudy->studyDS();
5140
5141   // componentName is used for encoding of entries when storing them in IParameters
5142   std::string componentName = myComponentSMESH->ComponentDataType();
5143   //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5144   //if (!aSComponent) return;
5145
5146   // IParameters
5147   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5148                                                              componentName.c_str(),
5149                                                              savePoint);
5150   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5151
5152   // restore map of custom markers and map of clipping planes
5153   VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5154   TPlaneDataMap aPlaneDataMap;
5155
5156   std::vector<std::string> properties = ip->getProperties();
5157   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5158   {
5159     std::string property = *propIt;
5160     QString aPropertyName( property.c_str() );
5161     QString aPropertyValue( ip->getProperty( property ).c_str() );
5162
5163     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5164     if( aPropertyNameList.isEmpty() )
5165       continue;
5166
5167     QString aPropertyType = aPropertyNameList[0];
5168     if( aPropertyType == "texture" )
5169     {
5170       if( aPropertyNameList.size() != 2 )
5171         continue;
5172
5173       bool ok = false;
5174       int anId = aPropertyNameList[1].toInt( &ok );
5175       if( !ok || anId < 1 )
5176         continue;
5177
5178       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5179       if( aPropertyValueList.size() != 2 )
5180         continue;
5181
5182       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5183       QString aMarkerTextureString = aPropertyValueList[1];
5184       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5185       if( aMarkerTextureStringList.size() != 3 )
5186         continue;
5187
5188       ok = false;
5189       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5190       if( !ok )
5191         continue;
5192
5193       ok = false;
5194       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5195       if( !ok )
5196         continue;
5197
5198       VTK::MarkerTexture aMarkerTexture;
5199       aMarkerTexture.push_back( aWidth );
5200       aMarkerTexture.push_back( aHeight );
5201
5202       QString aMarkerTextureData = aMarkerTextureStringList[2];
5203       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5204       {
5205         QChar aChar = aMarkerTextureData.at( i );
5206         if( aChar.isDigit() )
5207           aMarkerTexture.push_back( aChar.digitValue() );
5208       }
5209
5210       aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5211     }
5212     else if( aPropertyType == "ClippingPlane" )
5213     {
5214       if( aPropertyNameList.size() != 3 )
5215         continue;
5216
5217       bool ok = false;
5218       int aViewId = aPropertyNameList[1].toInt( &ok );
5219       if( !ok || aViewId < 0 )
5220         continue;
5221
5222       ok = false;
5223       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5224       if( !ok || aClippingPlaneId < 0 )
5225         continue;
5226
5227       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5228       if( aPropertyValueList.size() != 4 )
5229         continue;
5230
5231       TPlaneData aPlaneData;
5232       aPlaneData.Id = aClippingPlaneId;
5233
5234       ok = false;
5235       aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5236       if( !ok )
5237         continue;
5238
5239       ok = false;
5240       aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5241       if( !ok )
5242         continue;
5243
5244       ok = false;
5245       aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5246       if( !ok )
5247         continue;
5248
5249       ok = false;
5250       aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5251       if( !ok )
5252         continue;
5253
5254       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5255       aPlaneDataList.push_back( aPlaneData );
5256     }
5257   }
5258
5259   TPlaneInfoMap aPlaneInfoMap;
5260
5261   std::vector<std::string> entries = ip->getEntries();
5262
5263   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5264   {
5265     // entry is a normal entry - it should be "decoded" (setting base adress of component)
5266     QString entry (ip->decodeEntry(*entIt).c_str());
5267
5268     // Check that the entry corresponds to a real object in the Study
5269     // as the object may be deleted or modified after the visual state is saved.
5270     _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5271     if (!so) continue; //Skip the not existent entry
5272
5273     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5274     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5275
5276     std::vector<std::string>::iterator namesIt = paramNames.begin();
5277     std::vector<std::string>::iterator valuesIt = paramValues.begin();
5278
5279     // actors are stored in a map after displaying of them for
5280     // quicker access in the future: map < viewID to actor >
5281     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5282
5283     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5284     {
5285       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5286       // '_' is used as separator and should not be used in viewer type or parameter names.
5287       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5288       if (lst.size() != 3)
5289         continue;
5290
5291       QString viewerTypStr = lst[0];
5292       QString viewIndexStr = lst[1];
5293       QString paramNameStr = lst[2];
5294
5295       bool ok;
5296       int viewIndex = viewIndexStr.toUInt(&ok);
5297       if (!ok) // bad conversion of view index to integer
5298         continue;
5299
5300       // viewers
5301       if (viewerTypStr == SVTK_Viewer::Type())
5302       {
5303         SMESH_Actor* aSmeshActor = 0;
5304         if (vtkActors.IsBound(viewIndex))
5305           aSmeshActor = vtkActors.Find(viewIndex);
5306
5307         QList<SUIT_ViewManager*> lst;
5308         getApp()->viewManagers(viewerTypStr, lst);
5309
5310         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5311         SUIT_ViewManager* vman = NULL;
5312         if (viewIndex >= 0 && viewIndex < lst.count())
5313           vman = lst.at(viewIndex);
5314
5315         if (paramNameStr == "Visibility")
5316         {
5317           if (!aSmeshActor && displayer() && vman)
5318           {
5319             SUIT_ViewModel* vmodel = vman->getViewModel();
5320             // SVTK view model can be casted to SALOME_View
5321             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5322
5323             // store displayed actor in a temporary map for quicker
5324             // access later when restoring other parameters
5325             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5326             vtkRenderer* Renderer = vtkView->getRenderer();
5327             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5328             vtkActorCollection* theActors = aCopy.GetActors();
5329             theActors->InitTraversal();
5330             bool isFound = false;
5331             vtkActor *ac = theActors->GetNextActor();
5332             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5333               if (ac->IsA("SMESH_Actor")) {
5334                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5335                 if (aGeomAc->hasIO()) {
5336                   Handle(SALOME_InteractiveObject) io =
5337                     Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5338                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5339                     isFound = true;
5340                     vtkActors.Bind(viewIndex, aGeomAc);
5341                   }
5342                 }
5343               }
5344             }
5345           }
5346         } // if (paramNameStr == "Visibility")
5347         else
5348         {
5349           // the rest properties "work" with SMESH_Actor
5350           if (aSmeshActor)
5351           {
5352             QString val ((*valuesIt).c_str());
5353
5354             // Representation
5355             if (paramNameStr == "Representation") {
5356               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5357             }
5358             // IsShrunk
5359             else if (paramNameStr == "IsShrunk") {
5360               if (val.toInt()) {
5361                 if (!aSmeshActor->IsShrunk())
5362                   aSmeshActor->SetShrink();
5363               }
5364               else {
5365                 if (aSmeshActor->IsShrunk())
5366                   aSmeshActor->UnShrink();
5367               }
5368             }
5369             // Displayed entities
5370             else if (paramNameStr == "Entities") {
5371               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5372               if (mode.count() == 6) {
5373                 if (mode[0] != "e" || mode[2]  != "f" || mode[4] != "v") {
5374                   MESSAGE("Invalid order of data in Entities, must be: "
5375                           "e:0/1:f:0/1:v:0/1");
5376                 }
5377                 else {
5378                   unsigned int aMode = aSmeshActor->GetEntityMode();
5379                   unsigned int aNewMode =
5380                     (int(SMESH_Actor::eEdges  ) * mode[1].toInt()) |
5381                     (int(SMESH_Actor::eFaces  ) * mode[3].toInt()) |
5382                     (int(SMESH_Actor::eVolumes) * mode[5].toInt());
5383                   if (aNewMode != aMode)
5384                     aSmeshActor->SetEntityMode(aNewMode);
5385                 }
5386               }
5387             }
5388             // Colors
5389             else if (paramNameStr == "Colors") {
5390               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5391               if (colors.count() == 16) {
5392                 if (colors[0] != "surface" || colors[4]  != "backsurface" ||
5393                     colors[8] != "edge"    || colors[12] != "node") {
5394                   MESSAGE("Invalid order of data in Colors, must be: "
5395                           "surface:r:g:b:backsurface:r:g:b:edge:r:g:b:node:r:g:b");
5396                 }
5397                 else {
5398                   aSmeshActor->SetSufaceColor(colors[1].toFloat(), colors[2].toFloat(), colors[3].toFloat());
5399                   aSmeshActor->SetBackSufaceColor(colors[5].toFloat(), colors[6].toFloat(), colors[7].toFloat());
5400                   aSmeshActor->SetEdgeColor(colors[9].toFloat(), colors[10].toFloat(), colors[11].toFloat());
5401                   aSmeshActor->SetNodeColor(colors[13].toFloat(), colors[14].toFloat(), colors[15].toFloat());
5402                 }
5403               }
5404             }
5405             // Sizes of lines and points
5406             else if (paramNameStr == "Sizes") {
5407               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
5408               if (sizes.count() == 4) {
5409                 if (sizes[0] != "line" || sizes[2] != "shrink") {
5410                   MESSAGE("Invalid order of data in Sizes, must be: "
5411                           "line:int:shrink:float");
5412                 }
5413                 else {
5414                   aSmeshActor->SetLineWidth(sizes[1].toInt());
5415                   aSmeshActor->SetShrinkFactor(sizes[3].toFloat());
5416                 }
5417               }
5418               else if (sizes.count() == 6) { // just to support old format
5419                 if (sizes[0] != "line" || sizes[2]  != "node" || sizes[4] != "shrink") {
5420                   MESSAGE("Invalid order of data in Sizes, must be: "
5421                           "line:int:node:int:shrink:float");
5422                 }
5423                 else {
5424                   aSmeshActor->SetLineWidth(sizes[1].toInt());
5425                   //aSmeshActor->SetNodeSize(sizes[3].toInt()); // made obsolete
5426                   aSmeshActor->SetShrinkFactor(sizes[5].toFloat());
5427                 }
5428               }
5429             }
5430             // Point marker
5431             else if (paramNameStr == "PointMarker") {
5432               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
5433               if( data.count() >= 2 ) {
5434                 bool ok = false;
5435                 int aParam1 = data[1].toInt( &ok );
5436                 if( ok ) {
5437                   if( data[0] == "std" && data.count() == 3 ) {
5438                     int aParam2 = data[2].toInt( &ok );
5439                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
5440                   }
5441                   else if( data[0] == "custom" ) {
5442                     VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
5443                     if( markerIt != aMarkerMap.end() ) {
5444                       VTK::MarkerData aMarkerData = markerIt->second;
5445                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
5446                     }
5447                   }
5448                 }
5449               }
5450             }
5451             // Opacity
5452             else if (paramNameStr == "Opacity") {
5453               aSmeshActor->SetOpacity(val.toFloat());
5454             }
5455             // Clipping
5456             else if (paramNameStr.startsWith("ClippingPlane")) {
5457               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
5458               // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
5459               // new format - val looks like "Off" or "0" (plane id)
5460               // (note: in new format "Off" value is used only for consistency,
5461               //  so it is processed together with values in old format)
5462               bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
5463               if( anIsOldFormat ) {
5464                 if (paramNameStr == "ClippingPlane1" || val == "Off")
5465                   aSmeshActor->RemoveAllClippingPlanes();
5466                 if (val != "Off") {
5467                   SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
5468                   double aDistance = vals[1].toFloat();
5469                   vtkFloatingPointType anAngle[2];
5470                   anAngle[0] = vals[2].toFloat();
5471                   anAngle[1] = vals[3].toFloat();
5472
5473                   QList<SUIT_ViewManager*> lst;
5474                   getApp()->viewManagers(viewerTypStr, lst);
5475                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5476                   if (viewIndex >= 0 && viewIndex < lst.count()) {
5477                     SUIT_ViewManager* vman = lst.at(viewIndex);
5478                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5479
5480                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
5481
5482                     SMESH::TActorList anActorList;
5483                     anActorList.push_back( aSmeshActor );
5484                     SMESH::OrientedPlane* aPlane =
5485                       SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
5486                     if( aPlane ) {
5487                       SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5488                       aClippingPlaneInfo.Plane = aPlane;
5489                       aClippingPlaneInfo.ActorList = anActorList;
5490                       aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5491                     }
5492                   }
5493                 }
5494               }
5495               else {
5496                 bool ok = false;
5497                 int aPlaneId = val.toInt( &ok );
5498                 if( ok && aPlaneId >= 0 ) {
5499                   bool anIsDefinedPlane = false;
5500                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
5501                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
5502                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5503                     TPlaneInfo& aPlaneInfo = *anIter;
5504                     if( aPlaneInfo.PlaneId == aPlaneId ) {
5505                       aPlaneInfo.ActorList.push_back( aSmeshActor );
5506                       anIsDefinedPlane = true;
5507                       break;
5508                     }
5509                   }
5510                   if( !anIsDefinedPlane ) {
5511                     TPlaneInfo aPlaneInfo;
5512                     aPlaneInfo.PlaneId = aPlaneId;
5513                     aPlaneInfo.ActorList.push_back( aSmeshActor );
5514                     aPlaneInfo.ViewManager = vman;
5515
5516                     // to make the list sorted by plane id
5517                     anIter = aPlaneInfoList.begin();
5518                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5519                       const TPlaneInfo& aPlaneInfoRef = *anIter;
5520                       if( aPlaneInfoRef.PlaneId > aPlaneId )
5521                         break;
5522                     }
5523                     aPlaneInfoList.insert( anIter, aPlaneInfo );
5524                   }
5525                 }
5526               }
5527             }
5528           } // if (aSmeshActor)
5529         } // other parameters than Visibility
5530       }
5531     } // for names/parameters iterator
5532   } // for entries iterator
5533
5534   // take into account planes with empty list of actors referred to them
5535   QList<SUIT_ViewManager*> aVMList;
5536   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
5537
5538   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
5539   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
5540     int aViewId = aPlaneDataIter->first;
5541     if( aViewId >= 0 && aViewId < aVMList.count() ) {
5542       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
5543
5544       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
5545
5546       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
5547       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
5548       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
5549         const TPlaneData& aPlaneData = *anIter2;
5550         int aPlaneId = aPlaneData.Id;
5551
5552         bool anIsFound = false;
5553         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5554         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5555           const TPlaneInfo& aPlaneInfo = *anIter3;
5556           if( aPlaneInfo.PlaneId == aPlaneId ) {
5557             anIsFound = true;
5558             break;
5559           }
5560         }
5561
5562         if( !anIsFound ) {
5563           TPlaneInfo aPlaneInfo; // ActorList field is empty
5564           aPlaneInfo.PlaneId = aPlaneId;
5565           aPlaneInfo.ViewManager = aViewManager;
5566
5567           // to make the list sorted by plane id
5568           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
5569           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
5570             const TPlaneInfo& aPlaneInfoRef = *anIter4;
5571             if( aPlaneInfoRef.PlaneId > aPlaneId )
5572               break;
5573           }
5574           aPlaneInfoList.insert( anIter4, aPlaneInfo );
5575         }
5576       }
5577     }
5578   }
5579
5580   // add clipping planes to actors according to the restored parameters
5581   // and update the clipping plane map
5582   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
5583   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
5584     int aViewId = anIter1->first;
5585     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
5586
5587     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
5588     if( anIter2 == aPlaneDataMap.end() )
5589       continue;
5590     const TPlaneDataList& aPlaneDataList = anIter2->second;
5591
5592     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5593     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5594       const TPlaneInfo& aPlaneInfo = *anIter3;
5595       int aPlaneId = aPlaneInfo.PlaneId;
5596       const TActorList& anActorList = aPlaneInfo.ActorList;
5597       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
5598       if( !aViewManager )
5599         continue;
5600
5601       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
5602       if( !aViewWindow )
5603         continue;
5604
5605       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
5606
5607       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
5608       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
5609         const TPlaneData& aPlaneData = *anIter4;
5610         if( aPlaneData.Id == aPlaneId ) {
5611           SMESH::OrientedPlane* aPlane =
5612             SMESHGUI_ClippingDlg::AddPlane( anActorList,
5613                                             aViewWindow,
5614                                             (SMESH::Orientation)aPlaneData.Orientation,
5615                                             aPlaneData.Distance,
5616                                             aPlaneData.Angle );
5617           if( aPlane ) {
5618             SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5619             aClippingPlaneInfo.Plane = aPlane;
5620             aClippingPlaneInfo.ActorList = anActorList;
5621             aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5622           }
5623           break;
5624         }
5625       }
5626     }
5627   }
5628
5629   // update all VTK views
5630   QList<SUIT_ViewManager*> lst;
5631   getApp()->viewManagers(lst);
5632   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
5633     SUIT_ViewModel* vmodel = (*it)->getViewModel();
5634     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
5635       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
5636       vtkView->getRenderer()->ResetCameraClippingRange();
5637       vtkView->Repaint();
5638     }
5639   }
5640 }
5641
5642 /*!
5643   \brief Adds preferences for dfont of VTK viewer
5644   \param label label
5645   \param pIf group identifier
5646   \param param parameter
5647   \return identifier of preferences
5648 */
5649 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
5650 {
5651   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
5652
5653   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
5654
5655   QStringList fam;
5656   fam.append( tr( "SMESH_FONT_ARIAL" ) );
5657   fam.append( tr( "SMESH_FONT_COURIER" ) );
5658   fam.append( tr( "SMESH_FONT_TIMES" ) );
5659
5660   setPreferenceProperty( tfont, "fonts", fam );
5661
5662   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
5663   setPreferenceProperty( tfont, "features", f );
5664
5665   return tfont;
5666 }
5667
5668 /*!
5669   \brief Actions after hypothesis edition
5670   Updates object browser after hypothesis edition
5671 */
5672 void SMESHGUI::onHypothesisEdit( int result )
5673 {
5674   if( result == 1 )
5675     SMESHGUI::Modified();
5676   updateObjBrowser( true );
5677 }
5678
5679
5680 /*!
5681   \brief Signal handler closing(SUIT_ViewWindow*) of a view
5682   \param pview view being closed
5683 */
5684 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
5685 #ifndef DISABLE_PLOT2DVIEWER
5686   //Crear all Plot2d Viewers if need.
5687   SMESH::ClearPlot2Viewers(pview);
5688 #endif
5689 }
5690
5691 /*!
5692   \brief Connects or disconnects signals about activating and cloning view on the module slots
5693   \param pview view which is connected/disconnected
5694 */
5695 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
5696   if(!pview)
5697     return;
5698
5699   SUIT_ViewManager* viewMgr = pview->getViewManager();
5700   if ( viewMgr ) {
5701     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
5702                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
5703
5704     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
5705              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
5706   }
5707 }
5708
5709 /*!
5710   \brief Return \c true if object can be renamed
5711 */
5712 bool SMESHGUI::renameAllowed( const QString& entry) const {
5713   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
5714   if( !anApp )
5715     return false;
5716
5717   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
5718   if( !aStudy )
5719     return false;
5720
5721   bool appRes = SalomeApp_Module::renameAllowed(entry);
5722   if( !appRes )
5723     return false;
5724
5725   // check type to prevent renaming of inappropriate objects
5726   int aType = SMESHGUI_Selection::type(qPrintable(entry), aStudy);
5727   if (aType == MESH || aType == GROUP ||
5728       aType == SUBMESH || aType == SUBMESH_COMPOUND ||
5729       aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
5730       aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
5731       aType == HYPOTHESIS || aType == ALGORITHM)
5732     return true;
5733
5734   return false;
5735 }
5736
5737 /*!
5738   Rename object by entry.
5739   \param entry entry of the object
5740   \param name new name of the object
5741   \brief Return \c true if rename operation finished successfully, \c false otherwise.
5742 */
5743 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
5744
5745   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
5746   if( !anApp )
5747     return false;
5748
5749   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
5750   if( !aStudy )
5751     return false;
5752
5753   bool appRes = SalomeApp_Module::renameObject(entry,name);
5754   if( !appRes )
5755     return false;
5756
5757   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
5758   _PTR(GenericAttribute) anAttr;
5759   _PTR(AttributeName) aName;
5760   if ( obj ) {
5761     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
5762       aName = anAttr;
5763       // check type to prevent renaming of inappropriate objects
5764       int aType = SMESHGUI_Selection::type( qPrintable(entry), aStudy );
5765       if (aType == MESH || aType == GROUP ||
5766           aType == SUBMESH || aType == SUBMESH_COMPOUND ||
5767           aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
5768           aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
5769           aType == HYPOTHESIS || aType == ALGORITHM) {
5770         if ( !name.isEmpty() ) {
5771           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
5772
5773           // update name of group object and its actor
5774           Handle(SALOME_InteractiveObject) IObject =
5775             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
5776
5777           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
5778           if( !aGroupObject->_is_nil() ) {
5779             aGroupObject->SetName( qPrintable(name) );
5780             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
5781               anActor->setName( qPrintable(name) );
5782           }
5783           return true;
5784         }
5785       }
5786     }
5787   }
5788   return false;
5789 }