src/SMESHGUI/SMESHGUI.cxx

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