src/SMESHGUI/SMESHGUI.cxx

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