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