src/SMESHGUI/SMESHGUI.cxx

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