src/SMESHGUI/SMESHGUI.cxx

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