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 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
1985 {
1986   return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
1987 }
1988
1989 //=============================================================================
1990 /*!
1991  *
1992  */
1993 //=============================================================================
1994 SMESHGUI* SMESHGUI::GetSMESHGUI()
1995 {
1996   SMESHGUI* smeshMod = 0;
1997   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
1998   if ( app )
1999   {
2000     CAM_Module* module = app->module( "Mesh" );
2001     smeshMod = dynamic_cast<SMESHGUI*>( module );
2002   }
2003
2004   if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2005   {
2006     SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2007     if ( study )
2008     {
2009       _PTR(Study) aStudy = study->studyDS();
2010       if ( aStudy )
2011         GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2012     }
2013   }
2014
2015   return smeshMod;
2016 }
2017
2018 extern "C"
2019 {
2020   Standard_EXPORT SMESHGUI* GetComponentGUI()
2021   {
2022     return SMESHGUI::GetSMESHGUI();
2023   }
2024 }
2025
2026 //=============================================================================
2027 /*!
2028  *
2029  */
2030 //=============================================================================
2031 void SMESHGUI::SetState(int aState)
2032 {
2033   myState = aState;
2034 }
2035
2036 //=============================================================================
2037 /*!
2038  *
2039  */
2040 //=============================================================================
2041 void SMESHGUI::ResetState()
2042 {
2043   myState = -1;
2044 }
2045
2046 //=============================================================================
2047 /*!
2048  *
2049  */
2050 //=============================================================================
2051 void SMESHGUI::EmitSignalDeactivateDialog()
2052 {
2053   emit SignalDeactivateActiveDialog();
2054 }
2055
2056 //=============================================================================
2057 /*!
2058  *
2059  */
2060 //=============================================================================
2061 void SMESHGUI::EmitSignalStudyFrameChanged()
2062 {
2063   emit SignalStudyFrameChanged();
2064 }
2065
2066 //=============================================================================
2067 /*!
2068  *
2069  */
2070 //=============================================================================
2071 void SMESHGUI::EmitSignalCloseAllDialogs()
2072 {
2073   emit SignalCloseAllDialogs();
2074 }
2075
2076 //=============================================================================
2077 /*!
2078  *
2079  */
2080 //=============================================================================
2081 void SMESHGUI::EmitSignalVisibilityChanged()
2082 {
2083   emit SignalVisibilityChanged();
2084 }
2085
2086 //=============================================================================
2087 /*!
2088  *
2089  */
2090 //=============================================================================
2091 QDialog *SMESHGUI::GetActiveDialogBox()
2092 {
2093   return myActiveDialogBox;
2094 }
2095
2096 //=============================================================================
2097 /*!
2098  *
2099  */
2100 //=============================================================================
2101 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2102 {
2103   myActiveDialogBox = (QDialog *) aDlg;
2104   return;
2105 }
2106
2107 //=============================================================================
2108 /*!
2109  *
2110  */
2111 //=============================================================================
2112 SUIT_Desktop* SMESHGUI::desktop()
2113 {
2114   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2115   if( app )
2116     return app->desktop();
2117   else
2118     return 0;
2119 }
2120
2121 //=============================================================================
2122 /*!
2123  *
2124  */
2125 //=============================================================================
2126 SalomeApp_Study* SMESHGUI::activeStudy()
2127 {
2128   SUIT_Application* app = SUIT_Session::session()->activeApplication();
2129   if( app )
2130     return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2131   else
2132     return NULL;
2133 }
2134
2135 //=============================================================================
2136 /*!
2137  *
2138  */
2139 //=============================================================================
2140 void SMESHGUI::Modified( bool theIsUpdateActions )
2141 {
2142   if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2143     if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2144       appStudy->Modified();
2145       if( theIsUpdateActions )
2146         app->updateActions();
2147     }
2148   }
2149 }
2150
2151 //=============================================================================
2152 /*!
2153  *
2154  */
2155 //=============================================================================
2156 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2157 {
2158   /* Here the position is on the bottom right corner - 10 */
2159   // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2160   aDlg->adjustSize();
2161   SUIT_Desktop *PP = desktop();
2162   x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2163   y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2164   return true;
2165 }
2166
2167 //=============================================================================
2168 /*!
2169  *
2170  */
2171 //=============================================================================
2172 static int isStudyLocked(_PTR(Study) theStudy){
2173   return theStudy->GetProperties()->IsLocked();
2174 }
2175
2176 static bool checkLock(_PTR(Study) theStudy) {
2177   if (isStudyLocked(theStudy)) {
2178     SUIT_MessageBox::warning( SMESHGUI::desktop(),
2179                               QObject::tr("WRN_WARNING"),
2180                               QObject::tr("WRN_STUDY_LOCKED") );
2181     return true;
2182   }
2183   return false;
2184 }
2185
2186 //=======================================================================
2187 //function : CheckActiveStudyLocked
2188 //purpose  :
2189 //=======================================================================
2190
2191 bool SMESHGUI::isActiveStudyLocked()
2192 {
2193   _PTR(Study) aStudy = activeStudy()->studyDS();
2194   return checkLock( aStudy );
2195 }
2196
2197 //=============================================================================
2198 /*!
2199  *
2200  */
2201 //=============================================================================
2202 bool SMESHGUI::OnGUIEvent( int theCommandID )
2203 {
2204   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2205   if( !anApp )
2206     return false;
2207
2208   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2209   SUIT_ResourceMgr* mgr = resourceMgr();
2210   if( !mgr )
2211     return false;
2212
2213   if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2214     GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2215   }
2216
2217   SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2218   SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2219
2220   //QAction* act = action( theCommandID );
2221
2222   switch (theCommandID) {
2223   case 33:                                      // DELETE
2224     if(checkLock(aStudy)) break;
2225     OnEditDelete();
2226     break;
2227
2228   case 116:
2229   case 115:
2230   case 117:
2231   case 118:
2232   case 113:
2233   case 112:
2234   case 111:                                     // IMPORT
2235     {
2236       if(checkLock(aStudy)) break;
2237       ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2238       break;
2239     }
2240
2241   case 150:    //MED FILE INFORMATION
2242     {
2243       SALOME_ListIO selected;
2244       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2245       if( aSel )
2246         aSel->selectedObjects( selected );
2247       if( selected.Extent() )
2248       {
2249         Handle(SALOME_InteractiveObject) anIObject = selected.First();
2250         SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2251         if ( !aMesh->_is_nil() )
2252         {
2253           SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2254           dlg.exec();
2255         }
2256       }
2257       break;
2258     }
2259
2260   case 122:                                     // EXPORT MED
2261   case 121:
2262   case 123:
2263   case 124:
2264   case 125:
2265   case 126:
2266   case 140:
2267   case 141:
2268   case 142:
2269   case 143:
2270   case 144:
2271   case 145:
2272   case 146:
2273   case 147:
2274     {
2275       ::ExportMeshToFile(theCommandID);
2276       break;
2277     }
2278
2279   case 200:                                     // SCALAR BAR
2280     {
2281       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2282       SALOME_ListIO selected;
2283       if( aSel )
2284         aSel->selectedObjects( selected );
2285
2286       if( selected.Extent() ) {
2287         Handle(SALOME_InteractiveObject) anIO = selected.First();
2288         if( anIO->hasEntry() ) {
2289           if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2290             anActor->SetControlMode( SMESH_Actor::eNone );
2291 #ifndef DISABLE_PLOT2DVIEWER
2292             SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2293 #endif
2294           }
2295         }
2296       }
2297       break;
2298     }
2299   case 201:
2300     {
2301       SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2302       break;
2303     }
2304   case 2021:
2305     {
2306       // dump control distribution data to the text file
2307       ::SaveDistribution();
2308       break;
2309     }
2310
2311   case 2022:
2312     {
2313       // show/ distribution
2314       ::ShowDistribution();
2315       break;
2316     }
2317
2318 #ifndef DISABLE_PLOT2DVIEWER
2319   case 2023:
2320     {
2321       // plot distribution
2322       ::PlotDistribution();
2323       break;
2324     }
2325 #endif
2326
2327     // Auto-color
2328   case 1136:
2329     ::AutoColor();
2330   break;
2331
2332   case 1137:
2333     ::DisableAutoColor();
2334   break;
2335
2336   case 1134: // Clipping
2337   case 1133: // Tranparency
2338   case 1132: // Display preferences (colors, shrink size, line width, ...)
2339
2340     // Display Mode
2341   case 215: // Nodes
2342   case 213: // Nodes
2343   case 212: // Nodes
2344   case 211: // Nodes
2345     ::SetDisplayMode(theCommandID, myMarkerMap);
2346   break;
2347
2348   //2D quadratic representation
2349   case 231:
2350   case 232:
2351     ::SetDisplayMode(theCommandID, myMarkerMap);
2352   break;
2353
2354   // Display Entity
2355   case 216: // 0D elements
2356   case 217: // Edges
2357   case 218: // Faces
2358   case 219: // Volumes
2359   case 220: // All Entity
2360   case 222: // Balls
2361     ::SetDisplayEntity(theCommandID);
2362   break;
2363
2364   case 221: // Orientation of faces
2365     {
2366       LightApp_SelectionMgr* mgr = selectionMgr();
2367       SALOME_ListIO selected; mgr->selectedObjects( selected );
2368
2369       SALOME_ListIteratorOfListIO it(selected);
2370       for( ; it.More(); it.Next()) {
2371         Handle(SALOME_InteractiveObject) anIObject = it.Value();
2372         if(anIObject->hasEntry()) {
2373           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2374             anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2375           }
2376         }
2377       }
2378       break;
2379     }
2380
2381   case 214:                                     // UPDATE
2382     {
2383       if(checkLock(aStudy)) break;
2384       SUIT_OverrideCursor wc;
2385       try {
2386 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2387         OCC_CATCH_SIGNALS;
2388 #endif
2389         SMESH::UpdateView();
2390       }
2391       catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2392         SMESH::OnVisuException();
2393       }
2394       catch (...) { // PAL16774 (Crash after display of many groups)
2395         SMESH::OnVisuException();
2396       }
2397
2398       SALOME_ListIO l;
2399       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2400       aSel->selectedObjects( l );
2401       aSel->setSelectedObjects( l );
2402       break;
2403     }
2404
2405   case 300:                                     // ERASE
2406   case 301:                                     // DISPLAY
2407   case 302:                                     // DISPLAY ONLY
2408     {
2409       SMESH::EDisplaing anAction;
2410       switch (theCommandID) {
2411       case 300: anAction = SMESH::eErase; break;
2412       case 301: anAction = SMESH::eDisplay; break;
2413       case 302: anAction = SMESH::eDisplayOnly; break;
2414       }
2415
2416       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2417       SALOME_ListIO sel_objects, to_process;
2418       if (aSel)
2419         aSel->selectedObjects( sel_objects );
2420
2421       if( theCommandID==302 )
2422       {
2423         MESSAGE("anAction = SMESH::eDisplayOnly");
2424         startOperation( myEraseAll );
2425       }
2426
2427       extractContainers( sel_objects, to_process );
2428
2429       try {
2430 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2431         OCC_CATCH_SIGNALS;
2432 #endif
2433         if (vtkwnd) {
2434           SALOME_ListIteratorOfListIO It( to_process );
2435           for ( ; It.More(); It.Next()) {
2436                 MESSAGE("---");
2437             Handle(SALOME_InteractiveObject) IOS = It.Value();
2438             if (IOS->hasEntry()) {
2439                 MESSAGE("---");
2440               if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2441                 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2442                 break; // PAL16774 (Crash after display of many groups)
2443               }
2444               if (anAction == SMESH::eDisplayOnly)
2445               {
2446                 MESSAGE("anAction = SMESH::eDisplayOnly");
2447                 anAction = SMESH::eDisplay;
2448               }
2449             }
2450           }
2451         }
2452
2453         // PAL13338 + PAL15161 -->
2454         if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2455                 MESSAGE("anAction = SMESH::eDisplayOnly");
2456           SMESH::UpdateView();
2457           SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2458         }
2459         // PAL13338 + PAL15161 <--
2460       }
2461       catch (...) { // PAL16774 (Crash after display of many groups)
2462         SMESH::OnVisuException();
2463       }
2464
2465       if (anAction == SMESH::eErase) {
2466         MESSAGE("anAction == SMESH::eErase");
2467         SALOME_ListIO l1;
2468         aSel->setSelectedObjects( l1 );
2469       }
2470       else
2471         aSel->setSelectedObjects( to_process );
2472
2473       break;
2474     }
2475
2476   case 4000:                                    // NODES
2477     {
2478       if(checkLock(aStudy)) break;
2479
2480       if ( vtkwnd ) {
2481         EmitSignalDeactivateDialog();
2482
2483         ( new SMESHGUI_NodesDlg( this ) )->show();
2484       }
2485       else {
2486         SUIT_MessageBox::warning(desktop(),
2487                                  tr("SMESH_WRN_WARNING"),
2488                                  tr("SMESH_WRN_VIEWER_VTK"));
2489       }
2490       break;
2491     }
2492
2493   case 2151:  // FILTER
2494   {
2495     if ( vtkwnd )
2496     {
2497       EmitSignalDeactivateDialog();
2498       ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2499     }
2500     break;
2501   }
2502
2503   case 701: // COMPUTE MESH
2504   case 711: // PRECOMPUTE MESH
2505   case 712: // EVALUATE MESH
2506   case 713: // MESH ORDER
2507   case 702: // Create mesh
2508   case 703: // Create sub-mesh
2509   case 704: // Edit mesh/sub-mesh
2510     startOperation( theCommandID );
2511     break;
2512   case 705: // copy mesh
2513     {
2514       if (checkLock(aStudy)) break;
2515       EmitSignalDeactivateDialog();
2516       ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2517     }
2518     break;
2519   case 710: // Build compound mesh
2520     {
2521       if (checkLock(aStudy)) break;
2522       EmitSignalDeactivateDialog();
2523       ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2524     }
2525     break;
2526
2527   case 407: // DIAGONAL INVERSION
2528   case 408: // Delete diagonal
2529     {
2530       if ( !vtkwnd )
2531       {
2532         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2533                                   tr( "NOT_A_VTK_VIEWER" ) );
2534         break;
2535       }
2536
2537       if ( checkLock( aStudy ) )
2538         break;
2539
2540       /*Standard_Boolean aRes;
2541       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2542       if ( aMesh->_is_nil() )
2543       {
2544         SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2545           tr( "SMESH_BAD_SELECTION" ) );
2546         break;
2547       }
2548       */
2549       EmitSignalDeactivateDialog();
2550       if ( theCommandID == 407 )
2551         ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2552       else
2553         ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2554       break;
2555     }
2556   case 409: // Change orientation
2557   case 410: // Union of triangles
2558   case 411: // Cutting of quadrangles
2559   case 419: // Splitting volumes into tetrahedra
2560     {
2561       if ( !vtkwnd )
2562       {
2563         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2564                                   tr( "NOT_A_VTK_VIEWER" ) );
2565         break;
2566       }
2567
2568       if ( checkLock( aStudy ) )
2569         break;
2570
2571       EmitSignalDeactivateDialog();
2572       SMESHGUI_MultiEditDlg* aDlg = NULL;
2573       if ( theCommandID == 409 )
2574         aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2575       else if ( theCommandID == 410 )
2576         aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2577       else if ( theCommandID == 419 )
2578         aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2579       else
2580         aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2581
2582       aDlg->show();
2583       break;
2584     }
2585   case 412: // Smoothing
2586     {
2587       if(checkLock(aStudy)) break;
2588       if( vtkwnd ) {
2589         EmitSignalDeactivateDialog();
2590         ( new SMESHGUI_SmoothingDlg( this ) )->show();
2591       }
2592       else {
2593         SUIT_MessageBox::warning(desktop(),
2594                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2595       }
2596       break;
2597     }
2598   case 413: // Extrusion
2599     {
2600       if (checkLock(aStudy)) break;
2601       if (vtkwnd) {
2602         EmitSignalDeactivateDialog();
2603         ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2604       } else {
2605         SUIT_MessageBox::warning(desktop(),
2606                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2607       }
2608       break;
2609     }
2610   case 414: // Revolution
2611     {
2612       if(checkLock(aStudy)) break;
2613       if( vtkwnd ) {
2614         EmitSignalDeactivateDialog();
2615         ( new SMESHGUI_RevolutionDlg( this ) )->show();
2616       }
2617       else {
2618         SUIT_MessageBox::warning(desktop(),
2619                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2620       }
2621       break;
2622     }
2623   case 415: // Pattern mapping
2624     {
2625       if ( checkLock( aStudy ) )
2626         break;
2627       if ( vtkwnd )
2628       {
2629         EmitSignalDeactivateDialog();
2630         ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2631       }
2632       else {
2633         SUIT_MessageBox::warning(desktop(),
2634                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2635       }
2636       break;
2637     }
2638   case 416: // Extrusion along a path
2639     {
2640       if (checkLock(aStudy)) break;
2641       if (vtkwnd) {
2642         EmitSignalDeactivateDialog();
2643         ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2644       } else {
2645         SUIT_MessageBox::warning(desktop(),
2646                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2647       }
2648       break;
2649     }
2650   case 417: // Convert mesh to quadratic
2651   case 418: // create 2D mesh from 3D
2652   case 420: // Reorient faces
2653   case 806: // CREATE GEO GROUP
2654     {
2655       startOperation( theCommandID );
2656       break;
2657     }
2658   case 801:                                     // CREATE GROUP
2659     {
2660       if ( !vtkwnd )
2661       {
2662         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2663                                   tr( "NOT_A_VTK_VIEWER" ) );
2664         break;
2665       }
2666
2667       if(checkLock(aStudy)) break;
2668       EmitSignalDeactivateDialog();
2669       SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2670
2671       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2672       SALOME_ListIO selected;
2673       if( aSel )
2674         aSel->selectedObjects( selected );
2675
2676       int nbSel = selected.Extent();
2677       if (nbSel == 1) {
2678         // check if mesh is selected
2679         aMesh = SMESH::GetMeshByIO( selected.First() );
2680       }
2681       SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2682       aDlg->show();
2683       break;
2684     }
2685
2686   case 802:                                     // CONSTRUCT GROUP
2687     {
2688       if ( !vtkwnd )
2689       {
2690         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2691                                   tr( "NOT_A_VTK_VIEWER" ) );
2692         break;
2693       }
2694
2695       if(checkLock(aStudy)) break;
2696       EmitSignalDeactivateDialog();
2697
2698       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2699       SALOME_ListIO selected;
2700       if( aSel )
2701         aSel->selectedObjects( selected );
2702
2703       int nbSel = selected.Extent();
2704       if (nbSel == 1) {
2705         // check if submesh is selected
2706         Handle(SALOME_InteractiveObject) IObject = selected.First();
2707         if (IObject->hasEntry()) {
2708           _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2709           if( aSObj ) {
2710             SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2711             if (!aSubMesh->_is_nil()) {
2712               try {
2713                 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2714                 // get submesh elements list by types
2715                 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2716                 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2717                 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2718                 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2719                 // create group for each type o elements
2720                 QString aName = IObject->getName();
2721                 QStringList anEntryList;
2722                 if (aNodes->length() > 0) {
2723                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2724                   aGroup->Add(aNodes.inout());
2725                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2726                     anEntryList.append( aSObject->GetID().c_str() );
2727                 }
2728                 if (aEdges->length() > 0) {
2729                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2730                   aGroup->Add(aEdges.inout());
2731                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2732                     anEntryList.append( aSObject->GetID().c_str() );
2733                 }
2734                 if (aFaces->length() > 0) {
2735                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2736                   aGroup->Add(aFaces.inout());
2737                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2738                     anEntryList.append( aSObject->GetID().c_str() );
2739                 }
2740                 if (aVolumes->length() > 0) {
2741                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2742                   aGroup->Add(aVolumes.inout());
2743                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2744                     anEntryList.append( aSObject->GetID().c_str() );
2745                 }
2746                 updateObjBrowser();
2747                 anApp->browseObjects( anEntryList );
2748               }
2749               catch(const SALOME::SALOME_Exception & S_ex){
2750                 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2751               }
2752             }
2753           }
2754         }
2755       }
2756       else if(nbSel==0) {
2757         SUIT_MessageBox::warning(desktop(),
2758                                  tr("SMESH_WRN_WARNING"),
2759                                  tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2760       }
2761       break;
2762     }
2763
2764   case 803:                                     // EDIT GROUP
2765     {
2766       if ( !vtkwnd )
2767       {
2768         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2769                                   tr( "NOT_A_VTK_VIEWER" ) );
2770         break;
2771       }
2772
2773       if(checkLock(aStudy)) break;
2774       EmitSignalDeactivateDialog();
2775
2776       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2777       SALOME_ListIO selected;
2778       if( aSel )
2779         aSel->selectedObjects( selected );
2780
2781       SALOME_ListIteratorOfListIO It (selected);
2782       int nbSelectedGroups = 0;
2783       for ( ; It.More(); It.Next() )
2784       {
2785         SMESH::SMESH_GroupBase_var aGroup =
2786           SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2787         if (!aGroup->_is_nil()) {
2788           nbSelectedGroups++;
2789           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2790           aDlg->show();
2791         }
2792       }
2793       if (nbSelectedGroups == 0)
2794         {
2795           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2796           aDlg->show();
2797         }
2798       break;
2799     }
2800
2801   case 804:                                     // Add elements to group
2802     {
2803       if(checkLock(aStudy)) break;
2804       if (myState == 800) {
2805         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2806         if (aDlg) aDlg->onAdd();
2807       }
2808       break;
2809     }
2810
2811   case 805:                                     // Remove elements from group
2812     {
2813       if(checkLock(aStudy)) break;
2814       if (myState == 800) {
2815         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2816         if (aDlg) aDlg->onRemove();
2817       }
2818       break;
2819     }
2820
2821   case 815:                                     // Edit GEOM GROUP as standalone
2822     {
2823       if ( !vtkwnd )
2824       {
2825         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2826                                   tr( "NOT_A_VTK_VIEWER" ) );
2827         break;
2828       }
2829
2830       if(checkLock(aStudy)) break;
2831       EmitSignalDeactivateDialog();
2832
2833       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2834       SALOME_ListIO selected;
2835       if( aSel )
2836         aSel->selectedObjects( selected );
2837
2838       SALOME_ListIteratorOfListIO It (selected);
2839       for ( ; It.More(); It.Next() )
2840       {
2841         SMESH::SMESH_GroupOnGeom_var aGroup =
2842           SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2843         if (!aGroup->_is_nil()) {
2844           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2845           aDlg->show();
2846         }
2847         else
2848         {
2849           SMESH::SMESH_GroupOnFilter_var aGroup =
2850             SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2851           if (!aGroup->_is_nil()) {
2852             SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2853             aDlg->show();
2854           }
2855         }
2856       }
2857       break;
2858     }
2859
2860     case 810: // Union Groups
2861     case 811: // Intersect groups
2862     case 812: // Cut groups
2863     {
2864       if ( !vtkwnd )
2865       {
2866         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2867                                   tr( "NOT_A_VTK_VIEWER" ) );
2868         break;
2869       }
2870
2871       if ( checkLock( aStudy ) )
2872         break;
2873
2874       EmitSignalDeactivateDialog();
2875
2876       SMESHGUI_GroupOpDlg* aDlg = 0;
2877       if ( theCommandID == 810 )
2878         aDlg = new SMESHGUI_UnionGroupsDlg( this );
2879       else if ( theCommandID == 811 )
2880         aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2881       else
2882         aDlg = new SMESHGUI_CutGroupsDlg( this );
2883
2884       aDlg->show();
2885
2886       break;
2887     }
2888
2889     case 814: // Create groups of entities from existing groups of superior dimensions
2890     {
2891       if ( checkLock( aStudy ) )
2892         break;
2893
2894       EmitSignalDeactivateDialog();
2895       SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2896       aDlg->show();
2897
2898       break;
2899     }
2900
2901     case 813: // Delete groups with their contents
2902     {
2903       if ( !vtkwnd )
2904       {
2905         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2906                                   tr( "NOT_A_VTK_VIEWER" ) );
2907         break;
2908       }
2909
2910       if ( checkLock( aStudy ) )
2911         break;
2912
2913       EmitSignalDeactivateDialog();
2914
2915       ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2916       break;
2917     }
2918
2919   case 900:                                     // MESH INFOS
2920   case 903:                                     // WHAT IS
2921     {
2922       int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2923       EmitSignalDeactivateDialog();
2924       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2925       SALOME_ListIO selected;
2926       if( aSel )
2927         aSel->selectedObjects( selected );
2928
2929       if ( selected.Extent() > 1 ) { // a dlg for each IO
2930         SALOME_ListIteratorOfListIO It( selected );
2931         for ( ; It.More(); It.Next() ) {
2932           SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2933           dlg->showInfo( It.Value() );
2934           dlg->show();
2935         }
2936       }
2937       else {
2938         SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2939         dlg->show();
2940       }
2941       break;
2942     }
2943
2944   case 904:                                     // FIND ELEM
2945     {
2946       startOperation( theCommandID );
2947       break;
2948     }
2949
2950   case 1100:                                    // EDIT HYPOTHESIS
2951     {
2952       if(checkLock(aStudy)) break;
2953
2954       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2955       SALOME_ListIO selected;
2956       if( aSel )
2957         aSel->selectedObjects( selected );
2958
2959       int nbSel = selected.Extent();
2960
2961       if (nbSel == 1) {
2962         Handle(SALOME_InteractiveObject) anIObject = selected.First();
2963         SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
2964
2965         /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
2966         /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects                   */
2967         /* Warning : however by internal mechanism all subMeshes icons are changed !                     */
2968         if ( !aHypothesis->_is_nil() )
2969         {
2970           // BUG 0020378
2971           //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2972           SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2973           if (aCreator) {
2974             aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
2975           }
2976           else
2977           {
2978             // report error
2979           }
2980         }
2981       }
2982       break;
2983     }
2984   case 1102:                                    // REMOVE HYPOTHESIS / ALGORITHMS
2985     {
2986       if(checkLock(aStudy)) break;
2987       SUIT_OverrideCursor wc;
2988
2989       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2990       SALOME_ListIO selected;
2991       if( aSel )
2992         aSel->selectedObjects( selected, QString::null, false );
2993
2994       SALOME_ListIteratorOfListIO It(selected);
2995       for (int i = 0; It.More(); It.Next(), i++) {
2996         Handle(SALOME_InteractiveObject) IObject = It.Value();
2997         SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2998       }
2999       SALOME_ListIO l1;
3000       aSel->setSelectedObjects( l1 );
3001       updateObjBrowser();
3002       break;
3003     }
3004
3005   case 4008:                                    // BALL
3006   case 4009:                                    // ELEM0D
3007   case 4010:                                    // EDGE
3008   case 4021:                                    // TRIANGLE
3009   case 4022:                                    // QUAD
3010   case 4023:                                    // POLYGON
3011   case 4031:                                    // TETRA
3012   case 4032:                                    // HEXA
3013   case 4133:                                    // PENTA
3014   case 4134:                                    // PYRAMID
3015   case 4135:                                    // OCTA12
3016     {
3017       if(checkLock(aStudy)) break;
3018       if ( vtkwnd ) {
3019         EmitSignalDeactivateDialog();
3020         SMDSAbs_EntityType type = SMDSEntity_Edge;
3021         switch (theCommandID) {
3022         case 4008: type = SMDSEntity_Ball;            break;
3023         case 4009: type = SMDSEntity_0D;              break;
3024         case 4021: type = SMDSEntity_Triangle;        break;
3025         case 4022: type = SMDSEntity_Quadrangle;      break;
3026         case 4031: type = SMDSEntity_Tetra;           break;
3027         case 4023: type = SMDSEntity_Polygon;         break;
3028         case 4032: type = SMDSEntity_Hexa;            break;
3029         case 4133: type = SMDSEntity_Penta;           break;
3030         case 4134: type = SMDSEntity_Pyramid;         break;
3031         case 4135: type = SMDSEntity_Hexagonal_Prism; break;
3032         default:;
3033         }
3034         ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3035       }
3036       else {
3037         SUIT_MessageBox::warning(desktop(),
3038                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3039       }
3040       break;
3041     }
3042   case 4033:                                    // POLYHEDRON
3043     {
3044       if(checkLock(aStudy)) break;
3045       if ( vtkwnd ) {
3046         EmitSignalDeactivateDialog();
3047         ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3048       }
3049       else {
3050         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3051                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3052       }
3053       break;
3054     }
3055   case 4034:     // QUADRATIC EDGE
3056   case 4035:     // QUADRATIC TRIANGLE
3057   case 4036:     // QUADRATIC QUADRANGLE
3058   case 4136:     // BIQUADRATIC QUADRANGLE
3059   case 4137:     // BIQUADRATIC TRIANGLE
3060   case 4037:     // QUADRATIC TETRAHEDRON
3061   case 4038:     // QUADRATIC PYRAMID
3062   case 4039:     // QUADRATIC PENTAHEDRON
3063   case 4040:     // QUADRATIC HEXAHEDRON
3064   case 4140:     // TRIQUADRATIC HEXAHEDRON
3065     {
3066       if(checkLock(aStudy)) break;
3067       if ( vtkwnd ) {
3068         EmitSignalDeactivateDialog();
3069         SMDSAbs_EntityType type = SMDSEntity_Last;
3070
3071         switch (theCommandID) {
3072         case 4034: type = SMDSEntity_Quad_Edge; break;
3073         case 4035: type = SMDSEntity_Quad_Triangle; break;
3074         case 4036: type = SMDSEntity_Quad_Quadrangle; break;
3075         case 4136: type = SMDSEntity_BiQuad_Quadrangle; break;
3076         case 4137: type = SMDSEntity_BiQuad_Triangle; break;
3077         case 4037: type = SMDSEntity_Quad_Tetra; break;
3078         case 4038: type = SMDSEntity_Quad_Pyramid; break;
3079         case 4039: type = SMDSEntity_Quad_Penta; break;
3080         case 4040: type = SMDSEntity_Quad_Hexa; break;
3081         case 4140: type = SMDSEntity_TriQuad_Hexa; break;
3082         default: break;
3083         }
3084         if ( type != SMDSEntity_Last )
3085           ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3086       }
3087       else {
3088         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3089                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3090       }
3091       break;
3092     }
3093   case 4041:                                    // REMOVES NODES
3094     {
3095       if(checkLock(aStudy)) break;
3096       if ( vtkwnd ) {
3097         EmitSignalDeactivateDialog();
3098         ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3099       }
3100       else {
3101         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3102                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3103       }
3104       break;
3105     }
3106   case 4042:                                    // REMOVES ELEMENTS
3107     {
3108       if(checkLock(aStudy)) break;
3109       if( vtkwnd ) {
3110         EmitSignalDeactivateDialog();
3111         ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3112       }
3113       else
3114         {
3115           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3116                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3117         }
3118       break;
3119     }
3120   case 4043: {                                // CLEAR_MESH
3121
3122     if(checkLock(aStudy)) break;
3123
3124     SALOME_ListIO selected;
3125     if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3126       aSel->selectedObjects( selected );
3127
3128     SUIT_OverrideCursor wc;
3129     SALOME_ListIteratorOfListIO It (selected);
3130     for ( ; It.More(); It.Next() )
3131     {
3132       Handle(SALOME_InteractiveObject) IOS = It.Value();
3133       SMESH::SMESH_Mesh_var aMesh =
3134         SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3135       if ( aMesh->_is_nil()) continue;
3136       try {
3137         SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3138         aMesh->Clear();
3139         _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3140         SMESH::ModifiedMesh( aMeshSObj, false, true);
3141         // hide groups and submeshes
3142         _PTR(ChildIterator) anIter =
3143           SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3144         for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3145         {
3146           _PTR(SObject) so = anIter->Value();
3147           SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3148         }
3149       }
3150       catch (const SALOME::SALOME_Exception& S_ex){
3151         wc.suspend();
3152         SalomeApp_Tools::QtCatchCorbaException(S_ex);
3153         wc.resume();
3154       }
3155     }
3156     SMESH::UpdateView();
3157     updateObjBrowser();
3158     break;
3159   }
3160   case 4044:                                     // REMOVE ORPHAN NODES
3161     {
3162       if(checkLock(aStudy)) break;
3163       SALOME_ListIO selected;
3164       if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3165         aSel->selectedObjects( selected );
3166       if ( selected.Extent() == 1 ) {
3167         Handle(SALOME_InteractiveObject) anIO = selected.First();
3168         SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3169         if ( !aMesh->_is_nil() ) {
3170           bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3171                                                     tr( "SMESH_WARNING" ),
3172                                                     tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3173                                                     SUIT_MessageBox::Yes |
3174                                                     SUIT_MessageBox::No,
3175                                                     SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3176           if( confirm ) {
3177             try {
3178               SUIT_OverrideCursor wc;
3179               SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3180               int removed = aMeshEditor->RemoveOrphanNodes();
3181               SUIT_MessageBox::information(SMESHGUI::desktop(),
3182                                            tr("SMESH_INFORMATION"),
3183                                            tr("NB_NODES_REMOVED").arg(removed));
3184               if ( removed > 0 ) {
3185                 SMESH::UpdateView();
3186                 SMESHGUI::Modified();
3187               }
3188             }
3189             catch (const SALOME::SALOME_Exception& S_ex) {
3190               SalomeApp_Tools::QtCatchCorbaException(S_ex);
3191             }
3192             catch (...) {
3193             }
3194           }
3195         }
3196       }
3197       break;
3198     }
3199   case 4051:                                    // RENUMBERING NODES
3200     {
3201       if(checkLock(aStudy)) break;
3202       if( vtkwnd ) {
3203         EmitSignalDeactivateDialog();
3204         ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3205       }
3206       else
3207         {
3208           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3209                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3210         }
3211       break;
3212     }
3213   case 4052:                                    // RENUMBERING ELEMENTS
3214     {
3215       if(checkLock(aStudy)) break;
3216       if ( vtkwnd ) {
3217         EmitSignalDeactivateDialog();
3218         ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3219       }
3220       else
3221         {
3222           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3223                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3224         }
3225       break;
3226     }
3227   case 4061:                                   // TRANSLATION
3228     {
3229       if(checkLock(aStudy)) break;
3230       if ( vtkwnd ) {
3231         EmitSignalDeactivateDialog();
3232         ( new SMESHGUI_TranslationDlg( this ) )->show();
3233       }
3234       else {
3235         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3236                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3237       }
3238       break;
3239     }
3240   case 4062:                                   // ROTATION
3241     {
3242       if(checkLock(aStudy)) break;
3243       if( vtkwnd ) {
3244         EmitSignalDeactivateDialog();
3245         ( new SMESHGUI_RotationDlg( this ) )->show();
3246       }
3247       else {
3248         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3249                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3250       }
3251       break;
3252     }
3253   case 4063:                                   // SYMMETRY
3254     {
3255       if(checkLock(aStudy)) break;
3256       if(vtkwnd) {
3257         EmitSignalDeactivateDialog();
3258         ( new SMESHGUI_SymmetryDlg( this ) )->show();
3259       }
3260       else {
3261         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3262                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3263       }
3264       break;
3265     }
3266   case 4064:                                   // SEWING
3267     {
3268       if(checkLock(aStudy)) break;
3269       if(vtkwnd) {
3270         EmitSignalDeactivateDialog();
3271         ( new SMESHGUI_SewingDlg( this ) )->show();
3272       }
3273       else {
3274         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3275                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3276       }
3277       break;
3278     }
3279   case 4065:                                   // MERGE NODES
3280     {
3281       if(checkLock(aStudy)) break;
3282       if(vtkwnd) {
3283         EmitSignalDeactivateDialog();
3284         ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3285       }
3286       else {
3287         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3288                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3289       }
3290       break;
3291     }
3292   case 4066:                                   // MERGE EQUAL ELEMENTS
3293     {
3294       if (checkLock(aStudy)) break;
3295       if (vtkwnd) {
3296         EmitSignalDeactivateDialog();
3297         ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3298       } else {
3299         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3300                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3301       }
3302       break;
3303     }
3304
3305   case 4067: // MAKE MESH PASS THROUGH POINT
3306     startOperation( 4067 );
3307     break;
3308
3309   case 4068: // SCALE
3310     {
3311       if(checkLock(aStudy)) break;
3312       if ( vtkwnd ) {
3313         EmitSignalDeactivateDialog();
3314         ( new SMESHGUI_ScaleDlg( this ) )->show();
3315       }
3316       else {
3317         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3318                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3319       }
3320       break;
3321     }
3322
3323   case 4069: // DUPLICATE NODES
3324     {
3325       if(checkLock(aStudy)) break;
3326       if ( vtkwnd ) {
3327         EmitSignalDeactivateDialog();
3328         ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3329       }
3330       else {
3331         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3332                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3333       }
3334       break;
3335     }
3336
3337   case 4070: // 0D_ON_ALL_NODES
3338     startOperation( 4070 );
3339     break;
3340
3341   case 5105: // Library of selection filters
3342   {
3343     static QList<int> aTypes;
3344     if ( aTypes.isEmpty() )
3345     {
3346       aTypes.append( SMESH::NODE );
3347       aTypes.append( SMESH::EDGE );
3348       aTypes.append( SMESH::FACE );
3349       aTypes.append( SMESH::VOLUME );
3350     }
3351     if (!myFilterLibraryDlg)
3352       myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3353     else if (myFilterLibraryDlg->isHidden())
3354       myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3355     myFilterLibraryDlg->raise();
3356   }
3357   break;
3358
3359   case 6017:                                    // CONTROLS
3360   case 6016:
3361   case 6015:
3362   case 6014:
3363   case 6013:
3364   case 6012:
3365   case 6011:
3366   case 6001:
3367   case 6018:
3368   case 6019:
3369   case 6002:
3370   case 6003:
3371   case 6004:
3372   case 6005:
3373   case 6009:
3374   case 6021:
3375   case 6022:
3376   case 6023:
3377   case 6024:
3378   case 6025:
3379   case 6026:
3380   case 6027:
3381   case 6028:
3382   case 6029:
3383   case 6030:
3384   case 6031:
3385     if ( vtkwnd ) {
3386
3387       LightApp_SelectionMgr* mgr = selectionMgr();
3388       SALOME_ListIO selected; mgr->selectedObjects( selected );
3389
3390       if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3391         _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3392         if ( SO ) {
3393           CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3394           SMESH::SMESH_Mesh_var      aMesh    = SMESH::SMESH_Mesh::_narrow( aObject );
3395           SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3396           SMESH::SMESH_GroupBase_var aGroup   = SMESH::SMESH_GroupBase::_narrow( aObject );
3397           if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3398             SUIT_OverrideCursor wc;
3399             ::Control( theCommandID );
3400             break;
3401           }
3402         }
3403       }
3404       SUIT_MessageBox::warning(desktop(),
3405                                tr( "SMESH_WRN_WARNING" ),
3406                                tr( "SMESH_BAD_SELECTION" ) );
3407       break;
3408     }
3409     else {
3410       SUIT_MessageBox::warning(desktop(),
3411                                tr( "SMESH_WRN_WARNING" ),
3412                                tr( "NOT_A_VTK_VIEWER" ) );
3413     }
3414     break;
3415   case 6032:
3416     OverallMeshQuality();
3417     break;
3418   case 9010:
3419     {
3420       SUIT_OverrideCursor wc;
3421       LightApp_SelectionMgr* mgr = selectionMgr();
3422       SALOME_ListIO selected; mgr->selectedObjects( selected );
3423
3424       SALOME_ListIteratorOfListIO it(selected);
3425       for( ; it.More(); it.Next()) {
3426         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3427         if(anIObject->hasEntry()) {
3428           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3429             anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3430           }
3431         }
3432       }
3433       break;
3434     }
3435   case 9011:
3436     {
3437       SUIT_OverrideCursor wc;
3438       LightApp_SelectionMgr* mgr = selectionMgr();
3439       SALOME_ListIO selected; mgr->selectedObjects( selected );
3440
3441       SALOME_ListIteratorOfListIO it(selected);
3442       for( ; it.More(); it.Next()) {
3443         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3444         if(anIObject->hasEntry())
3445           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3446             anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3447           }
3448       }
3449       break;
3450     }
3451   case 501:
3452   case 502:
3453     {
3454       int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3455       EmitSignalDeactivateDialog();
3456       SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3457       dlg->show();
3458       break;
3459     }
3460   }
3461
3462   anApp->updateActions(); //SRN: To update a Save button in the toolbar
3463   //updateObjBrowser();
3464   return true;
3465 }
3466
3467 //=============================================================================
3468 /*!
3469  *
3470  */
3471 //=============================================================================
3472 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3473 {
3474   return false;
3475 }
3476
3477 //=============================================================================
3478 /*!
3479  *
3480  */
3481 //=============================================================================
3482 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3483 {
3484   return true;
3485 }
3486
3487 //=============================================================================
3488 /*!
3489  *
3490  */
3491 //=============================================================================
3492 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3493 {
3494   return true;
3495 }
3496
3497 //=============================================================================
3498 /*! Method:  BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3499  *  Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3500  */
3501 //=============================================================================
3502 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3503                                   SUIT_ViewWindow* wnd )
3504 {
3505   if(theIO->hasEntry()){
3506     //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3507     SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3508   }
3509 }
3510
3511 //=======================================================================
3512 // function : createSMESHAction
3513 // purpose  :
3514 //=======================================================================
3515 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3516                                   const int key, const bool toggle, const QString& shortcutAction  )
3517 {
3518   QIcon icon;
3519   QWidget* parent = application()->desktop();
3520   SUIT_ResourceMgr* resMgr = resourceMgr();
3521   QPixmap pix;
3522   if ( !icon_id.isEmpty() )
3523     pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3524   else
3525     pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3526   if ( !pix.isNull() )
3527     icon = QIcon( pix );
3528
3529   QString tooltip    = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3530           menu       = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3531           status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3532
3533   createAction( id, tooltip, icon, menu, status_bar, key, parent,
3534                 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3535 }
3536
3537 //=======================================================================
3538 // function : createPopupItem
3539 // purpose  :
3540 //=======================================================================
3541 void SMESHGUI::createPopupItem( const int id,
3542                                 const QString& clients,
3543                                 const QString& types,
3544                                 const QString& theRule,
3545                                 const int pId )
3546 {
3547   if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3548     popupMgr()->insert( action( id ), pId, 0 );
3549
3550   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
3551   QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3552   QString rule = "(%1) and (%2) and (%3)";
3553   rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3554   if( clients.isEmpty() )
3555     rule = rule.arg( QString( "true" ) );
3556   else
3557     rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3558   rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3559   rule += theRule;
3560
3561   bool cont = myRules.contains( id );
3562   if( cont )
3563     rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3564
3565   popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3566   myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3567 }
3568
3569 //=======================================================================
3570 // function : initialize
3571 // purpose  :
3572 //=======================================================================
3573 void SMESHGUI::initialize( CAM_Application* app )
3574 {
3575   SalomeApp_Module::initialize( app );
3576
3577 //   SUIT_ResourceMgr* mgr = app->resourceMgr();
3578 //   if ( mgr )
3579   /* Automatic Update flag */
3580 //     myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3581
3582   // ----- create actions --------------
3583
3584   //createSMESHAction(  111, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3585   createSMESHAction(  112, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3586   createSMESHAction(  113, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3587   createSMESHAction(  114, "NUM" );
3588   createSMESHAction(  115, "IMPORT_STL"  );
3589   createSMESHAction(  116, "IMPORT_CGNS" );
3590   createSMESHAction(  117, "IMPORT_SAUV" );
3591   createSMESHAction(  118, "IMPORT_GMF"  );
3592   createSMESHAction(  121, "DAT" );
3593   createSMESHAction(  122, "MED" );
3594   createSMESHAction(  123, "UNV" );
3595   createSMESHAction(  140, "STL" );
3596   createSMESHAction(  142, "CGNS");
3597   createSMESHAction(  144, "SAUV");
3598   createSMESHAction(  146, "GMF" );
3599   createSMESHAction(  124, "DAT" );
3600   createSMESHAction(  125, "MED" );
3601   createSMESHAction(  126, "UNV" );
3602   createSMESHAction(  141, "STL" );
3603   createSMESHAction(  143, "CGNS");
3604   createSMESHAction(  145, "SAUV");
3605   createSMESHAction(  147, "GMF" );
3606   createSMESHAction(  150, "FILE_INFO" );
3607   createSMESHAction(   33, "DELETE",          "ICON_DELETE", Qt::Key_Delete );
3608   createSMESHAction( 5105, "SEL_FILTER_LIB" );
3609   createSMESHAction(  701, "COMPUTE",         "ICON_COMPUTE" );
3610   createSMESHAction(  702, "CREATE_MESH",     "ICON_DLG_INIT_MESH" );
3611   createSMESHAction(  703, "CREATE_SUBMESH",  "ICON_DLG_ADD_SUBMESH" );
3612   createSMESHAction(  704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3613   createSMESHAction(  705, "COPY_MESH",       "ICON_COPY_MESH" );
3614   createSMESHAction(  710, "BUILD_COMPOUND",  "ICON_BUILD_COMPOUND" );
3615   createSMESHAction(  711, "PRECOMPUTE",      "ICON_PRECOMPUTE" );
3616   createSMESHAction(  712, "EVALUATE",        "ICON_COMPUTE" );
3617   createSMESHAction(  713, "MESH_ORDER",      "ICON_COMPUTE" );
3618   createSMESHAction(  806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3619   createSMESHAction(  801, "CREATE_GROUP",    "ICON_CREATE_GROUP" );
3620   createSMESHAction(  802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3621   createSMESHAction(  803, "EDIT_GROUP",      "ICON_EDIT_GROUP" );
3622   createSMESHAction(  815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3623   createSMESHAction(  804, "ADD" );
3624   createSMESHAction(  805, "REMOVE" );
3625   createSMESHAction(  810, "UN_GROUP",        "ICON_UNION" );
3626   createSMESHAction(  811, "INT_GROUP",       "ICON_INTERSECT" );
3627   createSMESHAction(  812, "CUT_GROUP",       "ICON_CUT" );
3628   createSMESHAction(  814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3629   createSMESHAction(  813, "DEL_GROUP",       "ICON_DEL_GROUP" );
3630   createSMESHAction(  900, "ADV_INFO",        "ICON_ADV_INFO" );
3631   //createSMESHAction(  902, "STD_INFO",        "ICON_STD_INFO" );
3632   //createSMESHAction(  903, "WHAT_IS",         "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3633   createSMESHAction(  904, "FIND_ELEM",       "ICON_FIND_ELEM" );
3634   createSMESHAction( 6001, "LENGTH",          "ICON_LENGTH",        0, true );
3635   createSMESHAction( 6002, "FREE_EDGE",       "ICON_FREE_EDGE",     0, true );
3636   createSMESHAction( 6021, "FREE_FACES",      "ICON_FREE_FACES",    0, true );
3637   createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D",  "ICON_MAX_ELEMENT_LENGTH_2D",   0, true );
3638   createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D",  "ICON_MAX_ELEMENT_LENGTH_3D",   0, true );
3639   createSMESHAction( 6024, "BARE_BORDER_VOLUME",     "ICON_BARE_BORDER_VOLUME",      0, true );
3640   createSMESHAction( 6025, "BARE_BORDER_FACE",       "ICON_BARE_BORDER_FACE",        0, true );
3641   createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3642   createSMESHAction( 6027, "OVER_CONSTRAINED_FACE",  "ICON_OVER_CONSTRAINED_FACE",   0, true );
3643   createSMESHAction( 6028, "EQUAL_NODE",      "ICON_EQUAL_NODE",    0, true );
3644   createSMESHAction( 6029, "EQUAL_EDGE",      "ICON_EQUAL_EDGE",    0, true );
3645   createSMESHAction( 6030, "EQUAL_FACE",      "ICON_EQUAL_FACE",    0, true );
3646   createSMESHAction( 6031, "EQUAL_VOLUME",    "ICON_EQUAL_VOLUME",  0, true );
3647   createSMESHAction( 6032, "OVERALL_MESH_QUALITY" );
3648   createSMESHAction( 6003, "FREE_BORDER",     "ICON_FREE_EDGE_2D",  0, true );
3649   createSMESHAction( 6004, "CONNECTION",      "ICON_CONNECTION",    0, true );
3650   createSMESHAction( 6005, "FREE_NODE",       "ICON_FREE_NODE",     0, true );
3651   createSMESHAction( 6011, "AREA",            "ICON_AREA",          0, true );
3652   createSMESHAction( 6012, "TAPER",           "ICON_TAPER",         0, true );
3653   createSMESHAction( 6013, "ASPECT",          "ICON_ASPECT",        0, true );
3654   createSMESHAction( 6014, "MIN_ANG",         "ICON_ANGLE",         0, true );
3655   createSMESHAction( 6015, "WARP",            "ICON_WARP",          0, true );
3656   createSMESHAction( 6016, "SKEW",            "ICON_SKEW",          0, true );
3657   createSMESHAction( 6017, "ASPECT_3D",       "ICON_ASPECT_3D",     0, true );
3658   createSMESHAction( 6018, "LENGTH_2D",       "ICON_LENGTH_2D",     0, true );
3659   createSMESHAction( 6019, "CONNECTION_2D",   "ICON_CONNECTION_2D", 0, true );
3660   createSMESHAction( 6009, "VOLUME_3D",       "ICON_VOLUME_3D",     0, true );
3661   createSMESHAction( 4000, "NODE",            "ICON_DLG_NODE" );
3662   createSMESHAction( 4009, "ELEM0D",          "ICON_DLG_ELEM0D" );
3663   createSMESHAction( 4008, "BALL",            "ICON_DLG_BALL" );
3664   createSMESHAction( 4010, "EDGE",            "ICON_DLG_EDGE" );
3665   createSMESHAction( 4021, "TRIANGLE",        "ICON_DLG_TRIANGLE" );
3666   createSMESHAction( 4022, "QUAD",            "ICON_DLG_QUADRANGLE" );
3667   createSMESHAction( 4023, "POLYGON",         "ICON_DLG_POLYGON" );
3668   createSMESHAction( 4031, "TETRA",           "ICON_DLG_TETRAS" );
3669   createSMESHAction( 4032, "HEXA",            "ICON_DLG_HEXAS" );
3670   createSMESHAction( 4133, "PENTA",           "ICON_DLG_PENTA" );
3671   createSMESHAction( 4134, "PYRAMID",         "ICON_DLG_PYRAMID" );
3672   createSMESHAction( 4135, "OCTA",            "ICON_DLG_OCTA" );
3673   createSMESHAction( 4033, "POLYHEDRON",              "ICON_DLG_POLYHEDRON" );
3674   createSMESHAction( 4034, "QUADRATIC_EDGE",          "ICON_DLG_QUADRATIC_EDGE" );
3675   createSMESHAction( 4035, "QUADRATIC_TRIANGLE",      "ICON_DLG_QUADRATIC_TRIANGLE" );
3676   createSMESHAction( 4036, "QUADRATIC_QUADRANGLE",    "ICON_DLG_QUADRATIC_QUADRANGLE" );
3677   createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE",  "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3678   createSMESHAction( 4137, "BIQUADRATIC_TRIANGLE",    "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3679   createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON",   "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3680   createSMESHAction( 4038, "QUADRATIC_PYRAMID",       "ICON_DLG_QUADRATIC_PYRAMID" );
3681   createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON",   "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3682   createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON",    "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3683   createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3684   createSMESHAction( 4041, "REMOVE_NODES",          "ICON_DLG_REM_NODE" );
3685   createSMESHAction( 4042, "REMOVE_ELEMENTS",       "ICON_DLG_REM_ELEMENT" );
3686   createSMESHAction( 4044, "REMOVE_ORPHAN_NODES",   "ICON_DLG_REM_ORPHAN_NODES" );
3687   createSMESHAction( 4043, "CLEAR_MESH"    ,  "ICON_CLEAR_MESH" );
3688   createSMESHAction( 4051, "RENUM_NODES",     "ICON_DLG_RENUMBERING_NODES" );
3689   createSMESHAction( 4052, "RENUM_ELEMENTS",  "ICON_DLG_RENUMBERING_ELEMENTS" );
3690   createSMESHAction( 4061, "TRANS",           "ICON_SMESH_TRANSLATION_VECTOR" );
3691   createSMESHAction( 4062, "ROT",             "ICON_DLG_MESH_ROTATION" );
3692   createSMESHAction( 4063, "SYM",             "ICON_SMESH_SYMMETRY_PLANE" );
3693   createSMESHAction( 4064, "SEW",             "ICON_SMESH_SEWING_FREEBORDERS" );
3694   createSMESHAction( 4065, "MERGE",           "ICON_SMESH_MERGE_NODES" );
3695   createSMESHAction( 4066, "MERGE_ELEMENTS",  "ICON_DLG_MERGE_ELEMENTS" );
3696   createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3697   createSMESHAction( 4068, "SCALE",           "ICON_DLG_MESH_SCALE" );
3698   createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3699   createSMESHAction( 4070, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3700   createSMESHAction(  407, "INV",             "ICON_DLG_MESH_DIAGONAL" );
3701   createSMESHAction(  408, "UNION2",          "ICON_UNION2TRI" );
3702   createSMESHAction(  409, "ORIENT",          "ICON_DLG_MESH_ORIENTATION" );
3703   createSMESHAction(  410, "UNION",           "ICON_UNIONTRI" );
3704   createSMESHAction(  411, "CUT",             "ICON_CUTQUAD" );
3705   createSMESHAction(  412, "SMOOTH",          "ICON_DLG_SMOOTHING" );
3706   createSMESHAction(  413, "EXTRUSION",       "ICON_EXTRUSION" );
3707   createSMESHAction(  414, "REVOLUTION",      "ICON_REVOLUTION" );
3708   createSMESHAction(  415, "MAP",             "ICON_MAP" );
3709   createSMESHAction(  416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3710   createSMESHAction(  417, "CONV_TO_QUAD",    "ICON_CONV_TO_QUAD" );
3711   createSMESHAction(  418, "2D_FROM_3D",      "ICON_2D_FROM_3D" );
3712   createSMESHAction(  419, "SPLIT_TO_TETRA",  "ICON_SPLIT_TO_TETRA" );
3713   createSMESHAction(  420, "REORIENT_2D",     "ICON_REORIENT_2D" );
3714   createSMESHAction(  200, "RESET" );
3715   createSMESHAction(  201, "SCALAR_BAR_PROP" );
3716   createSMESHAction(  2021, "SAVE_DISTRIBUTION" );
3717   createSMESHAction(  2022, "SHOW_DISTRIBUTION","",0, true );
3718 #ifndef DISABLE_PLOT2DVIEWER
3719   createSMESHAction(  2023, "PLOT_DISTRIBUTION" );
3720 #endif
3721   createSMESHAction(  211, "WIRE",           "ICON_WIRE", 0, true );
3722   createSMESHAction(  212, "SHADE",          "ICON_SHADE", 0, true );
3723   createSMESHAction(  213, "SHRINK",         "ICON_SHRINK", 0, true );
3724   createSMESHAction(  214, "UPDATE",         "ICON_UPDATE" );
3725   createSMESHAction(  215, "NODES",          "ICON_POINTS", 0, true );
3726   createSMESHAction(  222, "BALLS",          "ICON_DLG_BALL", 0, true );
3727   createSMESHAction(  216, "ELEMS0D",        "ICON_DLG_ELEM0D", 0, true );
3728   createSMESHAction(  217, "EDGES",          "ICON_DLG_EDGE", 0, true );
3729   createSMESHAction(  218, "FACES",          "ICON_DLG_TRIANGLE", 0, true );
3730   createSMESHAction(  219, "VOLUMES",        "ICON_DLG_TETRAS", 0, true );
3731   createSMESHAction(  220, "ALL" );
3732   createSMESHAction(  221, "FACE_ORIENTATION", "", 0, true );
3733
3734   createSMESHAction(  231, "LINE_REPRESENTATION", "", 0, true );
3735   createSMESHAction(  232, "ARC_REPRESENTATION", "", 0, true );
3736
3737   createSMESHAction( 1100, "EDIT_HYPO" );
3738   createSMESHAction( 1102, "UNASSIGN" );
3739   createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3740   createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3741   createSMESHAction( 1131, "DISPMODE" );
3742   createSMESHAction( 1132, "COLORS" );
3743   createSMESHAction( 1133, "TRANSP" );
3744   createSMESHAction( 1134, "CLIP" );
3745   createSMESHAction( 1135, "DISP_ENT" );
3746   createSMESHAction( 1136, "AUTO_COLOR" );
3747   createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3748   createSMESHAction( 2000, "CTRL" );
3749
3750   createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3751   createSMESHAction( 502, "MEASURE_BND_BOX",  "ICON_MEASURE_BND_BOX" );
3752
3753   createSMESHAction( 300, "HIDE" );
3754   createSMESHAction( 301, "SHOW" );
3755   createSMESHAction( 302, "DISPLAY_ONLY" );
3756
3757   // ----- create menu --------------
3758   int fileId    = createMenu( tr( "MEN_FILE" ),    -1,  1 ),
3759       editId    = createMenu( tr( "MEN_EDIT" ),    -1,  3 ),
3760       toolsId   = createMenu( tr( "MEN_TOOLS" ),   -1,  5, 50 ),
3761       meshId    = createMenu( tr( "MEN_MESH" ),    -1, 70, 10 ),
3762       ctrlId    = createMenu( tr( "MEN_CTRL" ),    -1, 60, 10 ),
3763       modifyId  = createMenu( tr( "MEN_MODIFY" ),  -1, 40, 10 ),
3764       measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3765       viewId    = createMenu( tr( "MEN_VIEW" ),    -1,  2 );
3766
3767   createMenu( separator(), fileId );
3768
3769   int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3770       exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3771       nodeId   = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3772       edgeId   = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3773       faceId   = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3774       volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3775       addId    = createMenu( tr( "MEN_ADD" ),    modifyId, 402 ),
3776       removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3777       renumId  = createMenu( tr( "MEN_RENUM" ),  modifyId, 404 ),
3778       transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3779
3780   //createMenu( 111, importId, -1 );
3781   createMenu( 112, importId, -1 );
3782   createMenu( 113, importId, -1 );
3783   createMenu( 115, importId, -1 );
3784 #ifdef WITH_CGNS
3785   createMenu( 116, importId, -1 );
3786 #endif
3787   createMenu( 117, importId, -1 );
3788   createMenu( 118, importId, -1 );
3789   createMenu( 121, exportId, -1 );
3790   createMenu( 122, exportId, -1 );
3791   createMenu( 123, exportId, -1 );
3792   createMenu( 140, exportId, -1 ); // export to STL
3793 #ifdef WITH_CGNS
3794   createMenu( 142, exportId, -1 ); // export to CGNS
3795 #endif
3796   createMenu( 144, exportId, -1 ); // export to SAUV
3797   createMenu( 146, exportId, -1 ); // export to GMF
3798   createMenu( separator(), fileId, 10 );
3799
3800   createMenu( 33, editId, -1 );
3801
3802   createMenu( 5105, toolsId, -1 );
3803
3804   createMenu( 702, meshId, -1 ); // "Mesh" menu
3805   createMenu( 703, meshId, -1 );
3806   createMenu( 704, meshId, -1 );
3807   createMenu( 710, meshId, -1 );
3808   createMenu( 705, meshId, -1 );
3809   createMenu( separator(), meshId, -1 );
3810   createMenu( 701, meshId, -1 );
3811   createMenu( 711, meshId, -1 );
3812   createMenu( 712, meshId, -1 );
3813   createMenu( 713, meshId, -1 );
3814   createMenu( separator(), meshId, -1 );
3815   createMenu( 801, meshId, -1 );
3816   createMenu( 806, meshId, -1 );
3817   createMenu( 802, meshId, -1 );
3818   createMenu( 803, meshId, -1 );
3819   createMenu( 815, meshId, -1 );
3820   createMenu( separator(), meshId, -1 );
3821   createMenu( 810, meshId, -1 );
3822   createMenu( 811, meshId, -1 );
3823   createMenu( 812, meshId, -1 );
3824   createMenu( separator(), meshId, -1 );
3825   createMenu( 814, meshId, -1 );
3826   createMenu( separator(), meshId, -1 );
3827   createMenu( 900, meshId, -1 );
3828   //createMenu( 902, meshId, -1 );
3829   //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3830   createMenu( 904, meshId, -1 );
3831   createMenu( separator(), meshId, -1 );
3832
3833   createMenu( 6005, nodeId, -1 );
3834   createMenu( 6028, nodeId, -1 );
3835   createMenu( 6002, edgeId, -1 );
3836   createMenu( 6003, edgeId, -1 );
3837   createMenu( 6001, edgeId, -1 );
3838   createMenu( 6004, edgeId, -1 );
3839   createMenu( 6029, edgeId, -1 );
3840   createMenu( 6021, faceId, -1 );
3841   createMenu( 6025, faceId, -1 );
3842   createMenu( 6027, faceId, -1 );
3843   createMenu( 6018, faceId, -1 );
3844   createMenu( 6019, faceId, -1 );
3845   createMenu( 6011, faceId, -1 );
3846   createMenu( 6012, faceId, -1 );
3847   createMenu( 6013, faceId, -1 );
3848   createMenu( 6014, faceId, -1 );
3849   createMenu( 6015, faceId, -1 );
3850   createMenu( 6016, faceId, -1 );
3851   createMenu( 6022, faceId, -1 );
3852   createMenu( 6030, faceId, -1 );
3853   createMenu( 6017, volumeId, -1 );
3854   createMenu( 6009, volumeId, -1 );
3855   createMenu( 6023, volumeId, -1 );
3856   createMenu( 6024, volumeId, -1 );
3857   createMenu( 6026, volumeId, -1 );
3858   createMenu( 6031, volumeId, -1 );
3859   createMenu( separator(), ctrlId, -1 );
3860   createMenu( 6032, ctrlId, -1 );
3861
3862   createMenu( 4000, addId, -1 );
3863   createMenu( 4009, addId, -1 );
3864   createMenu( 4070, addId, -1 );
3865   createMenu( 4008, addId, -1 );
3866   createMenu( 4010, addId, -1 );
3867   createMenu( 4021, addId, -1 );
3868   createMenu( 4022, addId, -1 );
3869   createMenu( 4023, addId, -1 );
3870   createMenu( 4031, addId, -1 );
3871   createMenu( 4032, addId, -1 );
3872   createMenu( 4133, addId, -1 );
3873   createMenu( 4134, addId, -1 );
3874   createMenu( 4135, addId, -1 );
3875   createMenu( 4033, addId, -1 );
3876   createMenu( separator(), addId, -1 );
3877   createMenu( 4034, addId, -1 );
3878   createMenu( 4035, addId, -1 );
3879   createMenu( 4137, addId, -1 );
3880   createMenu( 4036, addId, -1 );
3881   createMenu( 4136, addId, -1 );
3882   createMenu( 4037, addId, -1 );
3883   createMenu( 4038, addId, -1 );
3884   createMenu( 4039, addId, -1 );
3885   createMenu( 4040, addId, -1 );
3886   createMenu( 4140, addId, -1 );
3887
3888   createMenu( 4041, removeId, -1 );
3889   createMenu( 4042, removeId, -1 );
3890   createMenu( 4044, removeId, -1 );
3891   createMenu( separator(), removeId, -1 );
3892   createMenu( 813, removeId, -1 );
3893   createMenu( separator(), removeId, -1 );
3894   createMenu( 4043, removeId, -1 );
3895
3896   createMenu( 4051, renumId, -1 );
3897   createMenu( 4052, renumId, -1 );
3898
3899   createMenu( 4061, transfId, -1 );
3900   createMenu( 4062, transfId, -1 );
3901   createMenu( 4063, transfId, -1 );
3902   createMenu( 4068, transfId, -1 );
3903   createMenu( 4064, transfId, -1 );
3904   createMenu( 4065, transfId, -1 );
3905   createMenu( 4066, transfId, -1 );
3906   createMenu( 4069, transfId, -1 );
3907
3908   createMenu( 4067,modifyId, -1 );
3909   createMenu( 407, modifyId, -1 );
3910   createMenu( 408, modifyId, -1 );
3911   createMenu( 409, modifyId, -1 );
3912   createMenu( 420, modifyId, -1 );
3913   createMenu( 410, modifyId, -1 );
3914   createMenu( 411, modifyId, -1 );
3915   createMenu( 419, modifyId, -1 );
3916   createMenu( 412, modifyId, -1 );
3917   createMenu( 413, modifyId, -1 );
3918   createMenu( 416, modifyId, -1 );
3919   createMenu( 414, modifyId, -1 );
3920   createMenu( 415, modifyId, -1 );
3921   createMenu( 417, modifyId, -1 );
3922   createMenu( 418, modifyId, -1 );
3923
3924   createMenu( 501, measureId, -1 );
3925   createMenu( 502, measureId, -1 );
3926   createMenu( 214, viewId, -1 );
3927
3928   // ----- create toolbars --------------
3929   int meshTb     = createTool( tr( "TB_MESH" ) ),
3930       ctrlTb     = createTool( tr( "TB_CTRL" ) ),
3931       addRemTb   = createTool( tr( "TB_ADD_REMOVE" ) ),
3932       modifyTb   = createTool( tr( "TB_MODIFY" ) ),
3933       dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
3934
3935   createTool( 702, meshTb );
3936   createTool( 703, meshTb );
3937   createTool( 704, meshTb );
3938   createTool( 710, meshTb );
3939   createTool( 705, meshTb );
3940   createTool( separator(), meshTb );
3941   createTool( 701, meshTb );
3942   createTool( 711, meshTb );
3943   createTool( 712, meshTb );
3944   createTool( 713, meshTb );
3945   createTool( separator(), meshTb );
3946   createTool( 801, meshTb );
3947   createTool( 806, meshTb );
3948   createTool( 802, meshTb );
3949   createTool( 803, meshTb );
3950   //createTool( 815, meshTb );
3951   createTool( separator(), meshTb );
3952   createTool( 900, meshTb );
3953   //createTool( 902, meshTb );
3954   //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3955   createTool( 904, meshTb );
3956   createTool( separator(), meshTb );
3957
3958   createTool( 6005, ctrlTb );
3959   createTool( 6028, ctrlTb );
3960   createTool( separator(), ctrlTb );
3961   createTool( 6002, ctrlTb );
3962   createTool( 6003, ctrlTb );
3963   createTool( 6001, ctrlTb );
3964   createTool( 6004, ctrlTb );
3965   createTool( 6029, ctrlTb );
3966   createTool( separator(), ctrlTb );
3967   createTool( 6021, ctrlTb );
3968   createTool( 6025, ctrlTb );
3969   createTool( 6027, ctrlTb );
3970   createTool( 6018, ctrlTb );
3971   createTool( 6019, ctrlTb );
3972   createTool( 6011, ctrlTb );
3973   createTool( 6012, ctrlTb );
3974   createTool( 6013, ctrlTb );
3975   createTool( 6014, ctrlTb );
3976   createTool( 6015, ctrlTb );
3977   createTool( 6016, ctrlTb );
3978   createTool( 6022, ctrlTb );
3979   createTool( 6030, ctrlTb );
3980   createTool( separator(), ctrlTb );
3981   createTool( 6017, ctrlTb );
3982   createTool( 6009, ctrlTb );
3983   createTool( 6023, ctrlTb );
3984   createTool( 6024, ctrlTb );
3985   createTool( 6026, ctrlTb );
3986   createTool( 6031, ctrlTb );
3987   createTool( separator(), ctrlTb );
3988
3989   createTool( 4000, addRemTb );
3990   createTool( 4009, addRemTb );
3991   createTool( 4070, addRemTb );
3992   createTool( 4008, addRemTb );
3993   createTool( 4010, addRemTb );
3994   createTool( 4021, addRemTb );
3995   createTool( 4022, addRemTb );
3996   createTool( 4023, addRemTb );
3997   createTool( 4031, addRemTb );
3998   createTool( 4032, addRemTb );
3999   createTool( 4133, addRemTb );
4000   createTool( 4134, addRemTb );
4001   createTool( 4135, addRemTb );
4002   createTool( 4033, addRemTb );
4003   createTool( separator(), addRemTb );
4004   createTool( 4034, addRemTb );
4005   createTool( 4035, addRemTb );
4006   createTool( 4137, addRemTb );
4007   createTool( 4036, addRemTb );
4008   createTool( 4136, addRemTb );
4009   createTool( 4037, addRemTb );
4010   createTool( 4038, addRemTb );
4011   createTool( 4039, addRemTb );
4012   createTool( 4040, addRemTb );
4013   createTool( 4140, addRemTb );
4014   createTool( separator(), addRemTb );
4015   createTool( 4041, addRemTb );
4016   createTool( 4042, addRemTb );
4017   createTool( 4044, addRemTb );
4018   createTool( 4043, addRemTb );
4019   createTool( separator(), addRemTb );
4020   createTool( 4051, addRemTb );
4021   createTool( 4052, addRemTb );
4022   createTool( separator(), addRemTb );
4023   createTool( 4061, addRemTb );
4024   createTool( 4062, addRemTb );
4025   createTool( 4063, addRemTb );
4026   createTool( 4068, addRemTb );
4027   createTool( 4064, addRemTb );
4028   createTool( 4065, addRemTb );
4029   createTool( 4066, addRemTb );
4030   createTool( 4069, addRemTb );
4031   createTool( separator(), addRemTb );
4032
4033   createTool( 4067,modifyTb );
4034   createTool( 407, modifyTb );
4035   createTool( 408, modifyTb );
4036   createTool( 409, modifyTb );
4037   createTool( 420, modifyTb );
4038   createTool( 410, modifyTb );
4039   createTool( 411, modifyTb );
4040   createTool( 419, modifyTb );
4041   createTool( 412, modifyTb );
4042   createTool( 413, modifyTb );
4043   createTool( 416, modifyTb );
4044   createTool( 414, modifyTb );
4045   createTool( 415, modifyTb );
4046   createTool( 417, modifyTb );
4047   createTool( 418, modifyTb );
4048
4049   createTool( 214, dispModeTb );
4050
4051   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
4052   QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4053
4054   myRules.clear();
4055   QString OB = "'ObjectBrowser'",
4056           View = "'" + SVTK_Viewer::Type() + "'",
4057           pat = "'%1'",
4058           mesh    = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4059           group   = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4060           hypo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4061           algo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4062           elems   = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4063                        arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4064                        arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4065                        arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4066                        arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4067                        arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4068                        arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4069           subMesh = elems,
4070           mesh_part = mesh + " " + subMesh + " " + group,
4071           mesh_group = mesh + " " + group,
4072           hyp_alg = hypo + " " + algo;
4073
4074   // popup for object browser
4075   QString
4076     isInvisible("not( isVisible )"),
4077     isEmpty("numberOfNodes = 0"),
4078     isNotEmpty("numberOfNodes <> 0"),
4079
4080     // has nodes, edges, etc in VISIBLE! actor
4081     hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4082     hasElems("(count( elemTypes ) > 0)"),
4083     hasDifferentElems("(count( elemTypes ) > 1)"),
4084     hasBalls("({'BallElem'} in elemTypes)"),
4085     hasElems0d("({'Elem0d'} in elemTypes)"),
4086     hasEdges("({'Edge'} in elemTypes)"),
4087     hasFaces("({'Face'} in elemTypes)"),
4088     hasVolumes("({'Volume'} in elemTypes)");
4089
4090   createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" );      // FILE INFORMATION
4091   createPopupItem( 703, OB, mesh, "&& isComputable");      // CREATE_SUBMESH
4092   createPopupItem( 704, OB, mesh, "&& isComputable");      // EDIT_MESHSUBMESH
4093   createPopupItem( 704, OB, subMesh, "&& isComputable" );  // EDIT_MESHSUBMESH
4094   createPopupItem( 803, OB, group );                       // EDIT_GROUP
4095   createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
4096
4097   popupMgr()->insert( separator(), -1, 0 );
4098   createPopupItem( 701, OB, mesh, "&& isComputable" );     // COMPUTE
4099   createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
4100   createPopupItem( 712, OB, mesh, "&& isComputable" );     // EVALUATE
4101   createPopupItem( 713, OB, mesh, "&& isComputable" );     // MESH ORDER
4102   createPopupItem( 214, OB, mesh_part );                   // UPDATE
4103   createPopupItem( 900, OB, mesh_part );                   // ADV_INFO
4104   createPopupItem( 904, OB, mesh_group );                  // FIND_ELEM
4105   createPopupItem( 6032, OB, mesh_part );                  // CTRL_INFO
4106   popupMgr()->insert( separator(), -1, 0 );
4107   createPopupItem( 801, OB, mesh );                        // CREATE_GROUP
4108   createPopupItem( 806, OB, mesh );                        // CREATE_GEO_GROUP
4109   createPopupItem( 802, OB, subMesh );                     // CONSTRUCT_GROUP
4110   popupMgr()->insert( separator(), -1, 0 );
4111   createPopupItem( 1100, OB, hypo);                        // EDIT HYPOTHESIS
4112   createPopupItem( 1102, OB, hyp_alg );                    // REMOVE HYPOTHESIS / ALGORITHMS
4113   popupMgr()->insert( separator(), -1, 0 );
4114   createPopupItem( 4043, OB, mesh );                       // CLEAR_MESH
4115   popupMgr()->insert( separator(), -1, 0 );
4116   createPopupItem( 417, OB, mesh + " " + subMesh );        // convert to quadratic
4117   createPopupItem( 418, OB, mesh + " " + group,            // create 2D mesh from 3D
4118                    "&& dim>=2");
4119   popupMgr()->insert( separator(), -1, 0 );
4120
4121   QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4122   QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4123   QString only_one_2D        = only_one_non_empty + " && dim>1";
4124
4125   int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 );        // EXPORT submenu
4126   createPopupItem( 125, OB, mesh_group, multiple_non_empty, anId );   // EXPORT_MED
4127   createPopupItem( 126, OB, mesh_group, only_one_non_empty, anId );   // EXPORT_UNV
4128   createPopupItem( 141, OB, mesh_group, only_one_2D, anId );          // EXPORT_STL
4129 #ifdef WITH_CGNS
4130   createPopupItem( 143, OB, mesh_group, multiple_non_empty, anId );   // EXPORT_CGNS
4131 #endif
4132   createPopupItem( 145, OB, mesh_group, multiple_non_empty, anId );   // EXPORT_SAUV
4133   createPopupItem( 147, OB, mesh_group, multiple_non_empty, anId );   // EXPORT_GMF
4134   createPopupItem( 124, OB, mesh_group, multiple_non_empty, anId );   // EXPORT_DAT
4135   createPopupItem(  33, OB, mesh_part + " " + hyp_alg );        // DELETE
4136   createPopupItem( 813, OB, group );                            // DEL_GROUP with contents
4137   popupMgr()->insert( separator(), -1, 0 );
4138
4139   // popup for viewer
4140   createPopupItem( 803, View, group ); // EDIT_GROUP
4141   createPopupItem( 804, View, elems ); // ADD
4142   createPopupItem( 805, View, elems ); // REMOVE
4143
4144   popupMgr()->insert( separator(), -1, 0 );
4145   createPopupItem( 214, View, mesh_part );  // UPDATE
4146   createPopupItem( 900, View, mesh_part );  // ADV_INFO
4147   createPopupItem( 904, View, mesh );       // FIND_ELEM
4148   popupMgr()->insert( separator(), -1, 0 );
4149
4150   createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
4151   createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" );       // DISABLE_AUTO_COLOR
4152   popupMgr()->insert( separator(), -1, 0 );
4153
4154   QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4155   QString aType = QString( "%1type in {%2}" ).arg( lc );
4156   aType = aType.arg( mesh_part );
4157   QString aMeshInVTK = aClient + "&&" + aType;
4158
4159   aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4160   QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4161   QString aSelCount = QString( "%1 > 0" ).arg( dc );
4162
4163   //-------------------------------------------------
4164   // Numbering
4165   //-------------------------------------------------
4166   anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4167
4168   popupMgr()->insert( action( 9010 ), anId, -1 );
4169   popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4170   popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4171
4172   popupMgr()->insert( action( 9011 ), anId, -1 );
4173   popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4174   popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4175
4176   popupMgr()->insert( separator(), -1, -1 );
4177
4178   //-------------------------------------------------
4179   // Display Mode
4180   //-------------------------------------------------
4181   anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4182
4183   popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4184   popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4185   popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4186
4187   popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4188   popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4189   popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4190
4191   popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4192   popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4193   popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4194
4195   popupMgr()->insert( separator(), anId, -1 );
4196
4197   popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4198   popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4199   popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4200
4201   //-------------------------------------------------
4202   // Display Entity
4203   //-------------------------------------------------
4204   QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4205
4206   anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4207
4208   popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4209   popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4210   popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4211
4212   popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4213   popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4214   popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4215
4216   popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4217   popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4218   popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4219
4220   popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4221   popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4222   popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4223
4224   popupMgr()->insert( action( 222 ), anId, -1 ); // BALLS
4225   popupMgr()->setRule( action( 222 ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4226   popupMgr()->setRule( action( 222 ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4227
4228   popupMgr()->insert( separator(), anId, -1 );
4229
4230   popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4231   popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4232
4233
4234   //-------------------------------------------------
4235   // Representation of the 2D Quadratic elements
4236   //-------------------------------------------------
4237   anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4238   popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4239   popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4240   popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4241
4242   popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4243   popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4244   popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4245
4246   //-------------------------------------------------
4247   // Orientation of faces
4248   //-------------------------------------------------
4249   popupMgr()->insert( action( 221 ), -1, -1 );
4250   popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4251   popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4252
4253   //-------------------------------------------------
4254   // Color / Size
4255   //-------------------------------------------------
4256   popupMgr()->insert( action( 1132 ), -1, -1 );
4257   popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4258
4259   //-------------------------------------------------
4260   // Transparency
4261   //-------------------------------------------------
4262   popupMgr()->insert( action( 1133 ), -1, -1 );
4263   popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4264
4265   //-------------------------------------------------
4266   // Controls
4267   //-------------------------------------------------
4268   QString
4269     aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4270     aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4271     aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4272     aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4273
4274   anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4275
4276   popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4277   popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4278
4279   popupMgr()->insert( separator(), anId, -1 );
4280
4281   int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4282
4283   popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4284   popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4285   popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4286
4287   popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4288   popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4289   popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4290
4291   aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4292
4293   popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4294   popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4295   popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4296
4297   popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4298   popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4299   popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4300
4301   popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4302   popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4303   popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4304
4305   popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4306   popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4307   popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4308   popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4309   popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4310   popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4311
4312   aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4313
4314   popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4315   popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4316                                        QtxPopupMgr::VisibleRule );
4317   popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4318
4319   popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4320   popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4321   popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4322
4323   popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4324   popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4325   popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4326
4327   popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4328   popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4329   popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4330
4331   popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4332   popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4333   popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4334
4335   popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4336   popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4337   popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4338
4339   popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4340   popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4341   popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4342
4343   popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4344   popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4345   popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4346
4347   popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4348   popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4349   popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4350
4351   popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4352   popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4353   popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4354
4355   popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4356   popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4357   popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4358
4359   popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4360   popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4361   popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4362   popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4363   popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4364   popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4365
4366   aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4367
4368   popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4369   popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4370   popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4371
4372   popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4373   popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4374   popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4375
4376   popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4377   popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4378   popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4379
4380   popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4381   popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4382   popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4383
4384   popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4385   popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4386   popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4387
4388   popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4389   popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4390   popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4391
4392   popupMgr()->insert( separator(), anId, -1 );
4393
4394   popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4395   popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4396
4397   popupMgr()->insert( separator(), anId, -1 );
4398
4399   aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4400
4401   popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4402   popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4403
4404   popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4405   popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4406   popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4407
4408 #ifndef DISABLE_PLOT2DVIEWER
4409   popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4410   popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4411 #endif
4412
4413   //-------------------------------------------------
4414   // Display / Erase
4415   //-------------------------------------------------
4416   popupMgr()->insert( separator(), -1, -1 );
4417   QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4418     aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4419   popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4420   popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4421
4422   popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4423   popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4424
4425   popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4426   popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4427
4428   popupMgr()->insert( separator(), -1, -1 );
4429
4430   //-------------------------------------------------
4431   // Clipping
4432   //-------------------------------------------------
4433   popupMgr()->insert( action( 1134 ), -1, -1 );
4434   popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4435
4436   popupMgr()->insert( separator(), -1, -1 );
4437
4438   connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4439            this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4440
4441   connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4442            this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4443 }
4444
4445 //================================================================================
4446 /*!
4447  * \brief Return true if SMESH or GEOM objects are selected.
4448  * Is called form LightApp_Module::activateModule() which clear selection if
4449  * not isSelectionCompatible()
4450  */
4451 //================================================================================
4452
4453 bool SMESHGUI::isSelectionCompatible()
4454 {
4455   bool isCompatible = true;
4456   SALOME_ListIO selected;
4457   if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4458     Sel->selectedObjects( selected );
4459
4460   SALOME_ListIteratorOfListIO It( selected );
4461   for ( ; isCompatible && It.More(); It.Next())
4462     isCompatible =
4463       ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4464       ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4465
4466   return isCompatible;
4467 }
4468
4469
4470 bool SMESHGUI::reusableOperation( const int id )
4471 {
4472   // compute, evaluate and precompute are not reusable operations
4473   return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4474 }
4475
4476 bool SMESHGUI::activateModule( SUIT_Study* study )
4477 {
4478   bool res = SalomeApp_Module::activateModule( study );
4479
4480   setMenuShown( true );
4481   setToolShown( true );
4482
4483   // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4484   PyGILState_STATE gstate = PyGILState_Ensure();
4485   PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4486   if(pluginsmanager==NULL)
4487     PyErr_Print();
4488   else
4489     {
4490       PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4491       if(result==NULL)
4492         PyErr_Print();
4493       Py_XDECREF(result);
4494     }
4495   PyGILState_Release(gstate);
4496   // end of GEOM plugins loading
4497
4498   // Reset actions accelerator keys
4499   //action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4500   action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4501   action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4502
4503   action(  33)->setEnabled(true); // Delete: Key_Delete
4504
4505   //  0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4506   GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4507   if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4508     if ( _PTR(Study) aStudy = s->studyDS()) {
4509       GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4510       updateObjBrowser(); // objects can be removed
4511     }
4512
4513   // get all view currently opened in the study and connect their signals  to
4514   // the corresponding slots of the class.
4515   SUIT_Desktop* aDesk = study->application()->desktop();
4516   if ( aDesk ) {
4517     QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4518     SUIT_ViewWindow* wnd;
4519     foreach ( wnd, wndList )
4520       connectView( wnd );
4521   }
4522
4523   return res;
4524 }
4525
4526 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4527 {
4528   setMenuShown( false );
4529   setToolShown( false );
4530
4531   EmitSignalCloseAllDialogs();
4532
4533   // Unset actions accelerator keys
4534   //action(111)->setShortcut(QKeySequence()); // Import DAT
4535   action(112)->setShortcut(QKeySequence()); // Import UNV
4536   action(113)->setShortcut(QKeySequence()); // Import MED
4537
4538   action(  33)->setEnabled(false); // Delete: Key_Delete
4539
4540   return SalomeApp_Module::deactivateModule( study );
4541 }
4542
4543 void SMESHGUI::studyClosed( SUIT_Study* s )
4544 {
4545   SMESH::RemoveVisuData( s->id() );
4546   SalomeApp_Module::studyClosed( s );
4547 }
4548
4549 void SMESHGUI::OnGUIEvent()
4550 {
4551   const QObject* obj = sender();
4552   if ( !obj || !obj->inherits( "QAction" ) )
4553     return;
4554   int id = actionId((QAction*)obj);
4555   if ( id != -1 )
4556     OnGUIEvent( id );
4557 }
4558
4559 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4560 {
4561   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4562   if ( CORBA::is_nil( myComponentSMESH ) )
4563     {
4564       SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4565       if ( aStudy )
4566         aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4567       return aGUI.myComponentSMESH;
4568     }
4569   if ( aStudy )
4570     myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4571   return myComponentSMESH;
4572 }
4573
4574 QString SMESHGUI::engineIOR() const
4575 {
4576   CORBA::ORB_var anORB = getApp()->orb();
4577   CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4578   return QString( anIOR.in() );
4579 }
4580
4581 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4582 {
4583   SalomeApp_Module::contextMenuPopup( client, menu, title );
4584   SALOME_ListIO lst;
4585   selectionMgr()->selectedObjects( lst );
4586   if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4587     Handle(SALOME_InteractiveObject) io = lst.First();
4588     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4589     _PTR(Study) study = appStudy->studyDS();
4590     _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4591     if ( obj ) {
4592       QString aName = QString( obj->GetName().c_str() );
4593       while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4594           aName.remove( (aName.length() - 1), 1 );
4595       title = aName;
4596     }
4597   }
4598 }
4599
4600 LightApp_Selection* SMESHGUI::createSelection() const
4601 {
4602   return new SMESHGUI_Selection();
4603 }
4604
4605 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4606 {
4607   aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4608   aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4609 }
4610
4611 void SMESHGUI::viewManagers( QStringList& list ) const
4612 {
4613   list.append( SVTK_Viewer::Type() );
4614 }
4615
4616 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4617 {
4618   if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4619     SMESH::UpdateSelectionProp( this );
4620
4621     QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4622     for(int i = 0; i < aViews.count() ; i++){
4623       SUIT_ViewWindow *sf = aViews[i];
4624       connectView( sf );
4625     }
4626   }
4627 }
4628
4629 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4630 {
4631   if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4632     myClippingPlaneInfoMap.erase( theViewManager );
4633 }
4634
4635 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4636 {
4637   theActor->AddObserver( SMESH::DeleteActorEvent,
4638                          myEventCallbackCommand.GetPointer(),
4639                          myPriority );
4640 }
4641
4642 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4643                               unsigned long theEvent,
4644                               void* theClientData,
4645                               void* theCallData )
4646 {
4647   if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4648     if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4649       if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4650         SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4651         SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4652         for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4653           SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4654           SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4655           for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4656             SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4657             std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4658             SMESH::TActorList::iterator anIter3 = anActorList.begin();
4659             for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4660               if( anActor == *anIter3 ) {
4661                 anActorList.erase( anIter3 );
4662                 break;
4663               }
4664             }
4665           }
4666         }
4667       }
4668     }
4669   }
4670 }
4671
4672 void SMESHGUI::createPreferences()
4673 {
4674   // General tab ------------------------------------------------------------------------
4675   int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4676
4677   int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4678   int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4679   setPreferenceProperty( lim, "min",  0 );
4680   setPreferenceProperty( lim, "max",  100000000 );
4681   setPreferenceProperty( lim, "step", 1000 );
4682   setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4683
4684   int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4685   setPreferenceProperty( qaGroup, "columns", 2 );
4686   addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4687   addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4688   int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4689   setPreferenceProperty( prec, "min", 0 );
4690   setPreferenceProperty( prec, "max", 16 );
4691   int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4692   setPreferenceProperty( doubleNodesTol, "precision", 10 );
4693   setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4694   setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4695   setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4696
4697   int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4698   setPreferenceProperty( dispgroup, "columns", 2 );
4699   int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4700   QStringList modes;
4701   modes.append( tr("MEN_WIRE") );
4702   modes.append( tr("MEN_SHADE") );
4703   modes.append( tr("MEN_NODES") );
4704   modes.append( tr("MEN_SHRINK") );
4705   QList<QVariant> indices;
4706   indices.append( 0 );
4707   indices.append( 1 );
4708   indices.append( 2 );
4709   indices.append( 3 );
4710   setPreferenceProperty( dispmode, "strings", modes );
4711   setPreferenceProperty( dispmode, "indexes", indices );
4712
4713   int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4714   setPreferenceProperty( arcgroup, "columns", 2 );
4715   int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4716   QStringList quadraticModes;
4717   quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4718   quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4719   indices.clear();
4720   indices.append( 0 );
4721   indices.append( 1 );
4722   setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4723   setPreferenceProperty( quadraticmode, "indexes", indices );
4724
4725   int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4726                               "SMESH", "max_angle" );
4727   setPreferenceProperty( maxAngle, "min", 1 );
4728   setPreferenceProperty( maxAngle, "max", 90 );
4729
4730
4731
4732   int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4733   setPreferenceProperty( exportgroup, "columns", 2 );
4734   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4735   //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4736
4737   int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4738   setPreferenceProperty( computeGroup, "columns", 2 );
4739   int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4740   modes.clear();
4741   modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4742   modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4743   modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4744   indices.clear();
4745   indices.append( 0 );
4746   indices.append( 1 );
4747   indices.append( 2 );
4748   setPreferenceProperty( notifyMode, "strings", modes );
4749   setPreferenceProperty( notifyMode, "indexes", indices );
4750
4751   int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4752   setPreferenceProperty( infoGroup, "columns", 2 );
4753   int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4754   modes.clear();
4755   modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4756   modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4757   indices.clear();
4758   indices.append( 0 );
4759   indices.append( 1 );
4760   setPreferenceProperty( elemInfo, "strings", modes );
4761   setPreferenceProperty( elemInfo, "indexes", indices );
4762   int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4763   setPreferenceProperty( nodesLim, "min", 0 );
4764   setPreferenceProperty( nodesLim, "max", 10000000 );
4765   setPreferenceProperty( nodesLim, "step", 10000 );
4766   setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4767   int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
4768   setPreferenceProperty( ctrlLim, "min", 0 );
4769   setPreferenceProperty( ctrlLim, "max", 10000000 );
4770   setPreferenceProperty( ctrlLim, "step", 1000 );
4771   addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
4772   addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
4773   addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
4774   addPreference( tr( "PREF_DUMP_ADD_INFO"  ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
4775   addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
4776
4777   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4778   setPreferenceProperty( segGroup, "columns", 2 );
4779   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4780                               "SMESH", "segmentation" );
4781   setPreferenceProperty( segLen, "min", 1 );
4782   setPreferenceProperty( segLen, "max", 10000000 );
4783   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4784                              "SMESH", "nb_segments_per_edge" );
4785   setPreferenceProperty( nbSeg, "min", 1 );
4786   setPreferenceProperty( nbSeg, "max", 10000000 );
4787
4788   int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4789   addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4790                  "SMESH", "forget_mesh_on_hyp_modif" );
4791
4792
4793   // Quantities with individual precision settings
4794   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4795   setPreferenceProperty( precGroup, "columns", 2 );
4796
4797   const int nbQuantities = 6;
4798   int precs[nbQuantities], ii = 0;
4799   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4800                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4801   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4802                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4803   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4804                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4805   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4806                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4807   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4808                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4809   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4810                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4811
4812   // Set property for precision value for spinboxes
4813   for ( ii = 0; ii < nbQuantities; ii++ ){
4814     setPreferenceProperty( precs[ii], "min", -14 );
4815     setPreferenceProperty( precs[ii], "max", 14 );
4816     setPreferenceProperty( precs[ii], "precision", 2 );
4817   }
4818
4819   int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4820   setPreferenceProperty( previewGroup, "columns", 2 );
4821   int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4822   setPreferenceProperty( chunkSize, "min",  1 );
4823   setPreferenceProperty( chunkSize, "max",  1000 );
4824   setPreferenceProperty( chunkSize, "step", 50 );
4825
4826   int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4827   addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4828
4829   // Mesh tab ------------------------------------------------------------------------
4830   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4831   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4832   setPreferenceProperty( nodeGroup, "columns", 3 );
4833
4834   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4835
4836   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4837
4838   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4839   QList<QVariant> aMarkerTypeIndicesList;
4840   QList<QVariant> aMarkerTypeIconsList;
4841   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4842     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4843     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4844     aMarkerTypeIndicesList << i;
4845     aMarkerTypeIconsList << pixmap;
4846   }
4847   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4848   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
4849
4850   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4851
4852   QList<QVariant> aMarkerScaleIndicesList;
4853   QStringList     aMarkerScaleValuesList;
4854   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4855     aMarkerScaleIndicesList << i;
4856     aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4857   }
4858   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4859   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4860
4861   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4862   //setPreferenceProperty( elemGroup, "columns", 2 );
4863
4864   int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4865   setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4866   ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
4867   setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
4868   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4869   addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
4870   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4871   addPreference( tr( "PREF_WIREFRAME"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4872
4873
4874   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4875   setPreferenceProperty( grpGroup, "columns", 2 );
4876
4877   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4878   addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
4879
4880   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4881                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4882   int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
4883                              LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
4884   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
4885                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
4886   int outW  = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
4887                              LightApp_Preferences::IntSpin, "SMESH", "outline_width");
4888   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4889                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4890
4891   setPreferenceProperty( size0d, "min", 1 );
4892   setPreferenceProperty( size0d, "max", 10 );
4893
4894   setPreferenceProperty( ballSize, "min", 1 );
4895   setPreferenceProperty( ballSize, "max", 10 );
4896
4897   setPreferenceProperty( elemW, "min", 1 );
4898   setPreferenceProperty( elemW, "max", 5 );
4899
4900   setPreferenceProperty( outW, "min", 1 );
4901   setPreferenceProperty( outW, "max", 5 );
4902
4903   setPreferenceProperty( shrink, "min", 0 );
4904   setPreferenceProperty( shrink, "max", 100 );
4905
4906   int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
4907   setPreferenceProperty( numGroup, "columns", 2 );
4908
4909   addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
4910   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
4911
4912   addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
4913   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
4914
4915   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4916   setPreferenceProperty( orientGroup, "columns", 1 );
4917
4918   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4919   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4920
4921   setPreferenceProperty( orientScale, "min", 0.05 );
4922   setPreferenceProperty( orientScale, "max", 0.5 );
4923   setPreferenceProperty( orientScale, "step", 0.05 );
4924
4925   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4926
4927   // Selection tab ------------------------------------------------------------------------
4928   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4929
4930   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4931   setPreferenceProperty( selGroup, "columns", 2 );
4932
4933   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4934   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4935
4936   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4937   setPreferenceProperty( preGroup, "columns", 2 );
4938
4939   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4940
4941   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4942   setPreferenceProperty( precSelGroup, "columns", 2 );
4943
4944   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4945   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4946   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4947
4948   // Scalar Bar tab ------------------------------------------------------------------------
4949   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4950   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4951   setPreferenceProperty( fontGr, "columns", 2 );
4952
4953   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4954   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4955
4956   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4957   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4958
4959   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4960   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4961
4962   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4963   setPreferenceProperty( numcol, "min", 2 );
4964   setPreferenceProperty( numcol, "max", 256 );
4965
4966   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4967   setPreferenceProperty( numlab, "min", 2 );
4968   setPreferenceProperty( numlab, "max", 65 );
4969
4970   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4971   setPreferenceProperty( orientGr, "columns", 2 );
4972   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4973   QStringList orients;
4974   orients.append( tr( "SMESH_VERTICAL" ) );
4975   orients.append( tr( "SMESH_HORIZONTAL" ) );
4976   indices.clear(); indices.append( 0 ); indices.append( 1 );
4977   setPreferenceProperty( orient, "strings", orients );
4978   setPreferenceProperty( orient, "indexes", indices );
4979
4980   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4981   setPreferenceProperty( posVSizeGr, "columns", 2 );
4982   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4983   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4984   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4985   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4986   setPreferenceProperty( xv, "step", 0.1 );
4987   setPreferenceProperty( xv, "min", 0.0 );
4988   setPreferenceProperty( xv, "max", 1.0 );
4989   setPreferenceProperty( yv, "step", 0.1 );
4990   setPreferenceProperty( yv, "min", 0.0 );
4991   setPreferenceProperty( yv, "max", 1.0 );
4992   setPreferenceProperty( wv, "step", 0.1 );
4993   setPreferenceProperty( wv, "min", 0.0 );
4994   setPreferenceProperty( wv, "max", 1.0 );
4995   setPreferenceProperty( hv, "min", 0.0 );
4996   setPreferenceProperty( hv, "max", 1.0 );
4997   setPreferenceProperty( hv, "step", 0.1 );
4998
4999   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5000   setPreferenceProperty( posHSizeGr, "columns", 2 );
5001   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5002   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5003   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5004   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5005   setPreferenceProperty( xv, "min", 0.0 );
5006   setPreferenceProperty( xv, "max", 1.0 );
5007   setPreferenceProperty( xv, "step", 0.1 );
5008   setPreferenceProperty( xh, "min", 0.0 );
5009   setPreferenceProperty( xh, "max", 1.0 );
5010   setPreferenceProperty( xh, "step", 0.1 );
5011   setPreferenceProperty( yh, "min", 0.0 );
5012   setPreferenceProperty( yh, "max", 1.0 );
5013   setPreferenceProperty( yh, "step", 0.1 );
5014   setPreferenceProperty( wh, "min", 0.0 );
5015   setPreferenceProperty( wh, "max", 1.0 );
5016   setPreferenceProperty( wh, "step", 0.1 );
5017   setPreferenceProperty( hh, "min", 0.0 );
5018   setPreferenceProperty( hh, "max", 1.0 );
5019   setPreferenceProperty( hh, "step", 0.1 );
5020
5021   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5022   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5023   setPreferenceProperty( distributionGr, "columns", 3 );
5024   QStringList types;
5025   types.append( tr( "SMESH_MONOCOLOR" ) );
5026   types.append( tr( "SMESH_MULTICOLOR" ) );
5027   indices.clear(); indices.append( 0 ); indices.append( 1 );
5028   setPreferenceProperty( coloringType, "strings", types );
5029   setPreferenceProperty( coloringType, "indexes", indices );
5030   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5031
5032 }
5033
5034 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5035 {
5036   if( sect=="SMESH" ) {
5037     float sbX1,sbY1,sbW,sbH;
5038     float aTol = 1.00000009999999;
5039     std::string aWarning;
5040     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5041     if( name=="selection_object_color" || name=="selection_element_color" ||
5042         name=="highlight_color" ||
5043         name=="selection_precision_node" || name=="selection_precision_element" ||
5044         name=="selection_precision_object")
5045       SMESH::UpdateSelectionProp( this );
5046     else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5047       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5048       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5049       if(sbX1+sbW > aTol){
5050         aWarning = "Origin and Size Vertical: X+Width > 1\n";
5051         sbX1=0.01;
5052         sbW=0.08;
5053         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5054         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5055       }
5056     }
5057     else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5058       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5059       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5060       if(sbY1+sbH > aTol){
5061         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5062         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5063         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5064       }
5065     }
5066     else if(name ==  QString("scalar_bar_horizontal_x") || name ==  QString("scalar_bar_horizontal_width")){
5067       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5068       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5069       if(sbX1+sbW > aTol){
5070         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5071         sbX1=0.1;
5072         sbW=0.08;
5073         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5074         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5075       }
5076     }
5077     else if(name ==  QString("scalar_bar_horizontal_y") || name ==  QString("scalar_bar_horizontal_height")){
5078       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5079       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5080       if(sbY1+sbH > aTol){
5081         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5082         sbY1=0.01;
5083         sbH=0.08;
5084         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5085         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5086       }
5087     }
5088     else if ( name == "segmentation" ) {
5089       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5090       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5091     }
5092     else if ( name == "nb_segments_per_edge" ) {
5093       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5094       myComponentSMESH->SetDefaultNbSegments( nbSeg );
5095     }
5096     else if ( name == "historical_python_dump" ||
5097               name == "forget_mesh_on_hyp_modif") {
5098       QString val = aResourceMgr->stringValue( "SMESH", name );
5099       myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5100     }
5101     else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5102       SMESH::UpdateFontProp( this );
5103     }
5104     else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5105       SMESH::UpdateFontProp( this );
5106     }
5107
5108     if(aWarning.size() != 0){
5109       aWarning += "The default values are applied instead.";
5110       SUIT_MessageBox::warning(SMESHGUI::desktop(),
5111                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5112                                QObject::tr(aWarning.c_str()));
5113     }
5114   }
5115 }
5116
5117 //================================================================================
5118 /*!
5119  * \brief Update something in accordance with update flags
5120   * \param theFlags - update flags
5121 *
5122 * Update viewer or/and object browser etc. in accordance with update flags ( see
5123 * LightApp_UpdateFlags enumeration ).
5124 */
5125 //================================================================================
5126 void SMESHGUI::update( const int flags )
5127 {
5128   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5129     SMESH::UpdateView();
5130   else
5131     SalomeApp_Module::update( flags );
5132 }
5133
5134 //================================================================================
5135 /*!
5136  * \brief Set default selection mode
5137 *
5138 * SLOT called when operation commited. Sets default selection mode
5139 */
5140 //================================================================================
5141 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5142 {
5143   SVTK_ViewWindow* vtkWnd =
5144     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5145   if ( vtkWnd )
5146     vtkWnd->SetSelectionMode( ActorSelection );
5147 }
5148
5149 //================================================================================
5150 /*!
5151  * \brief Set default selection mode
5152 *
5153 * SLOT called when operation aborted. Sets default selection mode
5154 */
5155 //================================================================================
5156 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5157 {
5158   SVTK_ViewWindow* vtkWnd =
5159     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5160   if ( vtkWnd )
5161     vtkWnd->SetSelectionMode( ActorSelection );
5162 }
5163
5164 //================================================================================
5165 /*!
5166  * \brief Creates operation with given identifier
5167   * \param id - identifier of operation to be started
5168   * \return Pointer on created operation or NULL if operation is not created
5169 *
5170 * Virtual method redefined from the base class creates operation with given id.
5171 * It is called called automatically from startOperation method of base class.
5172 */
5173 //================================================================================
5174 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5175 {
5176   LightApp_Operation* op = 0;
5177   // to do : create operation here
5178   switch( id )
5179   {
5180     case 417: //convert to quadratic
5181       op = new SMESHGUI_ConvToQuadOp();
5182     break;
5183     case 418: // create 2D mesh as boundary on 3D
5184       op = new SMESHGUI_Make2DFrom3DOp();
5185     break;
5186     case 420: // Reorient faces
5187       op = new SMESHGUI_ReorientFacesOp();
5188       break;
5189     case 701: // Compute mesh
5190       op = new SMESHGUI_ComputeOp();
5191     break;
5192     case 702: // Create mesh
5193       op = new SMESHGUI_MeshOp( true, true );
5194     break;
5195     case 703: // Create sub-mesh
5196       op = new SMESHGUI_MeshOp( true, false );
5197     break;
5198     case 704: // Edit mesh/sub-mesh
5199       op = new SMESHGUI_MeshOp( false );
5200     break;
5201     case 711: // Precompute mesh
5202       op = new SMESHGUI_PrecomputeOp();
5203     break;
5204     case 712: // Evaluate mesh
5205       op = new SMESHGUI_EvaluateOp();
5206     break;
5207     case 713: // Evaluate mesh
5208       op = new SMESHGUI_MeshOrderOp();
5209     break;
5210     case 806: // Create group on geom
5211       op = new SMESHGUI_GroupOnShapeOp();
5212       break;
5213     case 904: // Find element
5214       op = new SMESHGUI_FindElemByPointOp();
5215       break;
5216     case 4067: // Make mesh pass through point
5217       op = new SMESHGUI_MakeNodeAtPointOp();
5218       break;
5219     case 4070: // Create 0D elements on all nodes
5220       op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5221       break;
5222     default:
5223     break;
5224   }
5225
5226   if( !op )
5227     op = SalomeApp_Module::createOperation( id );
5228   return op;
5229 }
5230
5231 //================================================================================
5232 /*!
5233  * \brief Stops current operations and starts a given one
5234   * \param id - The id of the operation to start
5235  */
5236 //================================================================================
5237
5238 void SMESHGUI::switchToOperation(int id)
5239 {
5240   if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5241     activeStudy()->abortAllOperations();
5242   startOperation( id );
5243 }
5244
5245 LightApp_Displayer* SMESHGUI::displayer()
5246 {
5247   if( !myDisplayer )
5248     myDisplayer = new SMESHGUI_Displayer( getApp() );
5249   return myDisplayer;
5250 }
5251
5252 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5253 {
5254   int aHue = -1;
5255   int aTolerance = 64;
5256   int anIterations = 0;
5257   int aPeriod = 5;
5258
5259   while( 1 )
5260   {
5261     anIterations++;
5262     if( anIterations % aPeriod == 0 )
5263     {
5264       aTolerance /= 2;
5265       if( aTolerance < 1 )
5266         break;
5267     }
5268
5269     aHue = (int)( 360.0 * rand() / RAND_MAX );
5270
5271     bool ok = true;
5272     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5273     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5274     for( ; it != itEnd; ++it )
5275     {
5276       SALOMEDS::Color anAutoColor = *it;
5277       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5278
5279       int h, s, v;
5280       aQColor.getHsv( &h, &s, &v );
5281       if( abs( h - aHue ) < aTolerance )
5282       {
5283         ok = false;
5284         break;
5285       }
5286     }
5287
5288     if( ok )
5289       break;
5290   }
5291
5292   QColor aColor;
5293   aColor.setHsv( aHue, 255, 255 );
5294
5295   SALOMEDS::Color aSColor;
5296   aSColor.R = aColor.redF();
5297   aSColor.G = aColor.greenF();
5298   aSColor.B = aColor.blueF();
5299
5300   return aSColor;
5301 }
5302
5303 const char* gSeparator = "_"; // character used to separate parameter names
5304 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5305 const char* gPathSep   = "|"; // character used to separate paths
5306
5307 /*!
5308  * \brief Store visual parameters
5309  *
5310  * This method is called just before the study document is saved.
5311  * Store visual parameters in AttributeParameter attribue(s)
5312  */
5313 void SMESHGUI::storeVisualParameters (int savePoint)
5314 {
5315   // localizing
5316   Kernel_Utils::Localizer loc;
5317
5318   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5319   if (!appStudy || !appStudy->studyDS())
5320     return;
5321   _PTR(Study) studyDS = appStudy->studyDS();
5322
5323   // componentName is used for encoding of entries when storing them in IParameters
5324   std::string componentName = myComponentSMESH->ComponentDataType();
5325   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5326   //if (!aSComponent) return;
5327
5328   // IParameters
5329   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5330                                                              componentName.c_str(),
5331                                                              savePoint);
5332   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5333
5334   // store map of custom markers
5335   const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5336   if( !aMarkerMap.empty() )
5337   {
5338     VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5339     for( ; anIter != aMarkerMap.end(); anIter++ )
5340     {
5341       int anId = anIter->first;
5342       VTK::MarkerData aMarkerData = anIter->second;
5343       std::string aMarkerFileName = aMarkerData.first;
5344       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5345       if( aMarkerTexture.size() < 3 )
5346         continue; // should contain at least width, height and the first value
5347
5348       QString aPropertyName( "texture" );
5349       aPropertyName += gSeparator;
5350       aPropertyName += QString::number( anId );
5351
5352       QString aPropertyValue = aMarkerFileName.c_str();
5353       aPropertyValue += gPathSep;
5354
5355       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5356       ushort aWidth = *aTextureIter++;
5357       ushort aHeight = *aTextureIter++;
5358       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5359       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5360       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5361         aPropertyValue += QString::number( *aTextureIter );
5362
5363       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5364     }
5365   }
5366
5367   // viewers counters are used for storing view_numbers in IParameters
5368   int vtkViewers = 0;
5369
5370   // main cycle to store parameters of displayed objects
5371   QList<SUIT_ViewManager*> lst;
5372   QList<SUIT_ViewManager*>::Iterator it;
5373   getApp()->viewManagers(lst);
5374   for (it = lst.begin(); it != lst.end(); it++)
5375   {
5376     SUIT_ViewManager* vman = *it;
5377     QString vType = vman->getType();
5378
5379     // saving VTK actors properties
5380     if (vType == SVTK_Viewer::Type())
5381     {
5382       // store the clipping planes attached to the view manager
5383       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5384       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5385       if( anIter != myClippingPlaneInfoMap.end() )
5386         aClippingPlaneInfoList = anIter->second;
5387
5388       if( !aClippingPlaneInfoList.empty() ) {
5389         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5390         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5391         {
5392           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5393           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5394
5395           QString aPropertyName( "ClippingPlane" );
5396           aPropertyName += gSeparator;
5397           aPropertyName += QString::number( vtkViewers );
5398           aPropertyName += gSeparator;
5399           aPropertyName += QString::number( anId );
5400
5401           QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5402           aPropertyValue += gDigitsSep;
5403           aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5404           aPropertyValue += gDigitsSep;
5405           aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5406           aPropertyValue += gDigitsSep;
5407           aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5408
5409           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5410         }
5411       }
5412
5413       QVector<SUIT_ViewWindow*> views = vman->getViews();
5414       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5415       {
5416         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5417         {
5418           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5419           vtkActorCollection* allActors = aCopy.GetActors();
5420           allActors->InitTraversal();
5421           while (vtkActor* actor = allActors->GetNextActor())
5422           {
5423             if (actor->GetVisibility()) // store only visible actors
5424             {
5425               SMESH_Actor* aSmeshActor = 0;
5426               if (actor->IsA("SMESH_Actor"))
5427                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5428               if (aSmeshActor && aSmeshActor->hasIO())
5429               {
5430                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5431                 if (io->hasEntry())
5432                 {
5433                   // entry is "encoded" = it does NOT contain component adress,
5434                   // since it is a subject to change on next component loading
5435                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5436
5437                   std::string param, vtkParam = vType.toLatin1().data();
5438                   vtkParam += gSeparator;
5439                   vtkParam += QString::number(vtkViewers).toLatin1().data();
5440                   vtkParam += gSeparator;
5441
5442                   // Visibility
5443                   param = vtkParam + "Visibility";
5444                   ip->setParameter(entry, param, "On");
5445
5446                   // Representation
5447                   param = vtkParam + "Representation";
5448                   ip->setParameter(entry, param, QString::number
5449                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5450
5451                   // IsShrunk
5452                   param = vtkParam + "IsShrunk";
5453                   ip->setParameter(entry, param, QString::number
5454                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5455
5456                   // Displayed entities
5457                   unsigned int aMode = aSmeshActor->GetEntityMode();
5458                   bool isE  = aMode & SMESH_Actor::eEdges;
5459                   bool isF  = aMode & SMESH_Actor::eFaces;
5460                   bool isV  = aMode & SMESH_Actor::eVolumes;
5461                   bool is0d = aMode & SMESH_Actor::e0DElements;
5462                   bool isB  = aMode & SMESH_Actor::eBallElem;
5463
5464                   QString modeStr ("e");
5465                   modeStr += gDigitsSep; modeStr += QString::number(isE);
5466                   modeStr += gDigitsSep; modeStr += "f";
5467                   modeStr += gDigitsSep; modeStr += QString::number(isF);
5468                   modeStr += gDigitsSep; modeStr += "v";
5469                   modeStr += gDigitsSep; modeStr += QString::number(isV);
5470                   modeStr += gDigitsSep; modeStr += "0d";
5471                   modeStr += gDigitsSep; modeStr += QString::number(is0d);
5472                   modeStr += gDigitsSep; modeStr += "b";
5473                   modeStr += gDigitsSep; modeStr += QString::number(isB);
5474
5475                   param = vtkParam + "Entities";
5476                   ip->setParameter(entry, param, modeStr.toLatin1().data());
5477
5478                   // Colors
5479                   double r, g, b;
5480                   int delta;
5481
5482                   aSmeshActor->GetSufaceColor(r, g, b, delta);
5483                   QStringList colorStr;
5484                   colorStr << "surface";
5485                   colorStr << QString::number(r);
5486                   colorStr << QString::number(g);
5487                   colorStr << QString::number(b);
5488
5489                   colorStr << "backsurface";
5490                   colorStr << QString::number(delta);
5491
5492                   aSmeshActor->GetVolumeColor(r, g, b, delta);
5493                   colorStr << "volume";
5494                   colorStr << QString::number(r);
5495                   colorStr << QString::number(g);
5496                   colorStr << QString::number(b);
5497                   colorStr << QString::number(delta);
5498
5499                   aSmeshActor->GetEdgeColor(r, g, b);
5500                   colorStr << "edge";
5501                   colorStr << QString::number(r);
5502                   colorStr << QString::number(g);
5503                   colorStr << QString::number(b);
5504
5505                   aSmeshActor->GetNodeColor(r, g, b);
5506                   colorStr << "node";
5507                   colorStr << QString::number(r);
5508                   colorStr << QString::number(g);
5509                   colorStr << QString::number(b);
5510
5511                   aSmeshActor->GetOutlineColor(r, g, b);
5512                   colorStr << "outline";
5513                   colorStr << QString::number(r);
5514                   colorStr << QString::number(g);
5515                   colorStr << QString::number(b);
5516
5517                   aSmeshActor->Get0DColor(r, g, b);
5518                   colorStr << "elem0d";
5519                   colorStr << QString::number(r);
5520                   colorStr << QString::number(g);
5521                   colorStr << QString::number(b);
5522
5523                   aSmeshActor->GetBallColor(r, g, b);
5524                   colorStr << "ball";
5525                   colorStr << QString::number(r);
5526                   colorStr << QString::number(g);
5527                   colorStr << QString::number(b);
5528
5529                   aSmeshActor->GetFacesOrientationColor(r, g, b);
5530                   colorStr << "orientation";
5531                   colorStr << QString::number(r);
5532                   colorStr << QString::number(g);
5533                   colorStr << QString::number(b);
5534
5535                   param = vtkParam + "Colors";
5536                   ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5537
5538                   // Sizes
5539                   QStringList sizeStr;
5540                   sizeStr << "line";
5541                   sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5542                   sizeStr << "outline";
5543                   sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5544                   sizeStr << "elem0d";
5545                   sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5546                   sizeStr << "ball";
5547                   sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5548                   sizeStr << "shrink";
5549                   sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5550                   sizeStr << "orientation";
5551                   sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5552                   sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5553
5554                   param = vtkParam + "Sizes";
5555                   ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5556
5557                   // Point marker
5558                   QString markerStr;
5559
5560                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5561                   if( aMarkerType == VTK::MT_USER ) {
5562                     markerStr += "custom";
5563                     markerStr += gDigitsSep;
5564                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5565                   }
5566                   else {
5567                     markerStr += "std";
5568                     markerStr += gDigitsSep;
5569                     markerStr += QString::number( (int)aMarkerType );
5570                     markerStr += gDigitsSep;
5571                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5572                   }
5573
5574                   param = vtkParam + "PointMarker";
5575                   ip->setParameter(entry, param, markerStr.toLatin1().data());
5576
5577                   // Opacity
5578                   param = vtkParam + "Opacity";
5579                   ip->setParameter(entry, param,
5580                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5581
5582                   // Clipping
5583                   param = vtkParam + "ClippingPlane";
5584                   int aPlaneId = 0;
5585                   if( !aClippingPlaneInfoList.empty() ) {
5586                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5587                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5588                     {
5589                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5590                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5591                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
5592                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5593                         if( aSmeshActor == *anIter2 ) {
5594                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5595                                             QString::number( anId ).toLatin1().constData() );
5596                           break;
5597                         }
5598                       }
5599                     }
5600                   }
5601                   if( aPlaneId == 0 )
5602                     ip->setParameter( entry, param, "Off" );
5603                 } // if (io->hasEntry())
5604               } // SMESH_Actor && hasIO
5605             } // isVisible
5606           } // while.. actors traversal
5607         } // if (vtkView)
5608       } // for (views)
5609       vtkViewers++;
5610     } // if (SVTK view model)
5611   } // for (viewManagers)
5612 }
5613
5614 // data structures for clipping planes processing
5615 typedef struct {
5616   int Id;
5617   vtkIdType Orientation;
5618   double Distance;
5619   double Angle[2];
5620 } TPlaneData;
5621 typedef std::list<TPlaneData>         TPlaneDataList;
5622 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5623
5624 typedef std::list<vtkActor*>          TActorList;
5625 typedef struct {
5626   int PlaneId;
5627   TActorList ActorList;
5628   SUIT_ViewManager* ViewManager;
5629 } TPlaneInfo;
5630 typedef std::list<TPlaneInfo>         TPlaneInfoList;
5631 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5632
5633 /*!
5634  * \brief Restore visual parameters
5635  *
5636  * This method is called after the study document is opened.
5637  * Restore visual parameters from AttributeParameter attribue(s)
5638  */
5639 void SMESHGUI::restoreVisualParameters (int savePoint)
5640 {
5641   // localizing
5642   Kernel_Utils::Localizer loc;
5643
5644   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5645   if (!appStudy || !appStudy->studyDS())
5646     return;
5647   _PTR(Study) studyDS = appStudy->studyDS();
5648
5649   // componentName is used for encoding of entries when storing them in IParameters
5650   std::string componentName = myComponentSMESH->ComponentDataType();
5651   //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5652   //if (!aSComponent) return;
5653
5654   // IParameters
5655   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5656                                                              componentName.c_str(),
5657                                                              savePoint);
5658   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5659
5660   // restore map of custom markers and map of clipping planes
5661   VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5662   TPlaneDataMap aPlaneDataMap;
5663
5664   std::vector<std::string> properties = ip->getProperties();
5665   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5666   {
5667     std::string property = *propIt;
5668     QString aPropertyName( property.c_str() );
5669     QString aPropertyValue( ip->getProperty( property ).c_str() );
5670
5671     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5672     if( aPropertyNameList.isEmpty() )
5673       continue;
5674
5675     QString aPropertyType = aPropertyNameList[0];
5676     if( aPropertyType == "texture" )
5677     {
5678       if( aPropertyNameList.size() != 2 )
5679         continue;
5680
5681       bool ok = false;
5682       int anId = aPropertyNameList[1].toInt( &ok );
5683       if( !ok || anId < 1 )
5684         continue;
5685
5686       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5687       if( aPropertyValueList.size() != 2 )
5688         continue;
5689
5690       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5691       QString aMarkerTextureString = aPropertyValueList[1];
5692       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5693       if( aMarkerTextureStringList.size() != 3 )
5694         continue;
5695
5696       ok = false;
5697       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5698       if( !ok )
5699         continue;
5700
5701       ok = false;
5702       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5703       if( !ok )
5704         continue;
5705
5706       VTK::MarkerTexture aMarkerTexture;
5707       aMarkerTexture.push_back( aWidth );
5708       aMarkerTexture.push_back( aHeight );
5709
5710       QString aMarkerTextureData = aMarkerTextureStringList[2];
5711       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5712       {
5713         QChar aChar = aMarkerTextureData.at( i );
5714         if( aChar.isDigit() )
5715           aMarkerTexture.push_back( aChar.digitValue() );
5716       }
5717
5718       aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5719     }
5720     else if( aPropertyType == "ClippingPlane" )
5721     {
5722       if( aPropertyNameList.size() != 3 )
5723         continue;
5724
5725       bool ok = false;
5726       int aViewId = aPropertyNameList[1].toInt( &ok );
5727       if( !ok || aViewId < 0 )
5728         continue;
5729
5730       ok = false;
5731       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5732       if( !ok || aClippingPlaneId < 0 )
5733         continue;
5734
5735       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5736       if( aPropertyValueList.size() != 4 )
5737         continue;
5738
5739       TPlaneData aPlaneData;
5740       aPlaneData.Id = aClippingPlaneId;
5741
5742       ok = false;
5743       aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5744       if( !ok )
5745         continue;
5746
5747       ok = false;
5748       aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5749       if( !ok )
5750         continue;
5751
5752       ok = false;
5753       aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5754       if( !ok )
5755         continue;
5756
5757       ok = false;
5758       aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5759       if( !ok )
5760         continue;
5761
5762       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5763       aPlaneDataList.push_back( aPlaneData );
5764     }
5765   }
5766
5767   TPlaneInfoMap aPlaneInfoMap;
5768
5769   std::vector<std::string> entries = ip->getEntries();
5770
5771   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5772   {
5773     // entry is a normal entry - it should be "decoded" (setting base adress of component)
5774     QString entry (ip->decodeEntry(*entIt).c_str());
5775
5776     // Check that the entry corresponds to a real object in the Study
5777     // as the object may be deleted or modified after the visual state is saved.
5778     _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5779     if (!so) continue; //Skip the not existent entry
5780
5781     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5782     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5783
5784     std::vector<std::string>::iterator namesIt = paramNames.begin();
5785     std::vector<std::string>::iterator valuesIt = paramValues.begin();
5786
5787     // actors are stored in a map after displaying of them for
5788     // quicker access in the future: map < viewID to actor >
5789     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5790
5791     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5792     {
5793       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5794       // '_' is used as separator and should not be used in viewer type or parameter names.
5795       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5796       if (lst.size() != 3)
5797         continue;
5798
5799       QString viewerTypStr = lst[0];
5800       QString viewIndexStr = lst[1];
5801       QString paramNameStr = lst[2];
5802
5803       bool ok;
5804       int viewIndex = viewIndexStr.toUInt(&ok);
5805       if (!ok) // bad conversion of view index to integer
5806         continue;
5807
5808       // viewers
5809       if (viewerTypStr == SVTK_Viewer::Type())
5810       {
5811         SMESH_Actor* aSmeshActor = 0;
5812         if (vtkActors.IsBound(viewIndex))
5813           aSmeshActor = vtkActors.Find(viewIndex);
5814
5815         QList<SUIT_ViewManager*> lst;
5816         getApp()->viewManagers(viewerTypStr, lst);
5817
5818         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5819         SUIT_ViewManager* vman = NULL;
5820         if (viewIndex >= 0 && viewIndex < lst.count())
5821           vman = lst.at(viewIndex);
5822
5823         if (paramNameStr == "Visibility")
5824         {
5825           if (!aSmeshActor && displayer() && vman)
5826           {
5827             SUIT_ViewModel* vmodel = vman->getViewModel();
5828             // SVTK view model can be casted to SALOME_View
5829             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5830
5831             // store displayed actor in a temporary map for quicker
5832             // access later when restoring other parameters
5833             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5834             vtkRenderer* Renderer = vtkView->getRenderer();
5835             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5836             vtkActorCollection* theActors = aCopy.GetActors();
5837             theActors->InitTraversal();
5838             bool isFound = false;
5839             vtkActor *ac = theActors->GetNextActor();
5840             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5841               if (ac->IsA("SMESH_Actor")) {
5842                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5843                 if (aGeomAc->hasIO()) {
5844                   Handle(SALOME_InteractiveObject) io =
5845                     Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5846                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5847                     isFound = true;
5848                     vtkActors.Bind(viewIndex, aGeomAc);
5849                   }
5850                 }
5851               }
5852             }
5853           }
5854         } // if (paramNameStr == "Visibility")
5855         else
5856         {
5857           // the rest properties "work" with SMESH_Actor
5858           if (aSmeshActor)
5859           {
5860             QString val ((*valuesIt).c_str());
5861
5862             // Representation
5863             if (paramNameStr == "Representation") {
5864               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5865             }
5866             // IsShrunk
5867             else if (paramNameStr == "IsShrunk") {
5868               if (val.toInt()) {
5869                 if (!aSmeshActor->IsShrunk())
5870                   aSmeshActor->SetShrink();
5871               }
5872               else {
5873                 if (aSmeshActor->IsShrunk())
5874                   aSmeshActor->UnShrink();
5875               }
5876             }
5877             // Displayed entities
5878             else if (paramNameStr == "Entities") {
5879               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5880               int aEntityMode = SMESH_Actor::eAllEntity;
5881               for ( int i = 0; i < mode.count(); i+=2 ) {
5882                 if ( i < mode.count()-1 ) {
5883                   QString type = mode[i];
5884                   bool val = mode[i+1].toInt();
5885                   if      ( type == "e" && !val )
5886                     aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
5887                   else if ( type == "f" && !val )
5888                     aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
5889                   else if ( type == "v" && !val )
5890                     aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
5891                   else if ( type == "0d" && !val )
5892                     aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
5893                   else if ( type == "b" && !val )
5894                     aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
5895                 }
5896               }
5897               aSmeshActor->SetEntityMode( aEntityMode );
5898             }
5899             // Colors
5900             else if (paramNameStr == "Colors") {
5901               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5902               QColor nodeColor;
5903               QColor edgeColor;
5904               QColor faceColor;
5905               QColor volumeColor;
5906               QColor elem0dColor;
5907               QColor ballColor;
5908               QColor outlineColor;
5909               QColor orientationColor;
5910               int deltaF;
5911               int deltaV;
5912               QColor c;
5913               double r, g, b;
5914               bool bOk;
5915               // below lines are required to get default values for delta coefficients
5916               // of backface color for faces and color of reversed volumes
5917               SMESH::GetColor( "SMESH", "fill_color",   c, deltaF, "0,170,255|-100" );
5918               SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
5919               for ( int i = 0; i < colors.count(); i++ ) {
5920                 QString type = colors[i];
5921                 if ( type == "surface" ) {
5922                   // face color is set by 3 values r:g:b, where
5923                   // - r,g,b - is rgb color components
5924                   if ( i+1 >= colors.count() ) break;                  // format error
5925                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5926                   if ( i+2 >= colors.count() ) break;                  // format error
5927                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5928                   if ( i+3 >= colors.count() ) break;                  // format error
5929                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5930                   faceColor.setRgbF( r, g, b );
5931                   i += 3;
5932                 }
5933                 else if ( type == "backsurface" ) {
5934                   // backface color can be defined in several ways
5935                   // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
5936                   // - in latest versions, it is set as delta coefficient
5937                   bool rgbOk = false, deltaOk;
5938                   if ( i+1 >= colors.count() ) break;                  // format error
5939                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5940                   int delta = colors[i+1].toInt( &deltaOk );
5941                   i++;                                 // shift index
5942                   if ( i+1 < colors.count() )          // index is shifted to 1
5943                     g = colors[i+1].toDouble( &rgbOk );
5944                   if ( rgbOk ) i++;                    // shift index
5945                   if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
5946                     b = colors[i+1].toDouble( &rgbOk );
5947                   if ( rgbOk ) i++;
5948                   // - as currently there's no way to set directly backsurface color as it was before,
5949                   // we ignore old dump where r,g,b triple was set
5950                   // - also we check that delta parameter is set properly
5951                   if ( !rgbOk && deltaOk )
5952                     deltaF = delta;
5953                 }
5954                 else if ( type == "volume" ) {
5955                   // volume color is set by 4 values r:g:b:delta, where
5956                   // - r,g,b - is a normal volume rgb color components
5957                   // - delta - is a reversed volume color delta coefficient
5958                   if ( i+1 >= colors.count() ) break;                  // format error
5959                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5960                   if ( i+2 >= colors.count() ) break;                  // format error
5961                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5962                   if ( i+3 >= colors.count() ) break;                  // format error
5963                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5964                   if ( i+4 >= colors.count() ) break;                  // format error
5965                   int delta = colors[i+4].toInt( &bOk );
5966                   if ( !bOk ) break;                                   // format error
5967                   volumeColor.setRgbF( r, g, b );
5968                   deltaV = delta;
5969                   i += 4;
5970                 }
5971                 else if ( type == "edge" ) {
5972                   // edge color is set by 3 values r:g:b, where
5973                   // - r,g,b - is rgb color components
5974                   if ( i+1 >= colors.count() ) break;                  // format error
5975                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5976                   if ( i+2 >= colors.count() ) break;                  // format error
5977                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5978                   if ( i+3 >= colors.count() ) break;                  // format error
5979                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5980                   edgeColor.setRgbF( r, g, b );
5981                   i += 3;
5982                 }
5983                 else if ( type == "node" ) {
5984                   // node color is set by 3 values r:g:b, where
5985                   // - r,g,b - is rgb color components
5986                   if ( i+1 >= colors.count() ) break;                  // format error
5987                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5988                   if ( i+2 >= colors.count() ) break;                  // format error
5989                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5990                   if ( i+3 >= colors.count() ) break;                  // format error
5991                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5992                   nodeColor.setRgbF( r, g, b );
5993                   i += 3;
5994                 }
5995                 else if ( type == "elem0d" ) {
5996                   // 0d element color is set by 3 values r:g:b, where
5997                   // - r,g,b - is rgb color components
5998                   if ( i+1 >= colors.count() ) break;                  // format error
5999                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6000                   if ( i+2 >= colors.count() ) break;                  // format error
6001                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6002                   if ( i+3 >= colors.count() ) break;                  // format error
6003                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6004                   elem0dColor.setRgbF( r, g, b );
6005                   i += 3;
6006                 }
6007                 else if ( type == "ball" ) {
6008                   // ball color is set by 3 values r:g:b, where
6009                   // - r,g,b - is rgb color components
6010                   if ( i+1 >= colors.count() ) break;                  // format error
6011                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6012                   if ( i+2 >= colors.count() ) break;                  // format error
6013                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6014                   if ( i+3 >= colors.count() ) break;                  // format error
6015                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6016                   ballColor.setRgbF( r, g, b );
6017                   i += 3;
6018                 }
6019                 else if ( type == "outline" ) {
6020                   // outline color is set by 3 values r:g:b, where
6021                   // - r,g,b - is rgb color components
6022                   if ( i+1 >= colors.count() ) break;                  // format error
6023                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6024                   if ( i+2 >= colors.count() ) break;                  // format error
6025                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6026                   if ( i+3 >= colors.count() ) break;                  // format error
6027                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6028                   outlineColor.setRgbF( r, g, b );
6029                   i += 3;
6030                 }
6031                 else if ( type == "orientation" ) {
6032                   // orientation color is set by 3 values r:g:b, where
6033                   // - r,g,b - is rgb color components
6034                   if ( i+1 >= colors.count() ) break;                  // format error
6035                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6036                   if ( i+2 >= colors.count() ) break;                  // format error
6037                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6038                   if ( i+3 >= colors.count() ) break;                  // format error
6039                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6040                   orientationColor.setRgbF( r, g, b );
6041                   i += 3;
6042                 }
6043               }
6044               // node color
6045               if ( nodeColor.isValid() )
6046                 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6047               // edge color
6048               if ( edgeColor.isValid() )
6049                 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6050               // face color
6051               if ( faceColor.isValid() )
6052                 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6053               // volume color
6054               if ( volumeColor.isValid() )
6055                 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6056               else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6057                 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6058               // 0d element color
6059               if ( elem0dColor.isValid() )
6060                 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6061               // ball color
6062               if ( ballColor.isValid() )
6063                 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6064               // outline color
6065               if ( outlineColor.isValid() )
6066                 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6067               // orientation color
6068               if ( orientationColor.isValid() )
6069                 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6070             }
6071             // Sizes
6072             else if (paramNameStr == "Sizes") {
6073               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6074               bool bOk;
6075               int lineWidth = -1;
6076               int outlineWidth = -1;
6077               int elem0dSize = -1;
6078               int ballSize = -1;
6079               double shrinkSize = -1;
6080               double orientationSize = -1;
6081               bool orientation3d = false;
6082               for ( int i = 0; i < sizes.count(); i++ ) {
6083                 QString type = sizes[i];
6084                 if ( type == "line" ) {
6085                   // line (wireframe) width is given as single integer value
6086                   if ( i+1 >= sizes.count() ) break;                    // format error
6087                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6088                   lineWidth = v;
6089                   i++;
6090                 }
6091                 if ( type == "outline" ) {
6092                   // outline width is given as single integer value
6093                   if ( i+1 >= sizes.count() ) break;                    // format error
6094                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6095                   outlineWidth = v;
6096                   i++;
6097                 }
6098                 else if ( type == "elem0d" ) {
6099                   // 0d element size is given as single integer value
6100                   if ( i+1 >= sizes.count() ) break;                    // format error
6101                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6102                   elem0dSize = v;
6103                   i++;
6104                 }
6105                 else if ( type == "ball" ) {
6106                   // ball size is given as single integer value
6107                   if ( i+1 >= sizes.count() ) break;                    // format error
6108                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6109                   ballSize = v;
6110                   i++;
6111                 }
6112                 else if ( type == "shrink" ) {
6113                   // shrink factor is given as single floating point value
6114                   if ( i+1 >= sizes.count() ) break;                          // format error
6115                   double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break;  // format error
6116                   shrinkSize = v;
6117                   i++;
6118                 }
6119                 else if ( type == "orientation" ) {
6120                   // orientation vectors are specified by two values size:3d, where
6121                   // - size - is a floating point value specifying scale factor
6122                   // - 3d - is a boolean
6123                   if ( i+1 >= sizes.count() ) break;                          // format error
6124                   double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6125                   if ( i+2 >= sizes.count() ) break;                          // format error
6126                   int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break;       // format error
6127                   orientationSize = v1;
6128                   orientation3d = (bool)v2;
6129                   i += 2;
6130                 }
6131               }
6132               // line (wireframe) width
6133               if ( lineWidth > 0 )
6134                 aSmeshActor->SetLineWidth( lineWidth );
6135               // outline width
6136               if ( outlineWidth > 0 )
6137                 aSmeshActor->SetOutlineWidth( outlineWidth );
6138               else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6139                 aSmeshActor->SetOutlineWidth( lineWidth );
6140               // 0d element size
6141               if ( elem0dSize > 0 )
6142                 aSmeshActor->Set0DSize( elem0dSize );
6143               // ball size
6144               if ( ballSize > 0 )
6145                 aSmeshActor->SetBallSize( ballSize );
6146               // shrink factor
6147               if ( shrinkSize > 0 )
6148                 aSmeshActor->SetShrinkFactor( shrinkSize );
6149               // orientation vectors
6150               if ( orientationSize > 0 ) {
6151                 aSmeshActor->SetFacesOrientationScale( orientationSize );
6152                 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6153               }
6154             }
6155             // Point marker
6156             else if (paramNameStr == "PointMarker") {
6157               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6158               if( data.count() >= 2 ) {
6159                 bool ok = false;
6160                 int aParam1 = data[1].toInt( &ok );
6161                 if( ok ) {
6162                   if( data[0] == "std" && data.count() == 3 ) {
6163                     int aParam2 = data[2].toInt( &ok );
6164                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6165                   }
6166                   else if( data[0] == "custom" ) {
6167                     VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6168                     if( markerIt != aMarkerMap.end() ) {
6169                       VTK::MarkerData aMarkerData = markerIt->second;
6170                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6171                     }
6172                   }
6173                 }
6174               }
6175             }
6176             // Opacity
6177             else if (paramNameStr == "Opacity") {
6178               aSmeshActor->SetOpacity(val.toFloat());
6179             }
6180             // Clipping
6181             else if (paramNameStr.startsWith("ClippingPlane")) {
6182               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6183               // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
6184               // new format - val looks like "Off" or "0" (plane id)
6185               // (note: in new format "Off" value is used only for consistency,
6186               //  so it is processed together with values in old format)
6187               bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
6188               if( anIsOldFormat ) {
6189                 if (paramNameStr == "ClippingPlane1" || val == "Off")
6190                   aSmeshActor->RemoveAllClippingPlanes();
6191                 if (val != "Off") {
6192                   SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
6193                   double aDistance = vals[1].toFloat();
6194                   double anAngle[2];
6195                   anAngle[0] = vals[2].toFloat();
6196                   anAngle[1] = vals[3].toFloat();
6197
6198                   QList<SUIT_ViewManager*> lst;
6199                   getApp()->viewManagers(viewerTypStr, lst);
6200                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6201                   if (viewIndex >= 0 && viewIndex < lst.count()) {
6202                     SUIT_ViewManager* vman = lst.at(viewIndex);
6203                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6204
6205                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6206
6207                     SMESH::TActorList anActorList;
6208                     anActorList.push_back( aSmeshActor );
6209                     SMESH::OrientedPlane* aPlane =
6210                       SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
6211                     if( aPlane ) {
6212                       SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6213                       aClippingPlaneInfo.Plane = aPlane;
6214                       aClippingPlaneInfo.ActorList = anActorList;
6215                       aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6216                     }
6217                   }
6218                 }
6219               }
6220               else {
6221                 bool ok = false;
6222                 int aPlaneId = val.toInt( &ok );
6223                 if( ok && aPlaneId >= 0 ) {
6224                   bool anIsDefinedPlane = false;
6225                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6226                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6227                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6228                     TPlaneInfo& aPlaneInfo = *anIter;
6229                     if( aPlaneInfo.PlaneId == aPlaneId ) {
6230                       aPlaneInfo.ActorList.push_back( aSmeshActor );
6231                       anIsDefinedPlane = true;
6232                       break;
6233                     }
6234                   }
6235                   if( !anIsDefinedPlane ) {
6236                     TPlaneInfo aPlaneInfo;
6237                     aPlaneInfo.PlaneId = aPlaneId;
6238                     aPlaneInfo.ActorList.push_back( aSmeshActor );
6239                     aPlaneInfo.ViewManager = vman;
6240
6241                     // to make the list sorted by plane id
6242                     anIter = aPlaneInfoList.begin();
6243                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6244                       const TPlaneInfo& aPlaneInfoRef = *anIter;
6245                       if( aPlaneInfoRef.PlaneId > aPlaneId )
6246                         break;
6247                     }
6248                     aPlaneInfoList.insert( anIter, aPlaneInfo );
6249                   }
6250                 }
6251               }
6252             }
6253           } // if (aSmeshActor)
6254         } // other parameters than Visibility
6255       }
6256     } // for names/parameters iterator
6257   } // for entries iterator
6258
6259   // take into account planes with empty list of actors referred to them
6260   QList<SUIT_ViewManager*> aVMList;
6261   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6262
6263   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6264   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6265     int aViewId = aPlaneDataIter->first;
6266     if( aViewId >= 0 && aViewId < aVMList.count() ) {
6267       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6268
6269       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6270
6271       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6272       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6273       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6274         const TPlaneData& aPlaneData = *anIter2;
6275         int aPlaneId = aPlaneData.Id;
6276
6277         bool anIsFound = false;
6278         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6279         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6280           const TPlaneInfo& aPlaneInfo = *anIter3;
6281           if( aPlaneInfo.PlaneId == aPlaneId ) {
6282             anIsFound = true;
6283             break;
6284           }
6285         }
6286
6287         if( !anIsFound ) {
6288           TPlaneInfo aPlaneInfo; // ActorList field is empty
6289           aPlaneInfo.PlaneId = aPlaneId;
6290           aPlaneInfo.ViewManager = aViewManager;
6291
6292           // to make the list sorted by plane id
6293           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6294           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6295             const TPlaneInfo& aPlaneInfoRef = *anIter4;
6296             if( aPlaneInfoRef.PlaneId > aPlaneId )
6297               break;
6298           }
6299           aPlaneInfoList.insert( anIter4, aPlaneInfo );
6300         }
6301       }
6302     }
6303   }
6304
6305   // add clipping planes to actors according to the restored parameters
6306   // and update the clipping plane map
6307   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6308   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6309     int aViewId = anIter1->first;
6310     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6311
6312     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6313     if( anIter2 == aPlaneDataMap.end() )
6314       continue;
6315     const TPlaneDataList& aPlaneDataList = anIter2->second;
6316
6317     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6318     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6319       const TPlaneInfo& aPlaneInfo = *anIter3;
6320       int aPlaneId = aPlaneInfo.PlaneId;
6321       const TActorList& anActorList = aPlaneInfo.ActorList;
6322       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6323       if( !aViewManager )
6324         continue;
6325
6326       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6327       if( !aViewWindow )
6328         continue;
6329
6330       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6331
6332       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6333       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6334         const TPlaneData& aPlaneData = *anIter4;
6335         if( aPlaneData.Id == aPlaneId ) {
6336           SMESH::OrientedPlane* aPlane =
6337             SMESHGUI_ClippingDlg::AddPlane( anActorList,
6338                                             aViewWindow,
6339                                             (SMESH::Orientation)aPlaneData.Orientation,
6340                                             aPlaneData.Distance,
6341                                             aPlaneData.Angle );
6342           if( aPlane ) {
6343             SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6344             aClippingPlaneInfo.Plane = aPlane;
6345             aClippingPlaneInfo.ActorList = anActorList;
6346             aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6347           }
6348           break;
6349         }
6350       }
6351     }
6352   }
6353
6354   // update all VTK views
6355   QList<SUIT_ViewManager*> lst;
6356   getApp()->viewManagers(lst);
6357   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6358     SUIT_ViewModel* vmodel = (*it)->getViewModel();
6359     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6360       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6361       vtkView->getRenderer()->ResetCameraClippingRange();
6362       vtkView->Repaint();
6363     }
6364   }
6365 }
6366
6367 /*!
6368   \brief Adds preferences for dfont of VTK viewer
6369   \param label label
6370   \param pIf group identifier
6371   \param param parameter
6372   \return identifier of preferences
6373 */
6374 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6375 {
6376   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6377
6378   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6379
6380   QStringList fam;
6381   fam.append( tr( "SMESH_FONT_ARIAL" ) );
6382   fam.append( tr( "SMESH_FONT_COURIER" ) );
6383   fam.append( tr( "SMESH_FONT_TIMES" ) );
6384
6385   setPreferenceProperty( tfont, "fonts", fam );
6386
6387   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6388   if ( needSize ) f = f | QtxFontEdit::Size;
6389   setPreferenceProperty( tfont, "features", f );
6390
6391   return tfont;
6392 }
6393
6394 /*!
6395   \brief Actions after hypothesis edition
6396   Updates object browser after hypothesis edition
6397 */
6398 void SMESHGUI::onHypothesisEdit( int result )
6399 {
6400   if( result == 1 )
6401     SMESHGUI::Modified();
6402   updateObjBrowser( true );
6403 }
6404
6405
6406 /*!
6407   \brief Signal handler closing(SUIT_ViewWindow*) of a view
6408   \param pview view being closed
6409 */
6410 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6411 #ifndef DISABLE_PLOT2DVIEWER
6412   //Crear all Plot2d Viewers if need.
6413   SMESH::ClearPlot2Viewers(pview);
6414 #endif
6415 }
6416
6417 void SMESHGUI::message( const QString& msg )
6418 {
6419   // dispatch message
6420   QStringList data = msg.split("/");
6421   if ( data.count() > 0 ) {
6422     if ( data.first() == "mesh_loading" ) {
6423       // get mesh entry
6424       QString entry = data.count() > 1 ? data[1] : QString();
6425       if ( entry.isEmpty() )
6426         return;
6427       // get study
6428       _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6429       // get mesh name
6430       _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6431       QString name;
6432       if ( obj )
6433         name = obj->GetName().c_str();
6434       if ( name.isEmpty() )
6435         return;
6436
6437       if ( data.last() == "stop" )
6438         application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6439       else
6440         application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6441       QApplication::processEvents();
6442     }
6443   }
6444 }
6445
6446 /*!
6447   \brief Connects or disconnects signals about activating and cloning view on the module slots
6448   \param pview view which is connected/disconnected
6449 */
6450 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6451   if(!pview)
6452     return;
6453
6454   SUIT_ViewManager* viewMgr = pview->getViewManager();
6455   if ( viewMgr ) {
6456     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6457                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6458
6459     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6460              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6461   }
6462 }
6463
6464 /*!
6465   \brief Return \c true if object can be renamed
6466 */
6467 bool SMESHGUI::renameAllowed( const QString& entry) const {
6468   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6469   if( !anApp )
6470     return false;
6471
6472   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6473   if( !appStudy )
6474     return false;
6475
6476   SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6477
6478   if(!obj)
6479     return false;
6480
6481   if(appStudy->isComponent(entry) || obj->isReference())
6482     return false;
6483
6484   // check type to prevent renaming of inappropriate objects
6485   int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6486   if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6487       aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6488       aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6489       aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6490       aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6491     return true;
6492
6493   return false;
6494 }
6495
6496 /*!
6497   Rename object by entry.
6498   \param entry entry of the object
6499   \param name new name of the object
6500   \brief Return \c true if rename operation finished successfully, \c false otherwise.
6501 */
6502 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6503
6504   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6505   if( !anApp )
6506     return false;
6507
6508   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6509
6510   if(!appStudy)
6511     return false;
6512
6513   _PTR(Study) aStudy = appStudy->studyDS();
6514
6515   if(!aStudy)
6516     return false;
6517
6518   bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6519   if ( aLocked ) {
6520     SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6521     return false;
6522   }
6523
6524
6525   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6526   _PTR(GenericAttribute) anAttr;
6527   _PTR(AttributeName) aName;
6528   if ( obj ) {
6529     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6530       aName = anAttr;
6531       // check type to prevent renaming of inappropriate objects
6532       int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6533       if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6534           aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6535           aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6536           aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6537           aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6538         if ( !name.isEmpty() ) {
6539           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6540
6541           // update name of group object and its actor
6542           Handle(SALOME_InteractiveObject) IObject =
6543             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6544
6545           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6546           if( !aGroupObject->_is_nil() ) {
6547             aGroupObject->SetName( qPrintable(name) );
6548             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6549               anActor->setName( qPrintable(name) );
6550           }
6551           return true;
6552         }
6553       }
6554     }
6555   }
6556   return false;
6557 }
6558
6559
6560 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6561 {
6562   static QList<QColor> colors;
6563
6564   if ( colors.isEmpty() ) {
6565
6566     for (int s = 0; s < 2 ; s++)
6567     {
6568       for (int v = 100; v >= 40; v = v - 20)
6569       {
6570         for (int h = 0; h < 359 ; h = h + 60)
6571         {
6572           colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
6573         }
6574       }
6575     }
6576   }
6577   static int currentColor = 0;
6578
6579   SALOMEDS::Color color;
6580   color.R = (double)colors[currentColor].red()   / 255.0;
6581   color.G = (double)colors[currentColor].green() / 255.0;
6582   color.B = (double)colors[currentColor].blue()  / 255.0;
6583
6584   currentColor = (currentColor+1) % colors.count();
6585
6586   return color;
6587 }