src/SMESHGUI/SMESHGUI.cxx

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