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/*, "&& " + hasVolumes*/);  // create 2D mesh on 3D
3747   popupMgr()->insert( separator(), -1, 0 );
3748
3749   QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
3750   QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
3751   QString only_one_2D        = only_one_non_empty + " && dim>1";
3752
3753   createPopupItem( 125, OB, mesh_group, multiple_non_empty );   // EXPORT_MED
3754   createPopupItem( 126, OB, mesh_group, only_one_non_empty );   // EXPORT_UNV
3755   createPopupItem( 141, OB, mesh_group, only_one_2D );          // EXPORT_STL
3756   createPopupItem(  33, OB, mesh_part + " " + hyp_alg );        // DELETE
3757   popupMgr()->insert( separator(), -1, 0 );
3758
3759   // popup for viewer
3760   createPopupItem( 803, View, group ); // EDIT_GROUP
3761   createPopupItem( 804, View, elems ); // ADD
3762   createPopupItem( 805, View, elems ); // REMOVE
3763
3764   popupMgr()->insert( separator(), -1, 0 );
3765   createPopupItem( 214, View, mesh_part );  // UPDATE
3766   createPopupItem( 900, View, mesh_part );  // ADV_INFO
3767   createPopupItem( 904, View, mesh );       // FIND_ELEM
3768   popupMgr()->insert( separator(), -1, 0 );
3769
3770   createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
3771   createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" );       // DISABLE_AUTO_COLOR
3772   popupMgr()->insert( separator(), -1, 0 );
3773
3774   int anId;
3775   QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
3776   QString aType = QString( "%1type in {%2}" ).arg( lc );
3777   aType = aType.arg( mesh_part );
3778   QString aMeshInVTK = aClient + "&&" + aType;
3779
3780   aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
3781   QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
3782   QString aSelCount = QString( "%1 > 0" ).arg( dc );
3783
3784   //-------------------------------------------------
3785   // Numbering
3786   //-------------------------------------------------
3787   anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
3788
3789   popupMgr()->insert( action( 9010 ), anId, -1 );
3790   popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
3791   popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
3792
3793   popupMgr()->insert( action( 9011 ), anId, -1 );
3794   popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
3795   popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
3796
3797   popupMgr()->insert( separator(), -1, -1 );
3798
3799   //-------------------------------------------------
3800   // Display Mode
3801   //-------------------------------------------------
3802   anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
3803
3804   popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
3805   popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
3806   popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
3807
3808   popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
3809   popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
3810   popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
3811
3812   popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
3813   popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
3814   popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
3815
3816   popupMgr()->insert( separator(), anId, -1 );
3817
3818   popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
3819   popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
3820   popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
3821
3822   //-------------------------------------------------
3823   // Display Entity
3824   //-------------------------------------------------
3825   QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
3826
3827   anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
3828
3829   popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
3830   popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
3831   popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
3832
3833   popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
3834   popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
3835   popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
3836
3837   popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
3838   popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
3839   popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
3840
3841   popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
3842   popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
3843   popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
3844
3845   popupMgr()->insert( separator(), anId, -1 );
3846
3847   popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
3848   popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
3849
3850
3851   //-------------------------------------------------
3852   // Representation of the 2D Quadratic elements
3853   //-------------------------------------------------
3854   anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
3855   popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
3856   popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
3857   popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
3858
3859   popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
3860   popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
3861   popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
3862
3863   //-------------------------------------------------
3864   // Orientation of faces
3865   //-------------------------------------------------
3866   popupMgr()->insert( action( 221 ), -1, -1 );
3867   popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
3868   popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
3869
3870   //-------------------------------------------------
3871   // Color / Size
3872   //-------------------------------------------------
3873   popupMgr()->insert( action( 1132 ), -1, -1 );
3874   popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
3875
3876   //-------------------------------------------------
3877   // Transparency
3878   //-------------------------------------------------
3879   popupMgr()->insert( action( 1133 ), -1, -1 );
3880   popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
3881
3882   //-------------------------------------------------
3883   // Controls
3884   //-------------------------------------------------
3885   QString
3886     aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
3887     aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
3888     aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
3889     aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
3890
3891   anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
3892
3893   popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
3894   popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
3895
3896   popupMgr()->insert( separator(), anId, -1 );
3897
3898   int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
3899
3900   popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
3901   popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
3902   popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
3903
3904   aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
3905
3906   popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
3907   popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
3908   popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
3909
3910   popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
3911   popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
3912   popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
3913
3914   popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
3915   popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
3916   popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
3917
3918   popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
3919   popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
3920   popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
3921
3922   aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
3923
3924   popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
3925   popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
3926                                        QtxPopupMgr::VisibleRule );
3927   popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
3928
3929   popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
3930   popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3931   popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
3932
3933   popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
3934   popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3935   popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
3936
3937   popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
3938   popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3939   popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
3940
3941   popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
3942   popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3943   popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
3944
3945   popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
3946   popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3947   popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
3948
3949   popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
3950   popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3951   popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
3952
3953   popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
3954   popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3955   popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
3956
3957   popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
3958   popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3959   popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
3960
3961   popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
3962   popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3963   popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
3964
3965   popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
3966   popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3967   popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
3968
3969   popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
3970   popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3971   popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
3972
3973   aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
3974
3975   popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
3976   popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3977   popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
3978
3979   popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
3980   popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3981   popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
3982
3983   popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
3984   popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3985   popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
3986
3987   popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
3988   popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3989   popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
3990
3991   popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
3992   popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3993   popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
3994
3995   popupMgr()->insert( separator(), anId, -1 );
3996
3997   popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
3998   popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
3999
4000   popupMgr()->insert( separator(), anId, -1 );
4001
4002   aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4003
4004   popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4005   popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4006
4007   popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4008   popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4009   popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4010
4011 #ifndef DISABLE_PLOT2DVIEWER
4012   popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4013   popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4014 #endif
4015
4016   //-------------------------------------------------
4017   // Display / Erase
4018   //-------------------------------------------------
4019   popupMgr()->insert( separator(), -1, -1 );
4020   QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4021     aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4022   popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4023   popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4024
4025   popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4026   popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4027
4028   popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4029   popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4030
4031   popupMgr()->insert( separator(), -1, -1 );
4032
4033   //-------------------------------------------------
4034   // Clipping
4035   //-------------------------------------------------
4036   popupMgr()->insert( action( 1134 ), -1, -1 );
4037   popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4038
4039   popupMgr()->insert( separator(), -1, -1 );
4040
4041   connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4042            this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4043
4044   connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4045            this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4046 }
4047
4048 //================================================================================
4049 /*!
4050  * \brief Return true if SMESH or GEOM objects are selected.
4051  * Is called form LightApp_Module::activateModule() which clear selection if
4052  * not isSelectionCompatible()
4053  */
4054 //================================================================================
4055
4056 bool SMESHGUI::isSelectionCompatible()
4057 {
4058   bool isCompatible = true;
4059   SALOME_ListIO selected;
4060   if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4061     Sel->selectedObjects( selected );
4062
4063   SALOME_ListIteratorOfListIO It( selected );
4064   for ( ; isCompatible && It.More(); It.Next())
4065     isCompatible =
4066       ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4067       ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4068
4069   return isCompatible;
4070 }
4071
4072
4073 bool SMESHGUI::reusableOperation( const int id )
4074 {
4075   // compute, evaluate and precompute are not reusable operations
4076   return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4077 }
4078
4079 bool SMESHGUI::activateModule( SUIT_Study* study )
4080 {
4081   bool res = SalomeApp_Module::activateModule( study );
4082
4083   setMenuShown( true );
4084   setToolShown( true );
4085
4086   // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4087   PyGILState_STATE gstate = PyGILState_Ensure();
4088   PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4089   if(pluginsmanager==NULL)
4090     PyErr_Print();
4091   else
4092     {
4093       PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4094       if(result==NULL)
4095         PyErr_Print();
4096       Py_XDECREF(result);
4097     }
4098   PyGILState_Release(gstate);
4099   // end of GEOM plugins loading
4100
4101   // Reset actions accelerator keys
4102   action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4103   action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4104   action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4105
4106   action(  33)->setEnabled(true); // Delete: Key_Delete
4107
4108   //  0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4109   GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4110   if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4111     if ( _PTR(Study) aStudy = s->studyDS()) {
4112       GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4113       updateObjBrowser(); // objects can be removed
4114     }
4115
4116   // get all view currently opened in the study and connect their signals  to
4117   // the corresponding slots of the class.
4118   SUIT_Desktop* aDesk = study->application()->desktop();
4119   if ( aDesk ) {
4120     QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4121     SUIT_ViewWindow* wnd;
4122     foreach ( wnd, wndList )
4123       connectView( wnd );
4124   }
4125
4126   return res;
4127 }
4128
4129 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4130 {
4131   setMenuShown( false );
4132   setToolShown( false );
4133
4134   EmitSignalCloseAllDialogs();
4135
4136   // Unset actions accelerator keys
4137   action(111)->setShortcut(QKeySequence()); // Import DAT
4138   action(112)->setShortcut(QKeySequence()); // Import UNV
4139   action(113)->setShortcut(QKeySequence()); // Import MED
4140
4141   action(  33)->setEnabled(false); // Delete: Key_Delete
4142
4143   return SalomeApp_Module::deactivateModule( study );
4144 }
4145
4146 void SMESHGUI::studyClosed( SUIT_Study* s )
4147 {
4148   SMESH::RemoveVisuData( s->id() );
4149   SalomeApp_Module::studyClosed( s );
4150 }
4151
4152 void SMESHGUI::OnGUIEvent()
4153 {
4154   const QObject* obj = sender();
4155   if ( !obj || !obj->inherits( "QAction" ) )
4156     return;
4157   int id = actionId((QAction*)obj);
4158   if ( id != -1 )
4159     OnGUIEvent( id );
4160 }
4161
4162 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4163 {
4164   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4165   if ( CORBA::is_nil( myComponentSMESH ) )
4166     {
4167       SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4168       if ( aStudy )
4169         aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4170       return aGUI.myComponentSMESH;
4171     }
4172   if ( aStudy )
4173     myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4174   return myComponentSMESH;
4175 }
4176
4177 QString SMESHGUI::engineIOR() const
4178 {
4179   CORBA::ORB_var anORB = getApp()->orb();
4180   CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4181   return QString( anIOR.in() );
4182 }
4183
4184 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4185 {
4186   SalomeApp_Module::contextMenuPopup( client, menu, title );
4187   SALOME_ListIO lst;
4188   selectionMgr()->selectedObjects( lst );
4189   if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4190     Handle(SALOME_InteractiveObject) io = lst.First();
4191     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4192     _PTR(Study) study = appStudy->studyDS();
4193     _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4194     if ( obj ) {
4195       QString aName = QString( obj->GetName().c_str() );
4196       while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4197           aName.remove( (aName.length() - 1), 1 );
4198       title = aName;
4199     }
4200   }
4201 }
4202
4203 LightApp_Selection* SMESHGUI::createSelection() const
4204 {
4205   return new SMESHGUI_Selection();
4206 }
4207
4208 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4209 {
4210   aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4211   aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4212 }
4213
4214 void SMESHGUI::viewManagers( QStringList& list ) const
4215 {
4216   list.append( SVTK_Viewer::Type() );
4217 }
4218
4219 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4220 {
4221   if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4222     SMESH::UpdateSelectionProp( this );
4223
4224     QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4225     for(int i = 0; i < aViews.count() ; i++){
4226       SUIT_ViewWindow *sf = aViews[i];
4227       connectView( sf );
4228     }
4229   }
4230 }
4231
4232 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4233 {
4234   if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4235     myClippingPlaneInfoMap.erase( theViewManager );
4236 }
4237
4238 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4239 {
4240   theActor->AddObserver( SMESH::DeleteActorEvent,
4241                          myEventCallbackCommand.GetPointer(),
4242                          myPriority );
4243 }
4244
4245 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4246                               unsigned long theEvent,
4247                               void* theClientData,
4248                               void* theCallData )
4249 {
4250   if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4251     if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4252       if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4253         SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4254         SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4255         for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4256           SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4257           SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4258           for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4259             SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4260             std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4261             SMESH::TActorList::iterator anIter3 = anActorList.begin();
4262             for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4263               if( anActor == *anIter3 ) {
4264                 anActorList.erase( anIter3 );
4265                 break;
4266               }
4267             }
4268           }
4269         }
4270       }
4271     }
4272   }
4273 }
4274
4275 void SMESHGUI::createPreferences()
4276 {
4277   // General tab ------------------------------------------------------------------------
4278   int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4279
4280   int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4281   int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4282   setPreferenceProperty( lim, "min",  0 );
4283   setPreferenceProperty( lim, "max",  100000000 );
4284   setPreferenceProperty( lim, "step", 1000 );
4285   setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4286
4287   int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4288   setPreferenceProperty( qaGroup, "columns", 2 );
4289   addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4290   addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4291   int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4292   setPreferenceProperty( prec, "min", 0 );
4293   setPreferenceProperty( prec, "max", 16 );
4294
4295   int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4296   setPreferenceProperty( dispgroup, "columns", 2 );
4297   int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4298   QStringList modes;
4299   modes.append( "Wireframe" );
4300   modes.append( "Shading" );
4301   modes.append( "Nodes" );
4302   modes.append( "Shrink" );
4303   QList<QVariant> indices;
4304   indices.append( 0 );
4305   indices.append( 1 );
4306   indices.append( 2 );
4307   indices.append( 3 );
4308   setPreferenceProperty( dispmode, "strings", modes );
4309   setPreferenceProperty( dispmode, "indexes", indices );
4310
4311   int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4312   setPreferenceProperty( arcgroup, "columns", 2 );
4313   int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4314   QStringList quadraticModes;
4315   quadraticModes.append("Lines");
4316   quadraticModes.append("Arcs");
4317   indices.clear();
4318   indices.append( 0 );
4319   indices.append( 1 );
4320   setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4321   setPreferenceProperty( quadraticmode, "indexes", indices );
4322
4323   int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4324                               "SMESH", "max_angle" );
4325   setPreferenceProperty( maxAngle, "min", 1 );
4326   setPreferenceProperty( maxAngle, "max", 90 );
4327
4328
4329
4330   int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4331   setPreferenceProperty( exportgroup, "columns", 2 );
4332   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4333   addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4334
4335   int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4336   setPreferenceProperty( computeGroup, "columns", 2 );
4337   int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4338   modes.clear();
4339   modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4340   modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4341   modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4342   indices.clear();
4343   indices.append( 0 );
4344   indices.append( 1 );
4345   indices.append( 2 );
4346   setPreferenceProperty( notifyMode, "strings", modes );
4347   setPreferenceProperty( notifyMode, "indexes", indices );
4348
4349   int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4350   setPreferenceProperty( computeGroup, "columns", 2 );
4351   int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4352   modes.clear();
4353   modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4354   modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4355   indices.clear();
4356   indices.append( 0 );
4357   indices.append( 1 );
4358   setPreferenceProperty( elemInfo, "strings", modes );
4359   setPreferenceProperty( elemInfo, "indexes", indices );
4360
4361   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4362   setPreferenceProperty( segGroup, "columns", 2 );
4363   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4364                               "SMESH", "segmentation" );
4365   setPreferenceProperty( segLen, "min", 1 );
4366   setPreferenceProperty( segLen, "max", 10000000 );
4367   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4368                              "SMESH", "nb_segments_per_edge" );
4369   setPreferenceProperty( nbSeg, "min", 1 );
4370   setPreferenceProperty( nbSeg, "max", 10000000 );
4371
4372   // Quantities with individual precision settings
4373   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4374   setPreferenceProperty( precGroup, "columns", 2 );
4375
4376   const int nbQuantities = 6;
4377   int precs[nbQuantities], ii = 0;
4378   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4379                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4380   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4381                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4382   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4383                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4384   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4385                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4386   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4387                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4388   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4389                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4390
4391   // Set property for precision value for spinboxes
4392   for ( ii = 0; ii < nbQuantities; ii++ ){
4393     setPreferenceProperty( precs[ii], "min", -14 );
4394     setPreferenceProperty( precs[ii], "max", 14 );
4395     setPreferenceProperty( precs[ii], "precision", 2 );
4396   }
4397
4398   // Mesh tab ------------------------------------------------------------------------
4399   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4400   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4401   setPreferenceProperty( nodeGroup, "columns", 3 );
4402
4403   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4404
4405   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4406
4407   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4408   QList<QVariant> aMarkerTypeIndicesList;
4409   QList<QVariant> aMarkerTypeIconsList;
4410   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4411     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4412     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4413     aMarkerTypeIndicesList << i;
4414     aMarkerTypeIconsList << pixmap;
4415   }
4416   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4417   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
4418
4419   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4420
4421   QList<QVariant> aMarkerScaleIndicesList;
4422   QStringList     aMarkerScaleValuesList;
4423   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4424     aMarkerScaleIndicesList << i;
4425     aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4426   }
4427   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4428   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4429
4430   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4431   setPreferenceProperty( elemGroup, "columns", 2 );
4432
4433   addPreference( tr( "PREF_FILL"     ), elemGroup, LightApp_Preferences::Color, "SMESH", "fill_color" );
4434   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4435   addPreference( tr( "PREF_BACKFACE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "backface_color" );
4436   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4437
4438   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4439   setPreferenceProperty( grpGroup, "columns", 2 );
4440
4441   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4442
4443   //int sp = addPreference( "", elemGroup, LightApp_Preferences::Space );
4444   //setPreferenceProperty( sp, "hstretch", 0 );
4445   //setPreferenceProperty( sp, "vstretch", 0 );
4446
4447   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4448                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4449   int sp = addPreference( "", elemGroup, LightApp_Preferences::Space );
4450   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
4451                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
4452   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4453                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4454
4455   setPreferenceProperty( size0d, "min", 1 );
4456   setPreferenceProperty( size0d, "max", 10 );
4457
4458   setPreferenceProperty( sp, "hstretch", 0 );
4459   setPreferenceProperty( sp, "vstretch", 0 );
4460
4461   setPreferenceProperty( elemW, "min", 1 );
4462   setPreferenceProperty( elemW, "max", 5 );
4463
4464   setPreferenceProperty( shrink, "min", 0 );
4465   setPreferenceProperty( shrink, "max", 100 );
4466
4467   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4468   setPreferenceProperty( orientGroup, "columns", 1 );
4469
4470   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4471   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4472
4473   setPreferenceProperty( orientScale, "min", 0.05 );
4474   setPreferenceProperty( orientScale, "max", 0.5 );
4475   setPreferenceProperty( orientScale, "step", 0.05 );
4476
4477   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4478
4479   // Selection tab ------------------------------------------------------------------------
4480   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4481
4482   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4483   setPreferenceProperty( selGroup, "columns", 2 );
4484
4485   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4486   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4487   int selW = addPreference( tr( "PREF_WIDTH" ), selGroup, LightApp_Preferences::IntSpin, "SMESH", "selection_width" );
4488
4489   setPreferenceProperty( selW, "min", 1 );
4490   setPreferenceProperty( selW, "max", 5 );
4491
4492   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4493   setPreferenceProperty( preGroup, "columns", 2 );
4494
4495   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4496   int preW = addPreference( tr( "PREF_WIDTH" ), preGroup, LightApp_Preferences::IntSpin, "SMESH", "highlight_width" );
4497
4498   setPreferenceProperty( preW, "min", 1 );
4499   setPreferenceProperty( preW, "max", 5 );
4500
4501   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4502   setPreferenceProperty( precSelGroup, "columns", 2 );
4503
4504   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4505   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4506   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4507
4508   // Scalar Bar tab ------------------------------------------------------------------------
4509   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4510   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4511   setPreferenceProperty( fontGr, "columns", 2 );
4512
4513   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4514   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4515
4516   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4517   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4518
4519   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4520   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4521
4522   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4523   setPreferenceProperty( numcol, "min", 2 );
4524   setPreferenceProperty( numcol, "max", 256 );
4525
4526   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4527   setPreferenceProperty( numlab, "min", 2 );
4528   setPreferenceProperty( numlab, "max", 65 );
4529
4530   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4531   setPreferenceProperty( orientGr, "columns", 2 );
4532   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4533   QStringList orients;
4534   orients.append( tr( "SMESH_VERTICAL" ) );
4535   orients.append( tr( "SMESH_HORIZONTAL" ) );
4536   indices.clear(); indices.append( 0 ); indices.append( 1 );
4537   setPreferenceProperty( orient, "strings", orients );
4538   setPreferenceProperty( orient, "indexes", indices );
4539
4540   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4541   setPreferenceProperty( posVSizeGr, "columns", 2 );
4542   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4543   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4544   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4545   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4546   setPreferenceProperty( xv, "step", 0.1 );
4547   setPreferenceProperty( xv, "min", 0.0 );
4548   setPreferenceProperty( xv, "max", 1.0 );
4549   setPreferenceProperty( yv, "step", 0.1 );
4550   setPreferenceProperty( yv, "min", 0.0 );
4551   setPreferenceProperty( yv, "max", 1.0 );
4552   setPreferenceProperty( wv, "step", 0.1 );
4553   setPreferenceProperty( wv, "min", 0.0 );
4554   setPreferenceProperty( wv, "max", 1.0 );
4555   setPreferenceProperty( hv, "min", 0.0 );
4556   setPreferenceProperty( hv, "max", 1.0 );
4557   setPreferenceProperty( hv, "step", 0.1 );
4558
4559   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
4560   setPreferenceProperty( posHSizeGr, "columns", 2 );
4561   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
4562   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
4563   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
4564   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
4565   setPreferenceProperty( xv, "min", 0.0 );
4566   setPreferenceProperty( xv, "max", 1.0 );
4567   setPreferenceProperty( xv, "step", 0.1 );
4568   setPreferenceProperty( xh, "min", 0.0 );
4569   setPreferenceProperty( xh, "max", 1.0 );
4570   setPreferenceProperty( xh, "step", 0.1 );
4571   setPreferenceProperty( yh, "min", 0.0 );
4572   setPreferenceProperty( yh, "max", 1.0 );
4573   setPreferenceProperty( yh, "step", 0.1 );
4574   setPreferenceProperty( wh, "min", 0.0 );
4575   setPreferenceProperty( wh, "max", 1.0 );
4576   setPreferenceProperty( wh, "step", 0.1 );
4577   setPreferenceProperty( hh, "min", 0.0 );
4578   setPreferenceProperty( hh, "max", 1.0 );
4579   setPreferenceProperty( hh, "step", 0.1 );
4580
4581   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
4582   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
4583   setPreferenceProperty( distributionGr, "columns", 3 );
4584   QStringList types;
4585   types.append( tr( "SMESH_MONOCOLOR" ) );
4586   types.append( tr( "SMESH_MULTICOLOR" ) );
4587   indices.clear(); indices.append( 0 ); indices.append( 1 );
4588   setPreferenceProperty( coloringType, "strings", types );
4589   setPreferenceProperty( coloringType, "indexes", indices );
4590   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
4591
4592 }
4593
4594 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
4595 {
4596   if( sect=="SMESH" ) {
4597     float sbX1,sbY1,sbW,sbH;
4598     float aTol = 1.00000009999999;
4599     std::string aWarning;
4600     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4601     if( name=="selection_object_color" || name=="selection_element_color" ||
4602         name=="selection_width" || name=="highlight_color" || name=="highlight_width" ||
4603         name=="selection_precision_node" || name=="selection_precision_element" ||
4604         name=="selection_precision_object")
4605       SMESH::UpdateSelectionProp( this );
4606     else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
4607       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
4608       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
4609       if(sbX1+sbW > aTol){
4610         aWarning = "Origin and Size Vertical: X+Width > 1\n";
4611         sbX1=0.01;
4612         sbW=0.08;
4613         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
4614         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
4615       }
4616     }
4617     else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
4618       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
4619       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
4620       if(sbY1+sbH > aTol){
4621         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
4622         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
4623         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
4624       }
4625     }
4626     else if(name ==  QString("scalar_bar_horizontal_x") || name ==  QString("scalar_bar_horizontal_width")){
4627       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4628       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
4629       if(sbX1+sbW > aTol){
4630         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
4631         sbX1=0.1;
4632         sbW=0.08;
4633         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4634         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
4635       }
4636     }
4637     else if(name ==  QString("scalar_bar_horizontal_y") || name ==  QString("scalar_bar_horizontal_height")){
4638       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4639       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
4640       if(sbY1+sbH > aTol){
4641         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
4642         sbY1=0.01;
4643         sbH=0.08;
4644         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4645         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
4646       }
4647     }
4648     else if ( name == "segmentation" ) {
4649       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
4650       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
4651     }
4652     else if ( name == "nb_segments_per_edge" ) {
4653       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
4654       myComponentSMESH->SetDefaultNbSegments( nbSeg );
4655     }
4656
4657     if(aWarning.size() != 0){
4658       aWarning += "The default values are applied instead.";
4659       SUIT_MessageBox::warning(SMESHGUI::desktop(),
4660                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
4661                                QObject::tr(aWarning.c_str()));
4662     }
4663   }
4664 }
4665
4666 //================================================================================
4667 /*!
4668  * \brief Update something in accordance with update flags
4669   * \param theFlags - update flags
4670 *
4671 * Update viewer or/and object browser etc. in accordance with update flags ( see
4672 * LightApp_UpdateFlags enumeration ).
4673 */
4674 //================================================================================
4675 void SMESHGUI::update( const int flags )
4676 {
4677   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
4678     SMESH::UpdateView();
4679   else
4680     SalomeApp_Module::update( flags );
4681 }
4682
4683 //================================================================================
4684 /*!
4685  * \brief Set default selection mode
4686 *
4687 * SLOT called when operation commited. Sets default selection mode
4688 */
4689 //================================================================================
4690 void SMESHGUI::onOperationCommited( SUIT_Operation* )
4691 {
4692   SVTK_ViewWindow* vtkWnd =
4693     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4694   if ( vtkWnd )
4695     vtkWnd->SetSelectionMode( ActorSelection );
4696 }
4697
4698 //================================================================================
4699 /*!
4700  * \brief Set default selection mode
4701 *
4702 * SLOT called when operation aborted. Sets default selection mode
4703 */
4704 //================================================================================
4705 void SMESHGUI::onOperationAborted( SUIT_Operation* )
4706 {
4707   SVTK_ViewWindow* vtkWnd =
4708     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4709   if ( vtkWnd )
4710     vtkWnd->SetSelectionMode( ActorSelection );
4711 }
4712
4713 //================================================================================
4714 /*!
4715  * \brief Creates operation with given identifier
4716   * \param id - identifier of operation to be started
4717   * \return Pointer on created operation or NULL if operation is not created
4718 *
4719 * Virtual method redefined from the base class creates operation with given id.
4720 * It is called called automatically from startOperation method of base class.
4721 */
4722 //================================================================================
4723 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
4724 {
4725   LightApp_Operation* op = 0;
4726   // to do : create operation here
4727   switch( id )
4728   {
4729     case 417: //convert to quadratic
4730       op = new SMESHGUI_ConvToQuadOp();
4731     break;
4732     case 418: // create 2D mesh as boundary on 3D
4733       op = new SMESHGUI_Make2DFrom3DOp();
4734     break;
4735     case 701: // Compute mesh
4736       op = new SMESHGUI_ComputeOp();
4737     break;
4738     case 702: // Create mesh
4739       op = new SMESHGUI_MeshOp( true, true );
4740     break;
4741     case 703: // Create sub-mesh
4742       op = new SMESHGUI_MeshOp( true, false );
4743     break;
4744     case 704: // Edit mesh/sub-mesh
4745       op = new SMESHGUI_MeshOp( false );
4746     break;
4747     case 711: // Precompute mesh
4748       op = new SMESHGUI_PrecomputeOp();
4749     break;
4750     case 712: // Evaluate mesh
4751       op = new SMESHGUI_EvaluateOp();
4752     break;
4753     case 713: // Evaluate mesh
4754       op = new SMESHGUI_MeshOrderOp();
4755     break;
4756     case 806: // Create group on geom
4757       op = new SMESHGUI_GroupOnShapeOp();
4758       break;
4759     case 904: // Find element
4760       op = new SMESHGUI_FindElemByPointOp();
4761       break;
4762     case 4067: // make mesh pass through point
4763       op = new SMESHGUI_MakeNodeAtPointOp();
4764       break;
4765     default:
4766     break;
4767   }
4768
4769   if( !op )
4770     op = SalomeApp_Module::createOperation( id );
4771   return op;
4772 }
4773
4774 //================================================================================
4775 /*!
4776  * \brief Stops current operations and starts a given one
4777   * \param id - The id of the operation to start
4778  */
4779 //================================================================================
4780
4781 void SMESHGUI::switchToOperation(int id)
4782 {
4783   if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
4784     activeStudy()->abortAllOperations();
4785   startOperation( id );
4786 }
4787
4788 LightApp_Displayer* SMESHGUI::displayer()
4789 {
4790   if( !myDisplayer )
4791     myDisplayer = new SMESHGUI_Displayer( getApp() );
4792   return myDisplayer;
4793 }
4794
4795 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
4796 {
4797   int aHue = -1;
4798   int aTolerance = 64;
4799   int anIterations = 0;
4800   int aPeriod = 5;
4801
4802   while( 1 )
4803   {
4804     anIterations++;
4805     if( anIterations % aPeriod == 0 )
4806     {
4807       aTolerance /= 2;
4808       if( aTolerance < 1 )
4809         break;
4810     }
4811
4812     aHue = (int)( 360.0 * rand() / RAND_MAX );
4813
4814     bool ok = true;
4815     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
4816     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
4817     for( ; it != itEnd; ++it )
4818     {
4819       SALOMEDS::Color anAutoColor = *it;
4820       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
4821
4822       int h, s, v;
4823       aQColor.getHsv( &h, &s, &v );
4824       if( abs( h - aHue ) < aTolerance )
4825       {
4826         ok = false;
4827         break;
4828       }
4829     }
4830
4831     if( ok )
4832       break;
4833   }
4834
4835   QColor aColor;
4836   aColor.setHsv( aHue, 255, 255 );
4837
4838   SALOMEDS::Color aSColor;
4839   aSColor.R = (double)aColor.red() / 255.0;
4840   aSColor.G = (double)aColor.green() / 255.0;
4841   aSColor.B = (double)aColor.blue() / 255.0;
4842
4843   return aSColor;
4844 }
4845
4846 const char gSeparator = '_'; // character used to separate parameter names
4847 const char gDigitsSep = ':'; // character used to separate numeric parameter values (color = r:g:b)
4848 const char gPathSep   = '|'; // character used to separate paths
4849
4850 /*!
4851  * \brief Store visual parameters
4852  *
4853  * This method is called just before the study document is saved.
4854  * Store visual parameters in AttributeParameter attribue(s)
4855  */
4856 void SMESHGUI::storeVisualParameters (int savePoint)
4857 {
4858   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
4859   if (!appStudy || !appStudy->studyDS())
4860     return;
4861   _PTR(Study) studyDS = appStudy->studyDS();
4862
4863   // componentName is used for encoding of entries when storing them in IParameters
4864   std::string componentName = myComponentSMESH->ComponentDataType();
4865   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
4866   //if (!aSComponent) return;
4867
4868   // IParameters
4869   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
4870                                                              componentName.c_str(),
4871                                                              savePoint);
4872   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
4873
4874   // store map of custom markers
4875   const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
4876   if( !aMarkerMap.empty() )
4877   {
4878     VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
4879     for( ; anIter != aMarkerMap.end(); anIter++ )
4880     {
4881       int anId = anIter->first;
4882       VTK::MarkerData aMarkerData = anIter->second;
4883       std::string aMarkerFileName = aMarkerData.first;
4884       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
4885       if( aMarkerTexture.size() < 3 )
4886         continue; // should contain at least width, height and the first value
4887
4888       QString aPropertyName( "texture" );
4889       aPropertyName += gSeparator;
4890       aPropertyName += QString::number( anId );
4891
4892       QString aPropertyValue = aMarkerFileName.c_str();
4893       aPropertyValue += gPathSep;
4894
4895       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
4896       ushort aWidth = *aTextureIter++;
4897       ushort aHeight = *aTextureIter++;
4898       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
4899       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
4900       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
4901         aPropertyValue += QString::number( *aTextureIter );
4902
4903       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
4904     }
4905   }
4906
4907   // viewers counters are used for storing view_numbers in IParameters
4908   int vtkViewers = 0;
4909
4910   // main cycle to store parameters of displayed objects
4911   QList<SUIT_ViewManager*> lst;
4912   QList<SUIT_ViewManager*>::Iterator it;
4913   getApp()->viewManagers(lst);
4914   for (it = lst.begin(); it != lst.end(); it++)
4915   {
4916     SUIT_ViewManager* vman = *it;
4917     QString vType = vman->getType();
4918
4919     // saving VTK actors properties
4920     if (vType == SVTK_Viewer::Type())
4921     {
4922       // store the clipping planes attached to the view manager
4923       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
4924       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
4925       if( anIter != myClippingPlaneInfoMap.end() )
4926         aClippingPlaneInfoList = anIter->second;
4927
4928       if( !aClippingPlaneInfoList.empty() ) {
4929         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
4930         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
4931         {
4932           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
4933           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
4934
4935           QString aPropertyName( "ClippingPlane" );
4936           aPropertyName += gSeparator;
4937           aPropertyName += QString::number( vtkViewers );
4938           aPropertyName += gSeparator;
4939           aPropertyName += QString::number( anId );
4940
4941           QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
4942           aPropertyValue += gDigitsSep;
4943           aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
4944           aPropertyValue += gDigitsSep;
4945           aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
4946           aPropertyValue += gDigitsSep;
4947           aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
4948
4949           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
4950         }
4951       }
4952
4953       QVector<SUIT_ViewWindow*> views = vman->getViews();
4954       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
4955       {
4956         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
4957         {
4958           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
4959           vtkActorCollection* allActors = aCopy.GetActors();
4960           allActors->InitTraversal();
4961           while (vtkActor* actor = allActors->GetNextActor())
4962           {
4963             if (actor->GetVisibility()) // store only visible actors
4964             {
4965               SMESH_Actor* aSmeshActor = 0;
4966               if (actor->IsA("SMESH_Actor"))
4967                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
4968               if (aSmeshActor && aSmeshActor->hasIO())
4969               {
4970                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
4971                 if (io->hasEntry())
4972                 {
4973                   // entry is "encoded" = it does NOT contain component adress,
4974                   // since it is a subject to change on next component loading
4975                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
4976
4977                   std::string param, vtkParam = vType.toLatin1().data();
4978                   vtkParam += gSeparator;
4979                   vtkParam += QString::number(vtkViewers).toLatin1().data();
4980                   vtkParam += gSeparator;
4981
4982                   // Visibility
4983                   param = vtkParam + "Visibility";
4984                   ip->setParameter(entry, param, "On");
4985
4986                   // Representation
4987                   param = vtkParam + "Representation";
4988                   ip->setParameter(entry, param, QString::number
4989                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
4990
4991                   // IsShrunk
4992                   param = vtkParam + "IsShrunk";
4993                   ip->setParameter(entry, param, QString::number
4994                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
4995
4996                   // Displayed entities
4997                   unsigned int aMode = aSmeshActor->GetEntityMode();
4998                   bool isE = aMode & SMESH_Actor::eEdges;
4999                   bool isF = aMode & SMESH_Actor::eFaces;
5000                   bool isV = aMode & SMESH_Actor::eVolumes;
5001
5002                   QString modeStr ("e");
5003                   modeStr += gDigitsSep; modeStr += QString::number(isE);
5004                   modeStr += gDigitsSep; modeStr += "f";
5005                   modeStr += gDigitsSep; modeStr += QString::number(isF);
5006                   modeStr += gDigitsSep; modeStr += "v";
5007                   modeStr += gDigitsSep; modeStr += QString::number(isV);
5008
5009                   param = vtkParam + "Entities";
5010                   ip->setParameter(entry, param, modeStr.toLatin1().data());
5011
5012                   // Colors (surface:edge:)
5013                   vtkFloatingPointType r, g, b;
5014
5015                   aSmeshActor->GetSufaceColor(r, g, b);
5016                   QString colorStr ("surface");
5017                   colorStr += gDigitsSep; colorStr += QString::number(r);
5018                   colorStr += gDigitsSep; colorStr += QString::number(g);
5019                   colorStr += gDigitsSep; colorStr += QString::number(b);
5020
5021                   aSmeshActor->GetBackSufaceColor(r, g, b);
5022                   colorStr += gDigitsSep; colorStr += "backsurface";
5023                   colorStr += gDigitsSep; colorStr += QString::number(r);
5024                   colorStr += gDigitsSep; colorStr += QString::number(g);
5025                   colorStr += gDigitsSep; colorStr += QString::number(b);
5026
5027                   aSmeshActor->GetEdgeColor(r, g, b);
5028                   colorStr += gDigitsSep; colorStr += "edge";
5029                   colorStr += gDigitsSep; colorStr += QString::number(r);
5030                   colorStr += gDigitsSep; colorStr += QString::number(g);
5031                   colorStr += gDigitsSep; colorStr += QString::number(b);
5032
5033                   aSmeshActor->GetNodeColor(r, g, b);
5034                   colorStr += gDigitsSep; colorStr += "node";
5035                   colorStr += gDigitsSep; colorStr += QString::number(r);
5036                   colorStr += gDigitsSep; colorStr += QString::number(g);
5037                   colorStr += gDigitsSep; colorStr += QString::number(b);
5038
5039                   param = vtkParam + "Colors";
5040                   ip->setParameter(entry, param, colorStr.toLatin1().data());
5041
5042                   // Sizes of lines and points
5043                   QString sizeStr ("line");
5044                   sizeStr += gDigitsSep; sizeStr += QString::number((int)aSmeshActor->GetLineWidth());
5045                   sizeStr += gDigitsSep; sizeStr += "shrink";
5046                   sizeStr += gDigitsSep; sizeStr += QString::number(aSmeshActor->GetShrinkFactor());
5047
5048                   param = vtkParam + "Sizes";
5049                   ip->setParameter(entry, param, sizeStr.toLatin1().data());
5050
5051                   // Point marker
5052                   QString markerStr;
5053
5054                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5055                   if( aMarkerType == VTK::MT_USER ) {
5056                     markerStr += "custom";
5057                     markerStr += gDigitsSep;
5058                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5059                   }
5060                   else {
5061                     markerStr += "std";
5062                     markerStr += gDigitsSep;
5063                     markerStr += QString::number( (int)aMarkerType );
5064                     markerStr += gDigitsSep;
5065                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5066                   }
5067
5068                   param = vtkParam + "PointMarker";
5069                   ip->setParameter(entry, param, markerStr.toLatin1().data());
5070
5071                   // Opacity
5072                   param = vtkParam + "Opacity";
5073                   ip->setParameter(entry, param,
5074                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5075
5076                   // Clipping
5077                   param = vtkParam + "ClippingPlane";
5078                   int aPlaneId = 0;
5079                   if( !aClippingPlaneInfoList.empty() ) {
5080                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5081                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5082                     {
5083                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5084                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5085                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
5086                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5087                         if( aSmeshActor == *anIter2 ) {
5088                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5089                                             QString::number( anId ).toLatin1().constData() );
5090                           break;
5091                         }
5092                       }
5093                     }
5094                   }
5095                   if( aPlaneId == 0 )
5096                     ip->setParameter( entry, param, "Off" );
5097                 } // if (io->hasEntry())
5098               } // SMESH_Actor && hasIO
5099             } // isVisible
5100           } // while.. actors traversal
5101         } // if (vtkView)
5102       } // for (views)
5103       vtkViewers++;
5104     } // if (SVTK view model)
5105   } // for (viewManagers)
5106 }
5107
5108 // data structures for clipping planes processing
5109 typedef struct {
5110   int Id;
5111   vtkIdType Orientation;
5112   vtkFloatingPointType Distance;
5113   vtkFloatingPointType Angle[2];
5114 } TPlaneData;
5115 typedef std::list<TPlaneData>         TPlaneDataList;
5116 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5117
5118 typedef std::list<vtkActor*>          TActorList;
5119 typedef struct {
5120   int PlaneId;
5121   TActorList ActorList;
5122   SUIT_ViewManager* ViewManager;
5123 } TPlaneInfo;
5124 typedef std::list<TPlaneInfo>         TPlaneInfoList;
5125 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5126
5127 /*!
5128  * \brief Restore visual parameters
5129  *
5130  * This method is called after the study document is opened.
5131  * Restore visual parameters from AttributeParameter attribue(s)
5132  */
5133 void SMESHGUI::restoreVisualParameters (int savePoint)
5134 {
5135   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5136   if (!appStudy || !appStudy->studyDS())
5137     return;
5138   _PTR(Study) studyDS = appStudy->studyDS();
5139
5140   // componentName is used for encoding of entries when storing them in IParameters
5141   std::string componentName = myComponentSMESH->ComponentDataType();
5142   //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5143   //if (!aSComponent) return;
5144
5145   // IParameters
5146   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5147                                                              componentName.c_str(),
5148                                                              savePoint);
5149   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5150
5151   // restore map of custom markers and map of clipping planes
5152   VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5153   TPlaneDataMap aPlaneDataMap;
5154
5155   std::vector<std::string> properties = ip->getProperties();
5156   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5157   {
5158     std::string property = *propIt;
5159     QString aPropertyName( property.c_str() );
5160     QString aPropertyValue( ip->getProperty( property ).c_str() );
5161
5162     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5163     if( aPropertyNameList.isEmpty() )
5164       continue;
5165
5166     QString aPropertyType = aPropertyNameList[0];
5167     if( aPropertyType == "texture" )
5168     {
5169       if( aPropertyNameList.size() != 2 )
5170         continue;
5171
5172       bool ok = false;
5173       int anId = aPropertyNameList[1].toInt( &ok );
5174       if( !ok || anId < 1 )
5175         continue;
5176
5177       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5178       if( aPropertyValueList.size() != 2 )
5179         continue;
5180
5181       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5182       QString aMarkerTextureString = aPropertyValueList[1];
5183       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5184       if( aMarkerTextureStringList.size() != 3 )
5185         continue;
5186
5187       ok = false;
5188       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5189       if( !ok )
5190         continue;
5191
5192       ok = false;
5193       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5194       if( !ok )
5195         continue;
5196
5197       VTK::MarkerTexture aMarkerTexture;
5198       aMarkerTexture.push_back( aWidth );
5199       aMarkerTexture.push_back( aHeight );
5200
5201       QString aMarkerTextureData = aMarkerTextureStringList[2];
5202       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5203       {
5204         QChar aChar = aMarkerTextureData.at( i );
5205         if( aChar.isDigit() )
5206           aMarkerTexture.push_back( aChar.digitValue() );
5207       }
5208
5209       aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5210     }
5211     else if( aPropertyType == "ClippingPlane" )
5212     {
5213       if( aPropertyNameList.size() != 3 )
5214         continue;
5215
5216       bool ok = false;
5217       int aViewId = aPropertyNameList[1].toInt( &ok );
5218       if( !ok || aViewId < 0 )
5219         continue;
5220
5221       ok = false;
5222       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5223       if( !ok || aClippingPlaneId < 0 )
5224         continue;
5225
5226       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5227       if( aPropertyValueList.size() != 4 )
5228         continue;
5229
5230       TPlaneData aPlaneData;
5231       aPlaneData.Id = aClippingPlaneId;
5232
5233       ok = false;
5234       aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5235       if( !ok )
5236         continue;
5237
5238       ok = false;
5239       aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5240       if( !ok )
5241         continue;
5242
5243       ok = false;
5244       aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5245       if( !ok )
5246         continue;
5247
5248       ok = false;
5249       aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5250       if( !ok )
5251         continue;
5252
5253       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5254       aPlaneDataList.push_back( aPlaneData );
5255     }
5256   }
5257
5258   TPlaneInfoMap aPlaneInfoMap;
5259
5260   std::vector<std::string> entries = ip->getEntries();
5261
5262   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5263   {
5264     // entry is a normal entry - it should be "decoded" (setting base adress of component)
5265     QString entry (ip->decodeEntry(*entIt).c_str());
5266
5267     // Check that the entry corresponds to a real object in the Study
5268     // as the object may be deleted or modified after the visual state is saved.
5269     _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5270     if (!so) continue; //Skip the not existent entry
5271
5272     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5273     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5274
5275     std::vector<std::string>::iterator namesIt = paramNames.begin();
5276     std::vector<std::string>::iterator valuesIt = paramValues.begin();
5277
5278     // actors are stored in a map after displaying of them for
5279     // quicker access in the future: map < viewID to actor >
5280     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5281
5282     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5283     {
5284       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5285       // '_' is used as separator and should not be used in viewer type or parameter names.
5286       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5287       if (lst.size() != 3)
5288         continue;
5289
5290       QString viewerTypStr = lst[0];
5291       QString viewIndexStr = lst[1];
5292       QString paramNameStr = lst[2];
5293
5294       bool ok;
5295       int viewIndex = viewIndexStr.toUInt(&ok);
5296       if (!ok) // bad conversion of view index to integer
5297         continue;
5298
5299       // viewers
5300       if (viewerTypStr == SVTK_Viewer::Type())
5301       {
5302         SMESH_Actor* aSmeshActor = 0;
5303         if (vtkActors.IsBound(viewIndex))
5304           aSmeshActor = vtkActors.Find(viewIndex);
5305
5306         QList<SUIT_ViewManager*> lst;
5307         getApp()->viewManagers(viewerTypStr, lst);
5308
5309         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5310         SUIT_ViewManager* vman = NULL;
5311         if (viewIndex >= 0 && viewIndex < lst.count())
5312           vman = lst.at(viewIndex);
5313
5314         if (paramNameStr == "Visibility")
5315         {
5316           if (!aSmeshActor && displayer() && vman)
5317           {
5318             SUIT_ViewModel* vmodel = vman->getViewModel();
5319             // SVTK view model can be casted to SALOME_View
5320             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5321
5322             // store displayed actor in a temporary map for quicker
5323             // access later when restoring other parameters
5324             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5325             vtkRenderer* Renderer = vtkView->getRenderer();
5326             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5327             vtkActorCollection* theActors = aCopy.GetActors();
5328             theActors->InitTraversal();
5329             bool isFound = false;
5330             vtkActor *ac = theActors->GetNextActor();
5331             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5332               if (ac->IsA("SMESH_Actor")) {
5333                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5334                 if (aGeomAc->hasIO()) {
5335                   Handle(SALOME_InteractiveObject) io =
5336                     Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5337                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5338                     isFound = true;
5339                     vtkActors.Bind(viewIndex, aGeomAc);
5340                   }
5341                 }
5342               }
5343             }
5344           }
5345         } // if (paramNameStr == "Visibility")
5346         else
5347         {
5348           // the rest properties "work" with SMESH_Actor
5349           if (aSmeshActor)
5350           {
5351             QString val ((*valuesIt).c_str());
5352
5353             // Representation
5354             if (paramNameStr == "Representation") {
5355               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5356             }
5357             // IsShrunk
5358             else if (paramNameStr == "IsShrunk") {
5359               if (val.toInt()) {
5360                 if (!aSmeshActor->IsShrunk())
5361                   aSmeshActor->SetShrink();
5362               }
5363               else {
5364                 if (aSmeshActor->IsShrunk())
5365                   aSmeshActor->UnShrink();
5366               }
5367             }
5368             // Displayed entities
5369             else if (paramNameStr == "Entities") {
5370               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5371               if (mode.count() == 6) {
5372                 if (mode[0] != "e" || mode[2]  != "f" || mode[4] != "v") {
5373                   MESSAGE("Invalid order of data in Entities, must be: "
5374                           "e:0/1:f:0/1:v:0/1");
5375                 }
5376                 else {
5377                   unsigned int aMode = aSmeshActor->GetEntityMode();
5378                   unsigned int aNewMode =
5379                     (int(SMESH_Actor::eEdges  ) * mode[1].toInt()) |
5380                     (int(SMESH_Actor::eFaces  ) * mode[3].toInt()) |
5381                     (int(SMESH_Actor::eVolumes) * mode[5].toInt());
5382                   if (aNewMode != aMode)
5383                     aSmeshActor->SetEntityMode(aNewMode);
5384                 }
5385               }
5386             }
5387             // Colors
5388             else if (paramNameStr == "Colors") {
5389               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5390               if (colors.count() == 16) {
5391                 if (colors[0] != "surface" || colors[4]  != "backsurface" ||
5392                     colors[8] != "edge"    || colors[12] != "node") {
5393                   MESSAGE("Invalid order of data in Colors, must be: "
5394                           "surface:r:g:b:backsurface:r:g:b:edge:r:g:b:node:r:g:b");
5395                 }
5396                 else {
5397                   aSmeshActor->SetSufaceColor(colors[1].toFloat(), colors[2].toFloat(), colors[3].toFloat());
5398                   aSmeshActor->SetBackSufaceColor(colors[5].toFloat(), colors[6].toFloat(), colors[7].toFloat());
5399                   aSmeshActor->SetEdgeColor(colors[9].toFloat(), colors[10].toFloat(), colors[11].toFloat());
5400                   aSmeshActor->SetNodeColor(colors[13].toFloat(), colors[14].toFloat(), colors[15].toFloat());
5401                 }
5402               }
5403             }
5404             // Sizes of lines and points
5405             else if (paramNameStr == "Sizes") {
5406               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
5407               if (sizes.count() == 4) {
5408                 if (sizes[0] != "line" || sizes[2] != "shrink") {
5409                   MESSAGE("Invalid order of data in Sizes, must be: "
5410                           "line:int:shrink:float");
5411                 }
5412                 else {
5413                   aSmeshActor->SetLineWidth(sizes[1].toInt());
5414                   aSmeshActor->SetShrinkFactor(sizes[3].toFloat());
5415                 }
5416               }
5417               else if (sizes.count() == 6) { // just to support old format
5418                 if (sizes[0] != "line" || sizes[2]  != "node" || sizes[4] != "shrink") {
5419                   MESSAGE("Invalid order of data in Sizes, must be: "
5420                           "line:int:node:int:shrink:float");
5421                 }
5422                 else {
5423                   aSmeshActor->SetLineWidth(sizes[1].toInt());
5424                   //aSmeshActor->SetNodeSize(sizes[3].toInt()); // made obsolete
5425                   aSmeshActor->SetShrinkFactor(sizes[5].toFloat());
5426                 }
5427               }
5428             }
5429             // Point marker
5430             else if (paramNameStr == "PointMarker") {
5431               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
5432               if( data.count() >= 2 ) {
5433                 bool ok = false;
5434                 int aParam1 = data[1].toInt( &ok );
5435                 if( ok ) {
5436                   if( data[0] == "std" && data.count() == 3 ) {
5437                     int aParam2 = data[2].toInt( &ok );
5438                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
5439                   }
5440                   else if( data[0] == "custom" ) {
5441                     VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
5442                     if( markerIt != aMarkerMap.end() ) {
5443                       VTK::MarkerData aMarkerData = markerIt->second;
5444                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
5445                     }
5446                   }
5447                 }
5448               }
5449             }
5450             // Opacity
5451             else if (paramNameStr == "Opacity") {
5452               aSmeshActor->SetOpacity(val.toFloat());
5453             }
5454             // Clipping
5455             else if (paramNameStr.startsWith("ClippingPlane")) {
5456               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
5457               // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
5458               // new format - val looks like "Off" or "0" (plane id)
5459               // (note: in new format "Off" value is used only for consistency,
5460               //  so it is processed together with values in old format)
5461               bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
5462               if( anIsOldFormat ) {
5463                 if (paramNameStr == "ClippingPlane1" || val == "Off")
5464                   aSmeshActor->RemoveAllClippingPlanes();
5465                 if (val != "Off") {
5466                   SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
5467                   double aDistance = vals[1].toFloat();
5468                   vtkFloatingPointType anAngle[2];
5469                   anAngle[0] = vals[2].toFloat();
5470                   anAngle[1] = vals[3].toFloat();
5471
5472                   QList<SUIT_ViewManager*> lst;
5473                   getApp()->viewManagers(viewerTypStr, lst);
5474                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5475                   if (viewIndex >= 0 && viewIndex < lst.count()) {
5476                     SUIT_ViewManager* vman = lst.at(viewIndex);
5477                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5478
5479                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
5480
5481                     SMESH::TActorList anActorList;
5482                     anActorList.push_back( aSmeshActor );
5483                     SMESH::OrientedPlane* aPlane =
5484                       SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
5485                     if( aPlane ) {
5486                       SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5487                       aClippingPlaneInfo.Plane = aPlane;
5488                       aClippingPlaneInfo.ActorList = anActorList;
5489                       aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5490                     }
5491                   }
5492                 }
5493               }
5494               else {
5495                 bool ok = false;
5496                 int aPlaneId = val.toInt( &ok );
5497                 if( ok && aPlaneId >= 0 ) {
5498                   bool anIsDefinedPlane = false;
5499                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
5500                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
5501                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5502                     TPlaneInfo& aPlaneInfo = *anIter;
5503                     if( aPlaneInfo.PlaneId == aPlaneId ) {
5504                       aPlaneInfo.ActorList.push_back( aSmeshActor );
5505                       anIsDefinedPlane = true;
5506                       break;
5507                     }
5508                   }
5509                   if( !anIsDefinedPlane ) {
5510                     TPlaneInfo aPlaneInfo;
5511                     aPlaneInfo.PlaneId = aPlaneId;
5512                     aPlaneInfo.ActorList.push_back( aSmeshActor );
5513                     aPlaneInfo.ViewManager = vman;
5514
5515                     // to make the list sorted by plane id
5516                     anIter = aPlaneInfoList.begin();
5517                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5518                       const TPlaneInfo& aPlaneInfoRef = *anIter;
5519                       if( aPlaneInfoRef.PlaneId > aPlaneId )
5520                         break;
5521                     }
5522                     aPlaneInfoList.insert( anIter, aPlaneInfo );
5523                   }
5524                 }
5525               }
5526             }
5527           } // if (aSmeshActor)
5528         } // other parameters than Visibility
5529       }
5530     } // for names/parameters iterator
5531   } // for entries iterator
5532
5533   // take into account planes with empty list of actors referred to them
5534   QList<SUIT_ViewManager*> aVMList;
5535   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
5536
5537   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
5538   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
5539     int aViewId = aPlaneDataIter->first;
5540     if( aViewId >= 0 && aViewId < aVMList.count() ) {
5541       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
5542
5543       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
5544
5545       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
5546       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
5547       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
5548         const TPlaneData& aPlaneData = *anIter2;
5549         int aPlaneId = aPlaneData.Id;
5550
5551         bool anIsFound = false;
5552         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5553         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5554           const TPlaneInfo& aPlaneInfo = *anIter3;
5555           if( aPlaneInfo.PlaneId == aPlaneId ) {
5556             anIsFound = true;
5557             break;
5558           }
5559         }
5560
5561         if( !anIsFound ) {
5562           TPlaneInfo aPlaneInfo; // ActorList field is empty
5563           aPlaneInfo.PlaneId = aPlaneId;
5564           aPlaneInfo.ViewManager = aViewManager;
5565
5566           // to make the list sorted by plane id
5567           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
5568           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
5569             const TPlaneInfo& aPlaneInfoRef = *anIter4;
5570             if( aPlaneInfoRef.PlaneId > aPlaneId )
5571               break;
5572           }
5573           aPlaneInfoList.insert( anIter4, aPlaneInfo );
5574         }
5575       }
5576     }
5577   }
5578
5579   // add clipping planes to actors according to the restored parameters
5580   // and update the clipping plane map
5581   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
5582   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
5583     int aViewId = anIter1->first;
5584     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
5585
5586     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
5587     if( anIter2 == aPlaneDataMap.end() )
5588       continue;
5589     const TPlaneDataList& aPlaneDataList = anIter2->second;
5590
5591     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5592     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5593       const TPlaneInfo& aPlaneInfo = *anIter3;
5594       int aPlaneId = aPlaneInfo.PlaneId;
5595       const TActorList& anActorList = aPlaneInfo.ActorList;
5596       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
5597       if( !aViewManager )
5598         continue;
5599
5600       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
5601       if( !aViewWindow )
5602         continue;
5603
5604       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
5605
5606       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
5607       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
5608         const TPlaneData& aPlaneData = *anIter4;
5609         if( aPlaneData.Id == aPlaneId ) {
5610           SMESH::OrientedPlane* aPlane =
5611             SMESHGUI_ClippingDlg::AddPlane( anActorList,
5612                                             aViewWindow,
5613                                             (SMESH::Orientation)aPlaneData.Orientation,
5614                                             aPlaneData.Distance,
5615                                             aPlaneData.Angle );
5616           if( aPlane ) {
5617             SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5618             aClippingPlaneInfo.Plane = aPlane;
5619             aClippingPlaneInfo.ActorList = anActorList;
5620             aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5621           }
5622           break;
5623         }
5624       }
5625     }
5626   }
5627
5628   // update all VTK views
5629   QList<SUIT_ViewManager*> lst;
5630   getApp()->viewManagers(lst);
5631   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
5632     SUIT_ViewModel* vmodel = (*it)->getViewModel();
5633     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
5634       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
5635       vtkView->getRenderer()->ResetCameraClippingRange();
5636       vtkView->Repaint();
5637     }
5638   }
5639 }
5640
5641 /*!
5642   \brief Adds preferences for dfont of VTK viewer
5643   \param label label
5644   \param pIf group identifier
5645   \param param parameter
5646   \return identifier of preferences
5647 */
5648 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
5649 {
5650   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
5651
5652   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
5653
5654   QStringList fam;
5655   fam.append( tr( "SMESH_FONT_ARIAL" ) );
5656   fam.append( tr( "SMESH_FONT_COURIER" ) );
5657   fam.append( tr( "SMESH_FONT_TIMES" ) );
5658
5659   setPreferenceProperty( tfont, "fonts", fam );
5660
5661   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
5662   setPreferenceProperty( tfont, "features", f );
5663
5664   return tfont;
5665 }
5666
5667 /*!
5668   \brief Actions after hypothesis edition
5669   Updates object browser after hypothesis edition
5670 */
5671 void SMESHGUI::onHypothesisEdit( int result )
5672 {
5673   if( result == 1 )
5674     SMESHGUI::Modified();
5675   updateObjBrowser( true );
5676 }
5677
5678
5679 /*!
5680   \brief Signal handler closing(SUIT_ViewWindow*) of a view
5681   \param pview view being closed
5682 */
5683 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
5684 #ifndef DISABLE_PLOT2DVIEWER
5685   //Crear all Plot2d Viewers if need.
5686   SMESH::ClearPlot2Viewers(pview);
5687 #endif
5688 }
5689
5690 /*!
5691   \brief Connects or disconnects signals about activating and cloning view on the module slots
5692   \param pview view which is connected/disconnected
5693 */
5694 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
5695   if(!pview)
5696     return;
5697
5698   SUIT_ViewManager* viewMgr = pview->getViewManager();
5699   if ( viewMgr ) {
5700     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
5701                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
5702
5703     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
5704              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
5705   }
5706 }
5707
5708 /*!
5709   \brief Return \c true if object can be renamed
5710 */
5711 bool SMESHGUI::renameAllowed( const QString& entry) const {
5712   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
5713   if( !anApp )
5714     return false;
5715
5716   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
5717   if( !aStudy )
5718     return false;
5719
5720   bool appRes = SalomeApp_Module::renameAllowed(entry);
5721   if( !appRes )
5722     return false;
5723
5724   // check type to prevent renaming of inappropriate objects
5725   int aType = SMESHGUI_Selection::type(qPrintable(entry), aStudy);
5726   if (aType == MESH || aType == GROUP ||
5727       aType == SUBMESH || aType == SUBMESH_COMPOUND ||
5728       aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
5729       aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
5730       aType == HYPOTHESIS || aType == ALGORITHM)
5731     return true;
5732
5733   return false;
5734 }
5735
5736 /*!
5737   Rename object by entry.
5738   \param entry entry of the object
5739   \param name new name of the object
5740   \brief Return \c true if rename operation finished successfully, \c false otherwise.
5741 */
5742 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
5743
5744   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
5745   if( !anApp )
5746     return false;
5747
5748   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
5749   if( !aStudy )
5750     return false;
5751
5752   bool appRes = SalomeApp_Module::renameObject(entry,name);
5753   if( !appRes )
5754     return false;
5755
5756   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
5757   _PTR(GenericAttribute) anAttr;
5758   _PTR(AttributeName) aName;
5759   if ( obj ) {
5760     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
5761       aName = anAttr;
5762       // check type to prevent renaming of inappropriate objects
5763       int aType = SMESHGUI_Selection::type( qPrintable(entry), aStudy );
5764       if (aType == MESH || aType == GROUP ||
5765           aType == SUBMESH || aType == SUBMESH_COMPOUND ||
5766           aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
5767           aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
5768           aType == HYPOTHESIS || aType == ALGORITHM) {
5769         if ( !name.isEmpty() ) {
5770           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
5771
5772           // update name of group object and its actor
5773           Handle(SALOME_InteractiveObject) IObject =
5774             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
5775
5776           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
5777           if( !aGroupObject->_is_nil() ) {
5778             aGroupObject->SetName( qPrintable(name) );
5779             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
5780               anActor->setName( qPrintable(name) );
5781           }
5782           return true;
5783         }
5784       }
5785     }
5786   }
5787   return false;
5788 }