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 #include "SMESHGUI_DisplayEntitiesDlg.h"
  85
  86 #include "SMESHGUI_FilterUtils.h"
  87 #include "SMESHGUI_GEOMGenUtils.h"
  88 #include "SMESHGUI_GroupUtils.h"
  89 #include "SMESHGUI_HypothesesUtils.h"
  90 #include "SMESHGUI_MeshUtils.h"
  91 #include "SMESHGUI_PatternUtils.h"
  92 #include "SMESHGUI_Utils.h"
  93 #include "SMESHGUI_VTKUtils.h"
  94
  95 #include <SMESH_version.h>
  96
  97 #include "SMESH_ControlsDef.hxx"
  98 #include <SMESH_Actor.h>
  99 #include <SMESH_ActorUtils.h>
 100 #include <SMESH_Client.hxx>
 101 #include <SMESH_ScalarBarActor.h>
 102 #include <SMESH_TypeFilter.hxx>
 103
 104 // SALOME GUI includes
 105 #include <SalomeApp_Application.h>
 106 #include <SalomeApp_CheckFileDlg.h>
 107 #include <SalomeApp_DataObject.h>
 108 #include <SalomeApp_Study.h>
 109 #include <SalomeApp_Tools.h>
 110
 111 #include <LightApp_DataOwner.h>
 112 #include <LightApp_NameDlg.h>
 113 #include <LightApp_Preferences.h>
 114 #include <LightApp_SelectionMgr.h>
 115 #include <LightApp_UpdateFlags.h>
 116
 117 #include <SVTK_ViewManager.h>
 118 #include <SVTK_ViewModel.h>
 119 #include <SVTK_ViewWindow.h>
 120
 121 #include <VTKViewer_Algorithm.h>
 122
 123 #include <PyInterp_Interp.h>
 124
 125 #include <SUIT_Desktop.h>
 126 #include <SUIT_FileDlg.h>
 127 #include <SUIT_MessageBox.h>
 128 #include <SUIT_OverrideCursor.h>
 129 #include <SUIT_ResourceMgr.h>
 130 #include <SUIT_Session.h>
 131
 132 #include <QtxPopupMgr.h>
 133 #include <QtxFontEdit.h>
 134
 135 #include <SALOME_ListIO.hxx>
 136
 137 #ifndef DISABLE_PLOT2DVIEWER
 138 #include <SPlot2d_ViewModel.h>
 139 #include <SPlot2d_Histogram.h>
 140 #endif
 141
 142 // IDL includes
 143 #include <SALOMEconfig.h>
 144 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
 145 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
 146 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
 147
 148 // Qt includes
 149 // #define       INCLUDE_MENUITEM_DEF // VSR commented ????????
 150 #include <QApplication>
 151 #include <QMenu>
 152 #include <QTextStream>
 153
 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   // Choose entities to be displayed
2520   case SMESHOp::OpDEChoose:
2521     {
2522       ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2523       break;
2524     }
2525
2526   case SMESHOp::OpOrientationOnFaces:
2527     {
2528       LightApp_SelectionMgr* mgr = selectionMgr();
2529       SALOME_ListIO selected; mgr->selectedObjects( selected );
2530
2531       SALOME_ListIteratorOfListIO it(selected);
2532       for( ; it.More(); it.Next()) {
2533         Handle(SALOME_InteractiveObject) anIObject = it.Value();
2534         if(anIObject->hasEntry()) {
2535           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2536             anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2537           }
2538         }
2539       }
2540       break;
2541     }
2542
2543   case SMESHOp::OpUpdate:
2544     {
2545       if(checkLock(aStudy)) break;
2546       SUIT_OverrideCursor wc;
2547       try {
2548 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2549         OCC_CATCH_SIGNALS;
2550 #endif
2551         SMESH::UpdateView();
2552       }
2553       catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2554         SMESH::OnVisuException();
2555       }
2556       catch (...) { // PAL16774 (Crash after display of many groups)
2557         SMESH::OnVisuException();
2558       }
2559
2560       SALOME_ListIO l;
2561       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2562       aSel->selectedObjects( l );
2563       aSel->setSelectedObjects( l );
2564       break;
2565     }
2566
2567   case SMESHOp::OpHide:
2568   case SMESHOp::OpShow:
2569   case SMESHOp::OpShowOnly:
2570     {
2571       SMESH::EDisplaing anAction;
2572       switch (theCommandID) {
2573       case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2574       case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2575       case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2576       }
2577
2578       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2579       SALOME_ListIO sel_objects, to_process;
2580       if (aSel)
2581         aSel->selectedObjects( sel_objects );
2582
2583       if( theCommandID==SMESHOp::OpShowOnly )
2584       {
2585         MESSAGE("anAction = SMESH::eDisplayOnly");
2586         startOperation( myEraseAll );
2587       }
2588
2589       extractContainers( sel_objects, to_process );
2590
2591       try {
2592 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2593         OCC_CATCH_SIGNALS;
2594 #endif
2595         if (vtkwnd) {
2596           SALOME_ListIteratorOfListIO It( to_process );
2597           for ( ; It.More(); It.Next()) {
2598             MESSAGE("---");
2599             Handle(SALOME_InteractiveObject) IOS = It.Value();
2600             if (IOS->hasEntry()) {
2601               MESSAGE("---");
2602               if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2603                 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2604                 break; // PAL16774 (Crash after display of many groups)
2605               }
2606               if (anAction == SMESH::eDisplayOnly)
2607               {
2608                 MESSAGE("anAction = SMESH::eDisplayOnly");
2609                 anAction = SMESH::eDisplay;
2610               }
2611             }
2612           }
2613         }
2614
2615         // PAL13338 + PAL15161 -->
2616         if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2617           MESSAGE("anAction = SMESH::eDisplayOnly");
2618           SMESH::UpdateView();
2619           SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2620         }
2621         // PAL13338 + PAL15161 <--
2622       }
2623       catch (...) { // PAL16774 (Crash after display of many groups)
2624         SMESH::OnVisuException();
2625       }
2626
2627       if (anAction == SMESH::eErase) {
2628         MESSAGE("anAction == SMESH::eErase");
2629         SALOME_ListIO l1;
2630         aSel->setSelectedObjects( l1 );
2631       }
2632       else
2633         aSel->setSelectedObjects( to_process );
2634
2635       break;
2636     }
2637
2638   case SMESHOp::OpNode:
2639     {
2640       if(checkLock(aStudy)) break;
2641
2642       if ( vtkwnd ) {
2643         EmitSignalDeactivateDialog();
2644
2645         ( new SMESHGUI_NodesDlg( this ) )->show();
2646       }
2647       else {
2648         SUIT_MessageBox::warning(desktop(),
2649                                  tr("SMESH_WRN_WARNING"),
2650                                  tr("SMESH_WRN_VIEWER_VTK"));
2651       }
2652       break;
2653     }
2654
2655   case SMESHOp::OpCreateMesh:
2656   case SMESHOp::OpCreateSubMesh:
2657   case SMESHOp::OpEditMeshOrSubMesh:
2658   case SMESHOp::OpCompute:
2659   case SMESHOp::OpPreCompute:
2660   case SMESHOp::OpEvaluate:
2661   case SMESHOp::OpMeshOrder:
2662     startOperation( theCommandID );
2663     break;
2664   case SMESHOp::OpCopyMesh:
2665     {
2666       if (checkLock(aStudy)) break;
2667       EmitSignalDeactivateDialog();
2668       ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2669     }
2670     break;
2671   case SMESHOp::OpBuildCompoundMesh:
2672     {
2673       if (checkLock(aStudy)) break;
2674       EmitSignalDeactivateDialog();
2675       ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2676     }
2677     break;
2678
2679   case SMESHOp::OpDiagonalInversion:
2680   case SMESHOp::OpUnionOfTwoTriangle:
2681     {
2682       if ( !vtkwnd )
2683       {
2684         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2685                                   tr( "NOT_A_VTK_VIEWER" ) );
2686         break;
2687       }
2688
2689       if ( checkLock( aStudy ) )
2690         break;
2691
2692       /*Standard_Boolean aRes;
2693       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2694       if ( aMesh->_is_nil() )
2695       {
2696         SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2697           tr( "SMESH_BAD_SELECTION" ) );
2698         break;
2699       }
2700       */
2701       EmitSignalDeactivateDialog();
2702       if ( theCommandID == SMESHOp::OpDiagonalInversion )
2703         ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2704       else
2705         ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2706       break;
2707     }
2708   case SMESHOp::OpOrientation:
2709   case SMESHOp::OpUnionOfTriangles:
2710   case SMESHOp::OpCuttingOfQuadrangles:
2711   case SMESHOp::OpSplitVolumes:
2712     {
2713       if ( !vtkwnd )
2714       {
2715         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2716                                   tr( "NOT_A_VTK_VIEWER" ) );
2717         break;
2718       }
2719
2720       if ( checkLock( aStudy ) )
2721         break;
2722
2723       EmitSignalDeactivateDialog();
2724       SMESHGUI_MultiEditDlg* aDlg = NULL;
2725       if ( theCommandID == SMESHOp::OpOrientation )
2726         aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2727       else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2728         aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2729       else if ( theCommandID == SMESHOp::OpSplitVolumes )
2730         aDlg = new SMESHGUI_SplitVolumesDlg(this);
2731       else
2732         aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2733
2734       aDlg->show();
2735       break;
2736     }
2737   case SMESHOp::OpSmoothing:
2738     {
2739       if(checkLock(aStudy)) break;
2740       if( vtkwnd ) {
2741         EmitSignalDeactivateDialog();
2742         ( new SMESHGUI_SmoothingDlg( this ) )->show();
2743       }
2744       else {
2745         SUIT_MessageBox::warning(desktop(),
2746                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2747       }
2748       break;
2749     }
2750   case SMESHOp::OpExtrusion:
2751     {
2752       if (checkLock(aStudy)) break;
2753       if (vtkwnd) {
2754         EmitSignalDeactivateDialog();
2755         ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2756       } else {
2757         SUIT_MessageBox::warning(desktop(),
2758                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2759       }
2760       break;
2761     }
2762   case SMESHOp::OpExtrusionAlongAPath:
2763     {
2764       if (checkLock(aStudy)) break;
2765       if (vtkwnd) {
2766         EmitSignalDeactivateDialog();
2767         ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2768       } else {
2769         SUIT_MessageBox::warning(desktop(),
2770                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2771       }
2772       break;
2773     }
2774   case SMESHOp::OpRevolution:
2775     {
2776       if(checkLock(aStudy)) break;
2777       if( vtkwnd ) {
2778         EmitSignalDeactivateDialog();
2779         ( new SMESHGUI_RevolutionDlg( this ) )->show();
2780       }
2781       else {
2782         SUIT_MessageBox::warning(desktop(),
2783                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2784       }
2785       break;
2786     }
2787   case SMESHOp::OpPatternMapping:
2788     {
2789       if ( checkLock( aStudy ) )
2790         break;
2791       if ( vtkwnd )
2792       {
2793         EmitSignalDeactivateDialog();
2794         ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2795       }
2796       else {
2797         SUIT_MessageBox::warning(desktop(),
2798                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2799       }
2800       break;
2801     }
2802   case SMESHOp::OpConvertMeshToQuadratic:
2803   case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2804   case SMESHOp::OpReorientFaces:
2805   case SMESHOp::OpCreateGeometryGroup:
2806     {
2807       startOperation( theCommandID );
2808       break;
2809     }
2810   case SMESHOp::OpCreateGroup:
2811     {
2812       if ( !vtkwnd )
2813       {
2814         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2815                                   tr( "NOT_A_VTK_VIEWER" ) );
2816         break;
2817       }
2818
2819       if(checkLock(aStudy)) break;
2820       EmitSignalDeactivateDialog();
2821       SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2822
2823       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2824       SALOME_ListIO selected;
2825       if( aSel )
2826         aSel->selectedObjects( selected );
2827
2828       int nbSel = selected.Extent();
2829       if (nbSel == 1) {
2830         // check if mesh is selected
2831         aMesh = SMESH::GetMeshByIO( selected.First() );
2832       }
2833       SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2834       aDlg->show();
2835       break;
2836     }
2837
2838   case SMESHOp::OpConstructGroup:
2839     {
2840       if ( !vtkwnd )
2841       {
2842         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2843                                   tr( "NOT_A_VTK_VIEWER" ) );
2844         break;
2845       }
2846
2847       if(checkLock(aStudy)) break;
2848       EmitSignalDeactivateDialog();
2849
2850       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2851       SALOME_ListIO selected;
2852       if( aSel )
2853         aSel->selectedObjects( selected );
2854
2855       int nbSel = selected.Extent();
2856       if (nbSel == 1) {
2857         // check if submesh is selected
2858         Handle(SALOME_InteractiveObject) IObject = selected.First();
2859         if (IObject->hasEntry()) {
2860           _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2861           if( aSObj ) {
2862             SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2863             if (!aSubMesh->_is_nil()) {
2864               try {
2865                 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2866                 // get submesh elements list by types
2867                 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2868                 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2869                 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2870                 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2871                 // create group for each type o elements
2872                 QString aName = IObject->getName();
2873                 QStringList anEntryList;
2874                 if (aNodes->length() > 0) {
2875                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2876                   aGroup->Add(aNodes.inout());
2877                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2878                     anEntryList.append( aSObject->GetID().c_str() );
2879                 }
2880                 if (aEdges->length() > 0) {
2881                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2882                   aGroup->Add(aEdges.inout());
2883                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2884                     anEntryList.append( aSObject->GetID().c_str() );
2885                 }
2886                 if (aFaces->length() > 0) {
2887                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2888                   aGroup->Add(aFaces.inout());
2889                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2890                     anEntryList.append( aSObject->GetID().c_str() );
2891                 }
2892                 if (aVolumes->length() > 0) {
2893                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2894                   aGroup->Add(aVolumes.inout());
2895                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2896                     anEntryList.append( aSObject->GetID().c_str() );
2897                 }
2898                 updateObjBrowser();
2899                 anApp->browseObjects( anEntryList );
2900               }
2901               catch(const SALOME::SALOME_Exception & S_ex){
2902                 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2903               }
2904             }
2905           }
2906         }
2907       }
2908       else if(nbSel==0) {
2909         SUIT_MessageBox::warning(desktop(),
2910                                  tr("SMESH_WRN_WARNING"),
2911                                  tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2912       }
2913       break;
2914     }
2915
2916   case SMESHOp::OpEditGroup:
2917     {
2918       if ( !vtkwnd )
2919       {
2920         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2921                                   tr( "NOT_A_VTK_VIEWER" ) );
2922         break;
2923       }
2924
2925       if(checkLock(aStudy)) break;
2926       EmitSignalDeactivateDialog();
2927
2928       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2929       SALOME_ListIO selected;
2930       if( aSel )
2931         aSel->selectedObjects( selected );
2932
2933       SALOME_ListIteratorOfListIO It (selected);
2934       int nbSelectedGroups = 0;
2935       for ( ; It.More(); It.Next() )
2936       {
2937         SMESH::SMESH_GroupBase_var aGroup =
2938           SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2939         if (!aGroup->_is_nil()) {
2940           nbSelectedGroups++;
2941           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2942           aDlg->show();
2943         }
2944       }
2945       if (nbSelectedGroups == 0)
2946         {
2947           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2948           aDlg->show();
2949         }
2950       break;
2951     }
2952
2953   case SMESHOp::OpAddElemGroupPopup:     // Add elements to group
2954     {
2955       if(checkLock(aStudy)) break;
2956       if (myState == 800) {
2957         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2958         if (aDlg) aDlg->onAdd();
2959       }
2960       break;
2961     }
2962
2963   case SMESHOp::OpRemoveElemGroupPopup:  // Remove elements from group
2964     {
2965       if(checkLock(aStudy)) break;
2966       if (myState == 800) {
2967         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2968         if (aDlg) aDlg->onRemove();
2969       }
2970       break;
2971     }
2972
2973   case SMESHOp::OpEditGeomGroupAsGroup:
2974     {
2975       if ( !vtkwnd )
2976       {
2977         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2978                                   tr( "NOT_A_VTK_VIEWER" ) );
2979         break;
2980       }
2981
2982       if(checkLock(aStudy)) break;
2983       EmitSignalDeactivateDialog();
2984
2985       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2986       SALOME_ListIO selected;
2987       if( aSel )
2988         aSel->selectedObjects( selected );
2989
2990       SALOME_ListIteratorOfListIO It (selected);
2991       for ( ; It.More(); It.Next() )
2992       {
2993         SMESH::SMESH_GroupOnGeom_var aGroup =
2994           SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2995         if (!aGroup->_is_nil()) {
2996           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2997           aDlg->show();
2998         }
2999         else
3000         {
3001           SMESH::SMESH_GroupOnFilter_var aGroup =
3002             SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3003           if (!aGroup->_is_nil()) {
3004             SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3005             aDlg->show();
3006           }
3007         }
3008       }
3009       break;
3010     }
3011
3012     case SMESHOp::OpUnionGroups:
3013     case SMESHOp::OpIntersectGroups:
3014     case SMESHOp::OpCutGroups:
3015     {
3016       if ( !vtkwnd )
3017       {
3018         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3019                                   tr( "NOT_A_VTK_VIEWER" ) );
3020         break;
3021       }
3022
3023       if ( checkLock( aStudy ) )
3024         break;
3025
3026       EmitSignalDeactivateDialog();
3027
3028       SMESHGUI_GroupOpDlg* aDlg = 0;
3029       if ( theCommandID == SMESHOp::OpUnionGroups )
3030         aDlg = new SMESHGUI_UnionGroupsDlg( this );
3031       else if ( theCommandID == SMESHOp::OpIntersectGroups )
3032         aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3033       else
3034         aDlg = new SMESHGUI_CutGroupsDlg( this );
3035
3036       aDlg->show();
3037
3038       break;
3039     }
3040
3041     case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3042     {
3043       if ( checkLock( aStudy ) )
3044         break;
3045
3046       EmitSignalDeactivateDialog();
3047       SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3048       aDlg->show();
3049
3050       break;
3051     }
3052
3053     case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3054     {
3055       if ( !vtkwnd )
3056       {
3057         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3058                                   tr( "NOT_A_VTK_VIEWER" ) );
3059         break;
3060       }
3061
3062       if ( checkLock( aStudy ) )
3063         break;
3064
3065       EmitSignalDeactivateDialog();
3066
3067       ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3068       break;
3069     }
3070
3071   case SMESHOp::OpMeshInformation:
3072   case SMESHOp::OpWhatIs:
3073     {
3074       int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3075       EmitSignalDeactivateDialog();
3076       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3077       SALOME_ListIO selected;
3078       if( aSel )
3079         aSel->selectedObjects( selected );
3080
3081       if ( selected.Extent() > 1 ) { // a dlg for each IO
3082         SALOME_ListIteratorOfListIO It( selected );
3083         for ( ; It.More(); It.Next() ) {
3084           SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3085           dlg->showInfo( It.Value() );
3086           dlg->show();
3087         }
3088       }
3089       else {
3090         SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3091         dlg->show();
3092       }
3093       break;
3094     }
3095
3096   case SMESHOp::OpFindElementByPoint:
3097     {
3098       startOperation( theCommandID );
3099       break;
3100     }
3101
3102   case SMESHOp::OpEditHypothesis:
3103     {
3104       if(checkLock(aStudy)) break;
3105
3106       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3107       SALOME_ListIO selected;
3108       if( aSel )
3109         aSel->selectedObjects( selected );
3110
3111       int nbSel = selected.Extent();
3112
3113       if (nbSel == 1) {
3114         Handle(SALOME_InteractiveObject) anIObject = selected.First();
3115         SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3116
3117         if ( !aHypothesis->_is_nil() )
3118         {
3119           SMESHGUI_GenericHypothesisCreator* aCreator =
3120             SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3121           if (aCreator)
3122           {
3123             // set geometry of mesh and sub-mesh to aCreator
3124             aSel->selectedObjects( selected, "",  /*convertReferences=*/false);
3125             if ( selected.Extent() == 1 )
3126             {
3127               QString subGeomID, meshGeomID;
3128               Handle(SALOME_InteractiveObject) hypIO = selected.First();
3129               if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3130               {
3131                 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3132                 aCreator->setShapeEntry( subGeomID );
3133                 aCreator->setMainShapeEntry( meshGeomID );
3134               }
3135             }
3136
3137             aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3138           }
3139           else
3140           {
3141             // report error
3142           }
3143         }
3144       }
3145       break;
3146     }
3147   case SMESHOp::OpUnassign:                      // REMOVE HYPOTHESIS / ALGORITHMS
3148     {
3149       if(checkLock(aStudy)) break;
3150       SUIT_OverrideCursor wc;
3151
3152       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3153       SALOME_ListIO selected;
3154       if( aSel )
3155         aSel->selectedObjects( selected, QString::null, false );
3156
3157       SALOME_ListIteratorOfListIO It(selected);
3158       for (int i = 0; It.More(); It.Next(), i++) {
3159         Handle(SALOME_InteractiveObject) IObject = It.Value();
3160         SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3161       }
3162       SALOME_ListIO l1;
3163       aSel->setSelectedObjects( l1 );
3164       updateObjBrowser();
3165       break;
3166     }
3167
3168   case SMESHOp::OpElem0D:
3169   case SMESHOp::OpBall:
3170   case SMESHOp::OpEdge:
3171   case SMESHOp::OpTriangle:
3172   case SMESHOp::OpQuadrangle:
3173   case SMESHOp::OpPolygon:
3174   case SMESHOp::OpTetrahedron:
3175   case SMESHOp::OpHexahedron:
3176   case SMESHOp::OpPentahedron:
3177   case SMESHOp::OpPyramid:
3178   case SMESHOp::OpHexagonalPrism:
3179     {
3180       if(checkLock(aStudy)) break;
3181       if ( vtkwnd ) {
3182         EmitSignalDeactivateDialog();
3183         SMDSAbs_EntityType type = SMDSEntity_Edge;
3184         switch (theCommandID) {
3185         case SMESHOp::OpElem0D: type = SMDSEntity_0D;                      break;
3186         case SMESHOp::OpBall: type = SMDSEntity_Ball;                      break;
3187         case SMESHOp::OpTriangle: type = SMDSEntity_Triangle;              break;
3188         case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle;          break;
3189         case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra;              break;
3190         case SMESHOp::OpPolygon: type = SMDSEntity_Polygon;                break;
3191         case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa;                break;
3192         case SMESHOp::OpPentahedron: type = SMDSEntity_Penta;              break;
3193         case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid;                break;
3194         case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3195         default:;
3196         }
3197         ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3198       }
3199       else {
3200         SUIT_MessageBox::warning(desktop(),
3201                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3202       }
3203       break;
3204     }
3205   case SMESHOp::OpPolyhedron:
3206     {
3207       if(checkLock(aStudy)) break;
3208       if ( vtkwnd ) {
3209         EmitSignalDeactivateDialog();
3210         ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3211       }
3212       else {
3213         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3214                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3215       }
3216       break;
3217     }
3218   case SMESHOp::OpQuadraticEdge:
3219   case SMESHOp::OpQuadraticTriangle:
3220   case SMESHOp::OpBiQuadraticTriangle:
3221   case SMESHOp::OpQuadraticQuadrangle:
3222   case SMESHOp::OpBiQuadraticQuadrangle:
3223   case SMESHOp::OpQuadraticTetrahedron:
3224   case SMESHOp::OpQuadraticPyramid:
3225   case SMESHOp::OpQuadraticPentahedron:
3226   case SMESHOp::OpQuadraticHexahedron:
3227   case SMESHOp::OpTriQuadraticHexahedron:
3228     {
3229       if(checkLock(aStudy)) break;
3230       if ( vtkwnd ) {
3231         EmitSignalDeactivateDialog();
3232         SMDSAbs_EntityType type = SMDSEntity_Last;
3233
3234         switch (theCommandID) {
3235         case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3236         case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3237         case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3238         case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3239         case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3240         case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3241         case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3242         case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3243         case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3244         case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3245         default: break;
3246         }
3247         if ( type != SMDSEntity_Last )
3248           ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3249       }
3250       else {
3251         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3252                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3253       }
3254       break;
3255     }
3256   case SMESHOp::OpRemoveNodes:
3257     {
3258       if(checkLock(aStudy)) break;
3259       if ( vtkwnd ) {
3260         EmitSignalDeactivateDialog();
3261         ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3262       }
3263       else {
3264         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3265                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3266       }
3267       break;
3268     }
3269   case SMESHOp::OpRemoveElements:                                    // REMOVES ELEMENTS
3270     {
3271       if(checkLock(aStudy)) break;
3272       if( vtkwnd ) {
3273         EmitSignalDeactivateDialog();
3274         ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3275       }
3276       else
3277         {
3278           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3279                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3280         }
3281       break;
3282     }
3283   case SMESHOp::OpClearMesh: {
3284
3285     if(checkLock(aStudy)) break;
3286
3287     SALOME_ListIO selected;
3288     if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3289       aSel->selectedObjects( selected );
3290
3291     SUIT_OverrideCursor wc;
3292     SALOME_ListIteratorOfListIO It (selected);
3293     for ( ; It.More(); It.Next() )
3294     {
3295       Handle(SALOME_InteractiveObject) IOS = It.Value();
3296       SMESH::SMESH_Mesh_var aMesh =
3297         SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3298       if ( aMesh->_is_nil()) continue;
3299       try {
3300         SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3301         aMesh->Clear();
3302         _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3303         SMESH::ModifiedMesh( aMeshSObj, false, true);
3304         // hide groups and submeshes
3305         _PTR(ChildIterator) anIter =
3306           SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3307         for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3308         {
3309           _PTR(SObject) so = anIter->Value();
3310           SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3311         }
3312       }
3313       catch (const SALOME::SALOME_Exception& S_ex){
3314         wc.suspend();
3315         SalomeApp_Tools::QtCatchCorbaException(S_ex);
3316         wc.resume();
3317       }
3318     }
3319     SMESH::UpdateView();
3320     updateObjBrowser();
3321     break;
3322   }
3323   case SMESHOp::OpRemoveOrphanNodes:
3324     {
3325       if(checkLock(aStudy)) break;
3326       SALOME_ListIO selected;
3327       if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3328         aSel->selectedObjects( selected );
3329       if ( selected.Extent() == 1 ) {
3330         Handle(SALOME_InteractiveObject) anIO = selected.First();
3331         SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3332         if ( !aMesh->_is_nil() ) {
3333           bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3334                                                     tr( "SMESH_WARNING" ),
3335                                                     tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3336                                                     SUIT_MessageBox::Yes |
3337                                                     SUIT_MessageBox::No,
3338                                                     SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3339           if( confirm ) {
3340             try {
3341               SUIT_OverrideCursor wc;
3342               SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3343               int removed = aMeshEditor->RemoveOrphanNodes();
3344               SUIT_MessageBox::information(SMESHGUI::desktop(),
3345                                            tr("SMESH_INFORMATION"),
3346                                            tr("NB_NODES_REMOVED").arg(removed));
3347               if ( removed > 0 ) {
3348                 SMESH::UpdateView();
3349                 SMESHGUI::Modified();
3350               }
3351             }
3352             catch (const SALOME::SALOME_Exception& S_ex) {
3353               SalomeApp_Tools::QtCatchCorbaException(S_ex);
3354             }
3355             catch (...) {
3356             }
3357           }
3358         }
3359       }
3360       break;
3361     }
3362   case SMESHOp::OpRenumberingNodes:
3363     {
3364       if(checkLock(aStudy)) break;
3365       if( vtkwnd ) {
3366         EmitSignalDeactivateDialog();
3367         ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3368       }
3369       else
3370         {
3371           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3372                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3373         }
3374       break;
3375     }
3376   case SMESHOp::OpRenumberingElements:
3377     {
3378       if(checkLock(aStudy)) break;
3379       if ( vtkwnd ) {
3380         EmitSignalDeactivateDialog();
3381         ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3382       }
3383       else
3384         {
3385           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3386                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3387         }
3388       break;
3389     }
3390   case SMESHOp::OpTranslation:
3391     {
3392       if(checkLock(aStudy)) break;
3393       if ( vtkwnd ) {
3394         EmitSignalDeactivateDialog();
3395         ( new SMESHGUI_TranslationDlg( this ) )->show();
3396       }
3397       else {
3398         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3399                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3400       }
3401       break;
3402     }
3403   case SMESHOp::OpRotation:
3404     {
3405       if(checkLock(aStudy)) break;
3406       if( vtkwnd ) {
3407         EmitSignalDeactivateDialog();
3408         ( new SMESHGUI_RotationDlg( this ) )->show();
3409       }
3410       else {
3411         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3412                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3413       }
3414       break;
3415     }
3416   case SMESHOp::OpSymmetry:
3417     {
3418       if(checkLock(aStudy)) break;
3419       if(vtkwnd) {
3420         EmitSignalDeactivateDialog();
3421         ( new SMESHGUI_SymmetryDlg( this ) )->show();
3422       }
3423       else {
3424         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3425                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3426       }
3427       break;
3428     }
3429   case SMESHOp::OpScale:
3430     {
3431       if(checkLock(aStudy)) break;
3432       if ( vtkwnd ) {
3433         EmitSignalDeactivateDialog();
3434         ( new SMESHGUI_ScaleDlg( this ) )->show();
3435       }
3436       else {
3437         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3438                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3439       }
3440       break;
3441     }
3442
3443   case SMESHOp::OpSewing:
3444     {
3445       if(checkLock(aStudy)) break;
3446       if(vtkwnd) {
3447         EmitSignalDeactivateDialog();
3448         ( new SMESHGUI_SewingDlg( this ) )->show();
3449       }
3450       else {
3451         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3452                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3453       }
3454       break;
3455     }
3456   case SMESHOp::OpMergeNodes:
3457     {
3458       if(checkLock(aStudy)) break;
3459       if(vtkwnd) {
3460         EmitSignalDeactivateDialog();
3461         ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3462       }
3463       else {
3464         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3465                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3466       }
3467       break;
3468     }
3469   case SMESHOp::OpMergeElements:
3470     {
3471       if (checkLock(aStudy)) break;
3472       if (vtkwnd) {
3473         EmitSignalDeactivateDialog();
3474         ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3475       } else {
3476         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3477                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3478       }
3479       break;
3480     }
3481
3482   case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3483     startOperation( SMESHOp::OpMoveNode );
3484     break;
3485
3486   case SMESHOp::OpDuplicateNodes:
3487     {
3488       if(checkLock(aStudy)) break;
3489       if ( vtkwnd ) {
3490         EmitSignalDeactivateDialog();
3491         ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3492       }
3493       else {
3494         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3495                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3496       }
3497       break;
3498     }
3499
3500   case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3501     startOperation( SMESHOp::OpElem0DOnElemNodes );
3502     break;
3503
3504   case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3505   {
3506     static QList<int> aTypes;
3507     if ( aTypes.isEmpty() )
3508     {
3509       aTypes.append( SMESH::NODE );
3510       aTypes.append( SMESH::EDGE );
3511       aTypes.append( SMESH::FACE );
3512       aTypes.append( SMESH::VOLUME );
3513     }
3514     if (!myFilterLibraryDlg)
3515       myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3516     else if (myFilterLibraryDlg->isHidden())
3517       myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3518     myFilterLibraryDlg->raise();
3519   }
3520   break;
3521   // CONTROLS
3522   case SMESHOp::OpFreeNode:
3523   case SMESHOp::OpEqualNode:
3524   case SMESHOp::OpFreeEdge:
3525   case SMESHOp::OpFreeBorder:
3526   case SMESHOp::OpLength:
3527   case SMESHOp::OpConnection:
3528   case SMESHOp::OpEqualEdge:
3529   case SMESHOp::OpFreeFace:
3530   case SMESHOp::OpBareBorderFace:
3531   case SMESHOp::OpOverConstrainedFace:
3532   case SMESHOp::OpLength2D:
3533   case SMESHOp::OpConnection2D:
3534   case SMESHOp::OpArea:
3535   case SMESHOp::OpTaper:
3536   case SMESHOp::OpAspectRatio:
3537   case SMESHOp::OpMinimumAngle:
3538   case SMESHOp::OpWarpingAngle:
3539   case SMESHOp::OpSkew:
3540   case SMESHOp::OpMaxElementLength2D:
3541   case SMESHOp::OpEqualFace:
3542   case SMESHOp::OpAspectRatio3D:
3543   case SMESHOp::OpVolume:
3544   case SMESHOp::OpMaxElementLength3D:
3545   case SMESHOp::OpBareBorderVolume:
3546   case SMESHOp::OpOverConstrainedVolume:
3547   case SMESHOp::OpEqualVolume:
3548     if ( vtkwnd ) {
3549
3550       LightApp_SelectionMgr* mgr = selectionMgr();
3551       SALOME_ListIO selected; mgr->selectedObjects( selected );
3552
3553       if( !selected.IsEmpty() ) {
3554         SUIT_OverrideCursor wc;
3555         ::Control( theCommandID );
3556         break;
3557       }
3558       SUIT_MessageBox::warning(desktop(),
3559                                tr( "SMESH_WRN_WARNING" ),
3560                                tr( "SMESH_BAD_SELECTION" ) );
3561       break;
3562     }
3563     else {
3564       SUIT_MessageBox::warning(desktop(),
3565                                tr( "SMESH_WRN_WARNING" ),
3566                                tr( "NOT_A_VTK_VIEWER" ) );
3567     }
3568     break;
3569   case SMESHOp::OpOverallMeshQuality:
3570     OverallMeshQuality();
3571     break;
3572   case SMESHOp::OpNumberingNodes:
3573     {
3574       SUIT_OverrideCursor wc;
3575       LightApp_SelectionMgr* mgr = selectionMgr();
3576       SALOME_ListIO selected; mgr->selectedObjects( selected );
3577
3578       SALOME_ListIteratorOfListIO it(selected);
3579       for( ; it.More(); it.Next()) {
3580         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3581         if(anIObject->hasEntry()) {
3582           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3583             anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3584           }
3585         }
3586       }
3587       break;
3588     }
3589   case SMESHOp::OpNumberingElements:
3590     {
3591       SUIT_OverrideCursor wc;
3592       LightApp_SelectionMgr* mgr = selectionMgr();
3593       SALOME_ListIO selected; mgr->selectedObjects( selected );
3594
3595       SALOME_ListIteratorOfListIO it(selected);
3596       for( ; it.More(); it.Next()) {
3597         Handle(SALOME_InteractiveObject) anIObject = it.Value();
3598         if(anIObject->hasEntry())
3599           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3600             anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3601           }
3602       }
3603       break;
3604     }
3605   case SMESHOp::OpPropertiesLength:
3606   case SMESHOp::OpPropertiesArea:
3607   case SMESHOp::OpPropertiesVolume:
3608   case SMESHOp::OpMinimumDistance:
3609   case SMESHOp::OpBoundingBox:
3610     {
3611       int page = SMESHGUI_MeasureDlg::MinDistance;
3612       if ( theCommandID == SMESHOp::OpBoundingBox )
3613         page = SMESHGUI_MeasureDlg::BoundingBox;
3614       else if ( theCommandID == SMESHOp::OpPropertiesLength )
3615         page = SMESHGUI_MeasureDlg::Length;
3616       else if ( theCommandID == SMESHOp::OpPropertiesArea )
3617         page = SMESHGUI_MeasureDlg::Area;
3618       else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3619         page = SMESHGUI_MeasureDlg::Volume;
3620
3621       EmitSignalDeactivateDialog();
3622       SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3623       dlg->show();
3624       break;
3625     }
3626   case SMESHOp::OpSortChild:
3627     ::sortChildren();
3628     break;
3629
3630   }
3631
3632   anApp->updateActions(); //SRN: To update a Save button in the toolbar
3633   //updateObjBrowser();
3634   return true;
3635 }
3636
3637 //=============================================================================
3638 /*!
3639  *
3640  */
3641 //=============================================================================
3642 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3643 {
3644   return false;
3645 }
3646
3647 //=============================================================================
3648 /*!
3649  *
3650  */
3651 //=============================================================================
3652 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3653 {
3654   return true;
3655 }
3656
3657 //=============================================================================
3658 /*!
3659  *
3660  */
3661 //=============================================================================
3662 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3663 {
3664   return true;
3665 }
3666
3667 //=============================================================================
3668 /*! Method:  BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3669  *  Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3670  */
3671 //=============================================================================
3672 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3673                                   SUIT_ViewWindow* wnd )
3674 {
3675   if(theIO->hasEntry()){
3676     //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3677     SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3678   }
3679 }
3680
3681 //=======================================================================
3682 // function : createSMESHAction
3683 // purpose  :
3684 //=======================================================================
3685 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3686                                   const int key, const bool toggle, const QString& shortcutAction  )
3687 {
3688   QIcon icon;
3689   QWidget* parent = application()->desktop();
3690   SUIT_ResourceMgr* resMgr = resourceMgr();
3691   QPixmap pix;
3692   if ( !icon_id.isEmpty() )
3693     pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3694   else
3695     pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3696   if ( !pix.isNull() )
3697     icon = QIcon( pix );
3698
3699   QString tooltip    = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3700           menu       = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3701           status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3702
3703   createAction( id, tooltip, icon, menu, status_bar, key, parent,
3704                 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3705 }
3706
3707 //=======================================================================
3708 // function : createPopupItem
3709 // purpose  :
3710 //=======================================================================
3711 void SMESHGUI::createPopupItem( const int id,
3712                                 const QString& clients,
3713                                 const QString& types,
3714                                 const QString& theRule,
3715                                 const int pId )
3716 {
3717   if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3718     popupMgr()->insert( action( id ), pId, 0 );
3719
3720   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
3721   QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3722   QString rule = "(%1) and (%2) and (%3)";
3723   rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3724   if( clients.isEmpty() )
3725     rule = rule.arg( QString( "true" ) );
3726   else
3727     rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3728   rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3729   rule += theRule;
3730
3731   bool cont = myRules.contains( id );
3732   if( cont )
3733     rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3734
3735   popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3736   myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3737 }
3738
3739 //=======================================================================
3740 // function : initialize
3741 // purpose  :
3742 //=======================================================================
3743 void SMESHGUI::initialize( CAM_Application* app )
3744 {
3745   SalomeApp_Module::initialize( app );
3746
3747 //   SUIT_ResourceMgr* mgr = app->resourceMgr();
3748 //   if ( mgr )
3749   /* Automatic Update flag */
3750 //     myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3751
3752   // ----- create actions --------------
3753
3754   //createSMESHAction(  SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3755   createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3756   createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3757   //createSMESHAction(  114, "NUM" );
3758   createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL"  );
3759 #ifdef WITH_CGNS
3760   createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3761 #endif
3762   createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3763   createSMESHAction( SMESHOp::OpImportGMF,  "IMPORT_GMF"  );
3764   createSMESHAction( SMESHOp::OpExportDAT,  "DAT" );
3765   createSMESHAction( SMESHOp::OpExportMED,  "MED" );
3766   createSMESHAction( SMESHOp::OpExportUNV,  "UNV" );
3767   createSMESHAction( SMESHOp::OpExportSTL,  "STL" );
3768 #ifdef WITH_CGNS
3769   createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3770 #endif
3771   createSMESHAction( SMESHOp::OpExportSAUV,     "SAUV");
3772   createSMESHAction( SMESHOp::OpExportGMF,      "GMF" );
3773   createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3774   createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3775   createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3776   createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3777 #ifdef WITH_CGNS
3778   createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3779 #endif
3780   createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3781   createSMESHAction( SMESHOp::OpPopupExportGMF,  "GMF" );
3782   createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3783   createSMESHAction( SMESHOp::OpDelete,          "DELETE", "ICON_DELETE", Qt::Key_Delete );
3784   createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3785   createSMESHAction( SMESHOp::OpCreateMesh,           "CREATE_MESH",             "ICON_DLG_INIT_MESH" );
3786   createSMESHAction( SMESHOp::OpCreateSubMesh,        "CREATE_SUBMESH",          "ICON_DLG_ADD_SUBMESH" );
3787   createSMESHAction( SMESHOp::OpEditMeshOrSubMesh,    "EDIT_MESHSUBMESH",        "ICON_DLG_EDIT_MESH" );
3788   createSMESHAction( SMESHOp::OpBuildCompoundMesh,    "BUILD_COMPOUND",          "ICON_BUILD_COMPOUND" );
3789   createSMESHAction( SMESHOp::OpCopyMesh,             "COPY_MESH",               "ICON_COPY_MESH" );
3790   createSMESHAction( SMESHOp::OpCompute,              "COMPUTE",                 "ICON_COMPUTE" );
3791   createSMESHAction( SMESHOp::OpPreCompute,           "PRECOMPUTE",              "ICON_PRECOMPUTE" );
3792   createSMESHAction( SMESHOp::OpEvaluate,             "EVALUATE",                "ICON_COMPUTE" );
3793   createSMESHAction( SMESHOp::OpMeshOrder,            "MESH_ORDER",              "ICON_COMPUTE" );
3794   createSMESHAction( SMESHOp::OpCreateGroup,          "CREATE_GROUP",            "ICON_CREATE_GROUP" );
3795   createSMESHAction( SMESHOp::OpCreateGeometryGroup,  "CREATE_GEO_GROUP",        "ICON_CREATE_GEO_GROUP" );
3796   createSMESHAction( SMESHOp::OpConstructGroup,       "CONSTRUCT_GROUP",         "ICON_CONSTRUCT_GROUP" );
3797   createSMESHAction( SMESHOp::OpEditGroup,            "EDIT_GROUP",              "ICON_EDIT_GROUP" );
3798   createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3799   createSMESHAction( SMESHOp::OpUnionGroups,          "UN_GROUP",                "ICON_UNION" );
3800   createSMESHAction( SMESHOp::OpIntersectGroups,      "INT_GROUP",               "ICON_INTERSECT" );
3801   createSMESHAction( SMESHOp::OpCutGroups,            "CUT_GROUP",               "ICON_CUT" );
3802   createSMESHAction( SMESHOp::OpGroupUnderlyingElem,  "UNDERLYING_ELEMS",        "ICON_UNDERLYING_ELEMS" );
3803   createSMESHAction( SMESHOp::OpAddElemGroupPopup,    "ADD" );
3804   createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3805   createSMESHAction( SMESHOp::OpDeleteGroup,          "DEL_GROUP",               "ICON_DEL_GROUP" );
3806   createSMESHAction( SMESHOp::OpMeshInformation ,     "ADV_INFO",                "ICON_ADV_INFO" );
3807   //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO",        "ICON_STD_INFO" );
3808   //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS",         "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3809   createSMESHAction( SMESHOp::OpFindElementByPoint,   "FIND_ELEM",               "ICON_FIND_ELEM" );
3810   //update
3811   createSMESHAction( SMESHOp::OpFreeNode,              "FREE_NODE",               "ICON_FREE_NODE",     0, true );
3812   createSMESHAction( SMESHOp::OpEqualNode,             "EQUAL_NODE",              "ICON_EQUAL_NODE",    0, true );
3813   createSMESHAction( SMESHOp::OpFreeEdge,              "FREE_EDGE",               "ICON_FREE_EDGE",     0, true );
3814   createSMESHAction( SMESHOp::OpFreeBorder,            "FREE_BORDER",             "ICON_FREE_EDGE_2D",  0, true );
3815   createSMESHAction( SMESHOp::OpLength,                "LENGTH",                  "ICON_LENGTH",        0, true );
3816   createSMESHAction( SMESHOp::OpConnection,            "CONNECTION",              "ICON_CONNECTION",    0, true );
3817   createSMESHAction( SMESHOp::OpEqualEdge,             "EQUAL_EDGE",              "ICON_EQUAL_EDGE",    0, true );
3818   createSMESHAction( SMESHOp::OpFreeFace,              "FREE_FACES",              "ICON_FREE_FACES",    0, true );
3819   createSMESHAction( SMESHOp::OpBareBorderFace,        "BARE_BORDER_FACE",        "ICON_BARE_BORDER_FACE",        0, true );
3820   createSMESHAction( SMESHOp::OpOverConstrainedFace,   "OVER_CONSTRAINED_FACE",   "ICON_OVER_CONSTRAINED_FACE",   0, true );
3821   createSMESHAction( SMESHOp::OpLength2D,              "LENGTH_2D",               "ICON_LENGTH_2D",     0, true );
3822   createSMESHAction( SMESHOp::OpConnection2D,          "CONNECTION_2D",           "ICON_CONNECTION_2D", 0, true );
3823   createSMESHAction( SMESHOp::OpArea,                  "AREA",                    "ICON_AREA",          0, true );
3824   createSMESHAction( SMESHOp::OpTaper,                 "TAPER",                   "ICON_TAPER",         0, true );
3825   createSMESHAction( SMESHOp::OpAspectRatio,           "ASPECT",                  "ICON_ASPECT",        0, true );
3826   createSMESHAction( SMESHOp::OpMinimumAngle,          "MIN_ANG",                 "ICON_ANGLE",         0, true );
3827   createSMESHAction( SMESHOp::OpWarpingAngle,          "WARP",                    "ICON_WARP",          0, true );
3828   createSMESHAction( SMESHOp::OpSkew,                  "SKEW",                    "ICON_SKEW",          0, true );
3829   createSMESHAction( SMESHOp::OpMaxElementLength2D,    "MAX_ELEMENT_LENGTH_2D",   "ICON_MAX_ELEMENT_LENGTH_2D",   0, true );
3830   createSMESHAction( SMESHOp::OpEqualFace,             "EQUAL_FACE",              "ICON_EQUAL_FACE",    0, true );
3831   createSMESHAction( SMESHOp::OpAspectRatio3D,         "ASPECT_3D",               "ICON_ASPECT_3D",     0, true );
3832   createSMESHAction( SMESHOp::OpVolume,                "VOLUME_3D",               "ICON_VOLUME_3D",     0, true );
3833   createSMESHAction( SMESHOp::OpMaxElementLength3D,    "MAX_ELEMENT_LENGTH_3D",   "ICON_MAX_ELEMENT_LENGTH_3D",   0, true );
3834   createSMESHAction( SMESHOp::OpBareBorderVolume,      "BARE_BORDER_VOLUME",      "ICON_BARE_BORDER_VOLUME",      0, true );
3835   createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3836   createSMESHAction( SMESHOp::OpEqualVolume,           "EQUAL_VOLUME",            "ICON_EQUAL_VOLUME",  0, true );
3837   createSMESHAction( SMESHOp::OpOverallMeshQuality,    "OVERALL_MESH_QUALITY" );
3838
3839   createSMESHAction( SMESHOp::OpNode,                   "NODE",            "ICON_DLG_NODE" );
3840   createSMESHAction( SMESHOp::OpElem0D,                 "ELEM0D",          "ICON_DLG_ELEM0D" );
3841   createSMESHAction( SMESHOp::OpElem0DOnElemNodes,      "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3842   createSMESHAction( SMESHOp::OpBall,                   "BALL",            "ICON_DLG_BALL" );
3843   createSMESHAction( SMESHOp::OpEdge,                   "EDGE",            "ICON_DLG_EDGE" );
3844   createSMESHAction( SMESHOp::OpTriangle,               "TRIANGLE",        "ICON_DLG_TRIANGLE" );
3845   createSMESHAction( SMESHOp::OpQuadrangle,             "QUAD",            "ICON_DLG_QUADRANGLE" );
3846   createSMESHAction( SMESHOp::OpPolygon,                "POLYGON",         "ICON_DLG_POLYGON" );
3847   createSMESHAction( SMESHOp::OpTetrahedron,            "TETRA",           "ICON_DLG_TETRAS" );
3848   createSMESHAction( SMESHOp::OpHexahedron,             "HEXA",            "ICON_DLG_HEXAS" );
3849   createSMESHAction( SMESHOp::OpPentahedron,            "PENTA",           "ICON_DLG_PENTA" );
3850   createSMESHAction( SMESHOp::OpPyramid ,               "PYRAMID",         "ICON_DLG_PYRAMID" );
3851   createSMESHAction( SMESHOp::OpHexagonalPrism,         "OCTA",            "ICON_DLG_OCTA" );
3852   createSMESHAction( SMESHOp::OpPolyhedron,             "POLYHEDRON",      "ICON_DLG_POLYHEDRON" );
3853   createSMESHAction( SMESHOp::OpQuadraticEdge,          "QUADRATIC_EDGE",          "ICON_DLG_QUADRATIC_EDGE" );
3854   createSMESHAction( SMESHOp::OpQuadraticTriangle,      "QUADRATIC_TRIANGLE",      "ICON_DLG_QUADRATIC_TRIANGLE" );
3855   createSMESHAction( SMESHOp::OpBiQuadraticTriangle,    "BIQUADRATIC_TRIANGLE",    "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3856   createSMESHAction( SMESHOp::OpQuadraticQuadrangle,    "QUADRATIC_QUADRANGLE",    "ICON_DLG_QUADRATIC_QUADRANGLE" );
3857   createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle,  "BIQUADRATIC_QUADRANGLE",  "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3858   createSMESHAction( SMESHOp::OpQuadraticTetrahedron,   "QUADRATIC_TETRAHEDRON",   "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3859   createSMESHAction( SMESHOp::OpQuadraticPyramid,       "QUADRATIC_PYRAMID",       "ICON_DLG_QUADRATIC_PYRAMID" );
3860   createSMESHAction( SMESHOp::OpQuadraticPentahedron,   "QUADRATIC_PENTAHEDRON",   "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3861   createSMESHAction( SMESHOp::OpQuadraticHexahedron,    "QUADRATIC_HEXAHEDRON",    "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3862   createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3863
3864   createSMESHAction( SMESHOp::OpRemoveNodes,       "REMOVE_NODES",          "ICON_DLG_REM_NODE" );
3865   createSMESHAction( SMESHOp::OpRemoveElements,    "REMOVE_ELEMENTS",       "ICON_DLG_REM_ELEMENT" );
3866   createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES",   "ICON_DLG_REM_ORPHAN_NODES" );
3867   createSMESHAction( SMESHOp::OpClearMesh,         "CLEAR_MESH",            "ICON_CLEAR_MESH" );
3868
3869   //createSMESHAction( SMESHOp::OpRenumberingNodes,    "RENUM_NODES",     "ICON_DLG_RENUMBERING_NODES" );
3870   //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS",  "ICON_DLG_RENUMBERING_ELEMENTS" );
3871
3872   createSMESHAction( SMESHOp::OpTranslation,            "TRANS",           "ICON_SMESH_TRANSLATION_VECTOR" );
3873   createSMESHAction( SMESHOp::OpRotation,               "ROT",             "ICON_DLG_MESH_ROTATION" );
3874   createSMESHAction( SMESHOp::OpSymmetry,               "SYM",             "ICON_SMESH_SYMMETRY_PLANE" );
3875   createSMESHAction( SMESHOp::OpScale,                  "SCALE",           "ICON_DLG_MESH_SCALE" );
3876   createSMESHAction( SMESHOp::OpSewing,                 "SEW",             "ICON_SMESH_SEWING_FREEBORDERS" );
3877   createSMESHAction( SMESHOp::OpMergeNodes,             "MERGE",           "ICON_SMESH_MERGE_NODES" );
3878   createSMESHAction( SMESHOp::OpMergeElements,          "MERGE_ELEMENTS",  "ICON_DLG_MERGE_ELEMENTS" );
3879   createSMESHAction( SMESHOp::OpMoveNode,               "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3880   createSMESHAction( SMESHOp::OpDuplicateNodes,         "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3881   createSMESHAction( SMESHOp::OpDiagonalInversion,      "INV",             "ICON_DLG_MESH_DIAGONAL" );
3882   createSMESHAction( SMESHOp::OpUnionOfTwoTriangle,     "UNION2",          "ICON_UNION2TRI" );
3883   createSMESHAction( SMESHOp::OpOrientation,            "ORIENT",          "ICON_DLG_MESH_ORIENTATION" );
3884   createSMESHAction( SMESHOp::OpReorientFaces,          "REORIENT_2D",     "ICON_REORIENT_2D" );
3885   createSMESHAction( SMESHOp::OpUnionOfTriangles,       "UNION",           "ICON_UNIONTRI" );
3886   createSMESHAction( SMESHOp::OpCuttingOfQuadrangles,   "CUT",             "ICON_CUTQUAD" );
3887   createSMESHAction( SMESHOp::OpSplitVolumes,           "SPLIT_TO_TETRA",  "ICON_SPLIT_TO_TETRA" );
3888   createSMESHAction( SMESHOp::OpSmoothing,              "SMOOTH",          "ICON_DLG_SMOOTHING" );
3889   createSMESHAction( SMESHOp::OpExtrusion,              "EXTRUSION",       "ICON_EXTRUSION" );
3890   createSMESHAction( SMESHOp::OpExtrusionAlongAPath,    "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3891   createSMESHAction( SMESHOp::OpRevolution,             "REVOLUTION",      "ICON_REVOLUTION" );
3892   createSMESHAction( SMESHOp::OpPatternMapping,         "MAP",             "ICON_MAP" );
3893   createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD",    "ICON_CONV_TO_QUAD" );
3894   createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D",      "ICON_2D_FROM_3D" );
3895
3896   createSMESHAction( SMESHOp::OpReset,               "RESET" );
3897   createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3898   createSMESHAction( SMESHOp::OpSaveDistribution,    "SAVE_DISTRIBUTION" );
3899   createSMESHAction( SMESHOp::OpShowDistribution,    "SHOW_DISTRIBUTION","",0, true );
3900 #ifndef DISABLE_PLOT2DVIEWER
3901   createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3902 #endif
3903   createSMESHAction( SMESHOp::OpDMWireframe,  "WIRE",    "ICON_WIRE", 0, true );
3904   createSMESHAction( SMESHOp::OpDMShading,    "SHADE",   "ICON_SHADE", 0, true );
3905   createSMESHAction( SMESHOp::OpDMNodes,      "NODES",   "ICON_POINTS", 0, true );
3906   createSMESHAction( SMESHOp::OpDMShrink,     "SHRINK",  "ICON_SHRINK", 0, true );
3907   createSMESHAction( SMESHOp::OpUpdate,       "UPDATE",  "ICON_UPDATE" );
3908   createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3909   createSMESHAction( SMESHOp::OpDEEdges,      "EDGES",   "ICON_DLG_EDGE", 0, true );
3910   createSMESHAction( SMESHOp::OpDEFaces,      "FACES",   "ICON_DLG_TRIANGLE", 0, true );
3911   createSMESHAction( SMESHOp::OpDEVolumes,    "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3912   createSMESHAction( SMESHOp::OpDEBalls,      "BALLS",   "ICON_DLG_BALL", 0, true );
3913   createSMESHAction( SMESHOp::OpDEChoose,     "CHOOSE",  "ICON_DLG_CHOOSE", 0, false );
3914   createSMESHAction( SMESHOp::OpDEAllEntity,  "ALL",     "ICON_DLG_CHOOSE_ALL", 0, false );
3915   createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3916
3917   createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3918   createSMESHAction( SMESHOp::OpRepresentationArcs,  "ARC_REPRESENTATION", "", 0, true );
3919
3920   createSMESHAction( SMESHOp::OpEditHypothesis,    "EDIT_HYPO" );
3921   createSMESHAction( SMESHOp::OpUnassign,          "UNASSIGN" );
3922   createSMESHAction( SMESHOp::OpNumberingNodes,    "NUM_NODES", "", 0, true );
3923   createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3924   createSMESHAction( SMESHOp::OpProperties,   "COLORS" );
3925   createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3926   createSMESHAction( SMESHOp::OpClipping,     "CLIP" );
3927   createSMESHAction( SMESHOp::OpAutoColor,        "AUTO_COLOR" );
3928   createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3929
3930   createSMESHAction( SMESHOp::OpMinimumDistance,  "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3931   createSMESHAction( SMESHOp::OpBoundingBox,      "MEASURE_BND_BOX",  "ICON_MEASURE_BND_BOX" );
3932   createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH",   "ICON_MEASURE_LENGTH" );
3933   createSMESHAction( SMESHOp::OpPropertiesArea,   "MEASURE_AREA",     "ICON_MEASURE_AREA" );
3934   createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME",   "ICON_MEASURE_VOLUME" );
3935
3936   createSMESHAction( SMESHOp::OpHide,     "HIDE" );
3937   createSMESHAction( SMESHOp::OpShow,     "SHOW" );
3938   createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
3939
3940   createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
3941
3942   QList<int> aCtrlActions;
3943   aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode                           // node controls
3944                << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
3945                << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge    // edge controls
3946                << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
3947                << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
3948                << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
3949                << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
3950                << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace                // face controls
3951                << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
3952                << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
3953                << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume;           // volume controls
3954   QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
3955   aCtrlGroup->setExclusive( true );
3956   for( int i = 0; i < aCtrlActions.size(); i++ )
3957     aCtrlGroup->addAction( action( aCtrlActions[i] ) );
3958
3959   // ----- create menu --------------
3960   int fileId    = createMenu( tr( "MEN_FILE" ),    -1,  1 ),
3961       editId    = createMenu( tr( "MEN_EDIT" ),    -1,  3 ),
3962       toolsId   = createMenu( tr( "MEN_TOOLS" ),   -1,  5, 50 ),
3963       meshId    = createMenu( tr( "MEN_MESH" ),    -1, 70, 10 ),
3964       ctrlId    = createMenu( tr( "MEN_CTRL" ),    -1, 60, 10 ),
3965       modifyId  = createMenu( tr( "MEN_MODIFY" ),  -1, 40, 10 ),
3966       measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3967       viewId    = createMenu( tr( "MEN_VIEW" ),    -1,  2 );
3968
3969   createMenu( separator(), fileId );
3970
3971   int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3972       exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3973       nodeId   = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3974       edgeId   = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3975       faceId   = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3976       volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3977       addId    = createMenu( tr( "MEN_ADD" ),    modifyId, 402 ),
3978       removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3979     //renumId  = createMenu( tr( "MEN_RENUM" ),  modifyId, 404 ),
3980       transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
3981       basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
3982
3983   //createMenu( SMESHOp::OpImportDAT, importId, -1 );
3984   createMenu( SMESHOp::OpImportUNV,  importId, -1 );
3985   createMenu( SMESHOp::OpImportMED,  importId, -1 );
3986   createMenu( SMESHOp::OpImportSTL,  importId, -1 );
3987 #ifdef WITH_CGNS
3988   createMenu( SMESHOp::OpImportCGNS, importId, -1 );
3989 #endif
3990   createMenu( SMESHOp::OpImportSAUV, importId, -1 );
3991   createMenu( SMESHOp::OpImportGMF,  importId, -1 );
3992   createMenu( SMESHOp::OpExportDAT,  exportId, -1 );
3993   createMenu( SMESHOp::OpExportMED,  exportId, -1 );
3994   createMenu( SMESHOp::OpExportUNV,  exportId, -1 );
3995   createMenu( SMESHOp::OpExportSTL,  exportId, -1 );
3996 #ifdef WITH_CGNS
3997   createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
3998 #endif
3999   createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4000   createMenu( SMESHOp::OpExportGMF,  exportId, -1 );
4001   createMenu( separator(), fileId, 10 );
4002
4003   createMenu( SMESHOp::OpDelete, editId, -1 );
4004
4005   createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4006
4007   createMenu( SMESHOp::OpCreateMesh,           meshId, -1 ); // "Mesh" menu
4008   createMenu( SMESHOp::OpCreateSubMesh,        meshId, -1 );
4009   createMenu( SMESHOp::OpEditMeshOrSubMesh,    meshId, -1 );
4010   createMenu( SMESHOp::OpBuildCompoundMesh,    meshId, -1 );
4011   createMenu( SMESHOp::OpCopyMesh,             meshId, -1 );
4012   createMenu( separator(),                     meshId, -1 );
4013   createMenu( SMESHOp::OpCompute,              meshId, -1 );
4014   createMenu( SMESHOp::OpPreCompute,           meshId, -1 );
4015   createMenu( SMESHOp::OpEvaluate,             meshId, -1 );
4016   createMenu( SMESHOp::OpMeshOrder,            meshId, -1 );
4017   createMenu( separator(),                     meshId, -1 );
4018   createMenu( SMESHOp::OpCreateGroup,          meshId, -1 );
4019   createMenu( SMESHOp::OpCreateGeometryGroup,  meshId, -1 );
4020   createMenu( SMESHOp::OpConstructGroup,       meshId, -1 );
4021   createMenu( SMESHOp::OpEditGroup,            meshId, -1 );
4022   createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4023   createMenu( separator(),                     meshId, -1 );
4024   createMenu( SMESHOp::OpUnionGroups,          meshId, -1 );
4025   createMenu( SMESHOp::OpIntersectGroups,      meshId, -1 );
4026   createMenu( SMESHOp::OpCutGroups,            meshId, -1 );
4027   createMenu( separator(),                     meshId, -1 );
4028   createMenu( SMESHOp::OpGroupUnderlyingElem,  meshId, -1 );
4029   createMenu( separator(),                     meshId, -1 );
4030   createMenu( SMESHOp::OpMeshInformation,      meshId, -1 );
4031   //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4032   //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4033   createMenu( SMESHOp::OpFindElementByPoint,   meshId, -1 );
4034   createMenu( separator(),                     meshId, -1 );
4035
4036   createMenu( SMESHOp::OpFreeNode,              nodeId,   -1 );
4037   createMenu( SMESHOp::OpEqualNode,             nodeId,   -1 );
4038   createMenu( SMESHOp::OpFreeEdge,              edgeId,   -1 );
4039   createMenu( SMESHOp::OpFreeBorder,            edgeId,   -1 );
4040   createMenu( SMESHOp::OpLength,                edgeId,   -1 );
4041   createMenu( SMESHOp::OpConnection,            edgeId,   -1 );
4042   createMenu( SMESHOp::OpEqualEdge,             edgeId,   -1 );
4043   createMenu( SMESHOp::OpFreeFace,              faceId,   -1 );
4044   createMenu( SMESHOp::OpBareBorderFace,        faceId,   -1 );
4045   createMenu( SMESHOp::OpOverConstrainedFace,   faceId,   -1 );
4046   createMenu( SMESHOp::OpLength2D,              faceId,   -1 );
4047   createMenu( SMESHOp::OpConnection2D,          faceId,   -1 );
4048   createMenu( SMESHOp::OpArea,                  faceId,   -1 );
4049   createMenu( SMESHOp::OpTaper,                 faceId,   -1 );
4050   createMenu( SMESHOp::OpAspectRatio,           faceId,   -1 );
4051   createMenu( SMESHOp::OpMinimumAngle,          faceId,   -1 );
4052   createMenu( SMESHOp::OpWarpingAngle,          faceId,   -1 );
4053   createMenu( SMESHOp::OpSkew,                  faceId,   -1 );
4054   createMenu( SMESHOp::OpMaxElementLength2D,    faceId,   -1 );
4055   createMenu( SMESHOp::OpEqualFace,             faceId,   -1 );
4056   createMenu( SMESHOp::OpAspectRatio3D,         volumeId, -1 );
4057   createMenu( SMESHOp::OpVolume,                volumeId, -1 );
4058   createMenu( SMESHOp::OpMaxElementLength3D,    volumeId, -1 );
4059   createMenu( SMESHOp::OpBareBorderVolume,      volumeId, -1 );
4060   createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4061   createMenu( SMESHOp::OpEqualVolume,           volumeId, -1 );
4062   createMenu( separator(),                      ctrlId,   -1 );
4063   createMenu( SMESHOp::OpReset,                 ctrlId,   -1 );
4064   createMenu( separator(),                      ctrlId,   -1 );
4065   createMenu( SMESHOp::OpOverallMeshQuality,    ctrlId,   -1 );
4066
4067   createMenu( SMESHOp::OpNode,                   addId, -1 );
4068   createMenu( SMESHOp::OpElem0D,                 addId, -1 );
4069   createMenu( SMESHOp::OpElem0DOnElemNodes,      addId, -1 );
4070   createMenu( SMESHOp::OpBall,                   addId, -1 );
4071   createMenu( SMESHOp::OpEdge,                   addId, -1 );
4072   createMenu( SMESHOp::OpTriangle,               addId, -1 );
4073   createMenu( SMESHOp::OpQuadrangle,             addId, -1 );
4074   createMenu( SMESHOp::OpPolygon,                addId, -1 );
4075   createMenu( SMESHOp::OpTetrahedron,            addId, -1 );
4076   createMenu( SMESHOp::OpHexahedron,             addId, -1 );
4077   createMenu( SMESHOp::OpPentahedron,            addId, -1 );
4078   createMenu( SMESHOp::OpPyramid,                addId, -1 );
4079   createMenu( SMESHOp::OpHexagonalPrism,         addId, -1 );
4080   createMenu( SMESHOp::OpPolyhedron,             addId, -1 );
4081   createMenu( separator(),                       addId, -1 );
4082   createMenu( SMESHOp::OpQuadraticEdge,          addId, -1 );
4083   createMenu( SMESHOp::OpQuadraticTriangle,      addId, -1 );
4084   createMenu( SMESHOp::OpBiQuadraticTriangle ,   addId, -1 );
4085   createMenu( SMESHOp::OpQuadraticQuadrangle,    addId, -1 );
4086   createMenu( SMESHOp::OpBiQuadraticQuadrangle,  addId, -1 );
4087   createMenu( SMESHOp::OpQuadraticTetrahedron,   addId, -1 );
4088   createMenu( SMESHOp::OpQuadraticPyramid,       addId, -1 );
4089   createMenu( SMESHOp::OpQuadraticPentahedron,   addId, -1 );
4090   createMenu( SMESHOp::OpQuadraticHexahedron,    addId, -1 );
4091   createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4092
4093   createMenu( SMESHOp::OpRemoveNodes,       removeId, -1 );
4094   createMenu( SMESHOp::OpRemoveElements,    removeId, -1 );
4095   createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4096   createMenu( separator(),                  removeId, -1 );
4097   createMenu( SMESHOp::OpDeleteGroup,       removeId, -1 );
4098   createMenu( separator(),                  removeId, -1 );
4099   createMenu( SMESHOp::OpClearMesh,         removeId, -1 );
4100
4101   //createMenu( SMESHOp::OpRenumberingNodes,    renumId, -1 );
4102   //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4103
4104   createMenu( SMESHOp::OpTranslation,    transfId, -1 );
4105   createMenu( SMESHOp::OpRotation,       transfId, -1 );
4106   createMenu( SMESHOp::OpSymmetry,       transfId, -1 );
4107   createMenu( SMESHOp::OpScale,          transfId, -1 );
4108   createMenu( SMESHOp::OpSewing,         transfId, -1 );
4109   createMenu( SMESHOp::OpMergeNodes,     transfId, -1 );
4110   createMenu( SMESHOp::OpMergeElements,  transfId, -1 );
4111   createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4112
4113   createMenu( SMESHOp::OpMoveNode,               modifyId, -1 );
4114   createMenu( SMESHOp::OpDiagonalInversion,      modifyId, -1 );
4115   createMenu( SMESHOp::OpUnionOfTwoTriangle,     modifyId, -1 );
4116   createMenu( SMESHOp::OpOrientation,            modifyId, -1 );
4117   createMenu( SMESHOp::OpReorientFaces,          modifyId, -1 );
4118   createMenu( SMESHOp::OpUnionOfTriangles,       modifyId, -1 );
4119   createMenu( SMESHOp::OpCuttingOfQuadrangles,   modifyId, -1 );
4120   createMenu( SMESHOp::OpSplitVolumes,           modifyId, -1 );
4121   createMenu( SMESHOp::OpSmoothing,              modifyId, -1 );
4122   createMenu( SMESHOp::OpExtrusion,              modifyId, -1 );
4123   createMenu( SMESHOp::OpExtrusionAlongAPath ,   modifyId, -1 );
4124   createMenu( SMESHOp::OpRevolution,             modifyId, -1 );
4125   createMenu( SMESHOp::OpPatternMapping,         modifyId, -1 );
4126   createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4127   createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4128
4129   createMenu( SMESHOp::OpMinimumDistance,  measureId,   -1 );
4130   createMenu( SMESHOp::OpBoundingBox,      measureId,   -1 );
4131   createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4132   createMenu( SMESHOp::OpPropertiesArea,   basicPropId, -1 );
4133   createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4134   createMenu( SMESHOp::OpUpdate,           viewId,      -1 );
4135
4136   // ----- create toolbars --------------
4137   int meshTb       = createTool( tr( "TB_MESH" ),      QString( "SMESHMeshToolbar" ) ),
4138       info         = createTool( tr( "TB_INFO" ),      QString( "SMESHInformationToolbar" ) ),
4139       groupTb      = createTool( tr( "TB_GROUP" ),     QString( "SMESHGroupToolbar" ) ),
4140       ctrl0dTb     = createTool( tr( "TB_CTRL0D" ),    QString( "SMESHNodeControlsToolbar" ) ),
4141       ctrl1dTb     = createTool( tr( "TB_CTRL1D" ),    QString( "SMESHEdgeControlsToolbar" ) ),
4142       ctrl2dTb     = createTool( tr( "TB_CTRL2D" ),    QString( "SMESHFaceControlsToolbar" ) ),
4143       ctrl3dTb     = createTool( tr( "TB_CTRL3D" ),    QString( "SMESHVolumeControlsToolbar" ) ),
4144       addElemTb    = createTool( tr( "TB_ADD" ),       QString( "SMESHAddElementToolbar" ) ),
4145       addNonElemTb = createTool( tr( "TB_ADDNON" ),    QString( "SMESHAddElementToolbar" ) ),
4146       remTb        = createTool( tr( "TB_REM" ),       QString( "SMESHRemoveToolbar" ) ),
4147     //renumbTb     = createTool( tr( "TB_RENUMBER" ),  QString( "SMESHRenumberingToolbar" ) ),
4148       transformTb  = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4149       modifyTb     = createTool( tr( "TB_MODIFY" ),    QString( "SMESHModificationToolbar" ) ),
4150       measuremTb   = createTool( tr( "TB_MEASUREM" ),  QString( "SMESHMeasurementsToolbar" ) ),
4151       dispModeTb   = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4152
4153   createTool( SMESHOp::OpCreateMesh,        meshTb );
4154   createTool( SMESHOp::OpCreateSubMesh,     meshTb );
4155   createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4156   createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4157   createTool( SMESHOp::OpCopyMesh,          meshTb );
4158   createTool( separator(),                  meshTb );
4159   createTool( SMESHOp::OpCompute,           meshTb );
4160   createTool( SMESHOp::OpPreCompute,        meshTb );
4161   createTool( SMESHOp::OpEvaluate,          meshTb );
4162   createTool( SMESHOp::OpMeshOrder,         meshTb );
4163
4164   createTool( SMESHOp::OpCreateGroup,         groupTb );
4165   createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4166   createTool( SMESHOp::OpConstructGroup,      groupTb );
4167   createTool( SMESHOp::OpEditGroup,           groupTb );
4168
4169   createTool( SMESHOp::OpMeshInformation,    info );
4170   //createTool( SMESHOp::OpStdInfo, meshTb );
4171   //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4172   createTool( SMESHOp::OpFindElementByPoint, info );
4173
4174   createTool( SMESHOp::OpFreeNode,  ctrl0dTb );
4175   createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4176
4177   createTool( SMESHOp::OpFreeEdge,   ctrl1dTb );
4178   createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4179   createTool( SMESHOp::OpLength,     ctrl1dTb );
4180   createTool( SMESHOp::OpConnection, ctrl1dTb );
4181   createTool( SMESHOp::OpEqualEdge,  ctrl1dTb );
4182
4183   createTool( SMESHOp::OpFreeFace,            ctrl2dTb );
4184   createTool( SMESHOp::OpBareBorderFace,      ctrl2dTb );
4185   createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4186   createTool( SMESHOp::OpLength2D,            ctrl2dTb );
4187   createTool( SMESHOp::OpConnection2D,        ctrl2dTb );
4188   createTool( SMESHOp::OpArea,                ctrl2dTb );
4189   createTool( SMESHOp::OpTaper,               ctrl2dTb );
4190   createTool( SMESHOp::OpAspectRatio,         ctrl2dTb );
4191   createTool( SMESHOp::OpMinimumAngle,        ctrl2dTb );
4192   createTool( SMESHOp::OpWarpingAngle,        ctrl2dTb );
4193   createTool( SMESHOp::OpSkew,                ctrl2dTb );
4194   createTool( SMESHOp::OpMaxElementLength2D,  ctrl2dTb );
4195   createTool( SMESHOp::OpEqualFace,           ctrl2dTb );
4196
4197   createTool( SMESHOp::OpAspectRatio3D,         ctrl3dTb );
4198   createTool( SMESHOp::OpVolume,                ctrl3dTb );
4199   createTool( SMESHOp::OpMaxElementLength3D,    ctrl3dTb );
4200   createTool( SMESHOp::OpBareBorderVolume,      ctrl3dTb );
4201   createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4202   createTool( SMESHOp::OpEqualVolume,           ctrl3dTb );
4203
4204   createTool( SMESHOp::OpNode,              addElemTb );
4205   createTool( SMESHOp::OpElem0D,            addElemTb );
4206   createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4207   createTool( SMESHOp::OpBall,              addElemTb );
4208   createTool( SMESHOp::OpEdge,              addElemTb );
4209   createTool( SMESHOp::OpTriangle,          addElemTb );
4210   createTool( SMESHOp::OpQuadrangle,        addElemTb );
4211   createTool( SMESHOp::OpPolygon,           addElemTb );
4212   createTool( SMESHOp::OpTetrahedron,       addElemTb );
4213   createTool( SMESHOp::OpHexahedron,        addElemTb );
4214   createTool( SMESHOp::OpPentahedron,       addElemTb );
4215   createTool( SMESHOp::OpPyramid,           addElemTb );
4216   createTool( SMESHOp::OpHexagonalPrism,    addElemTb );
4217   createTool( SMESHOp::OpPolyhedron,        addElemTb );
4218
4219   createTool( SMESHOp::OpQuadraticEdge,          addNonElemTb );
4220   createTool( SMESHOp::OpQuadraticTriangle,      addNonElemTb );
4221   createTool( SMESHOp::OpBiQuadraticTriangle,    addNonElemTb );
4222   createTool( SMESHOp::OpQuadraticQuadrangle,    addNonElemTb );
4223   createTool( SMESHOp::OpBiQuadraticQuadrangle,  addNonElemTb );
4224   createTool( SMESHOp::OpQuadraticTetrahedron,   addNonElemTb );
4225   createTool( SMESHOp::OpQuadraticPyramid,       addNonElemTb );
4226   createTool( SMESHOp::OpQuadraticPentahedron,   addNonElemTb );
4227   createTool( SMESHOp::OpQuadraticHexahedron,    addNonElemTb );
4228   createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4229
4230   createTool( SMESHOp::OpRemoveNodes,       remTb );
4231   createTool( SMESHOp::OpRemoveElements,    remTb );
4232   createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4233   createTool( SMESHOp::OpClearMesh,         remTb );
4234
4235   //createTool( SMESHOp::OpRenumberingNodes,    renumbTb );
4236   //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4237
4238   createTool( SMESHOp::OpTranslation,    transformTb );
4239   createTool( SMESHOp::OpRotation,       transformTb );
4240   createTool( SMESHOp::OpSymmetry,       transformTb );
4241   createTool( SMESHOp::OpScale,          transformTb );
4242   createTool( SMESHOp::OpSewing,         transformTb );
4243   createTool( SMESHOp::OpMergeNodes,     transformTb );
4244   createTool( SMESHOp::OpMergeElements,  transformTb );
4245   createTool( SMESHOp::OpDuplicateNodes, transformTb );
4246
4247   createTool( SMESHOp::OpMoveNode,               modifyTb );
4248   createTool( SMESHOp::OpDiagonalInversion,      modifyTb );
4249   createTool( SMESHOp::OpUnionOfTwoTriangle,     modifyTb );
4250   createTool( SMESHOp::OpOrientation,            modifyTb );
4251   createTool( SMESHOp::OpReorientFaces,          modifyTb );
4252   createTool( SMESHOp::OpUnionOfTriangles,       modifyTb );
4253   createTool( SMESHOp::OpCuttingOfQuadrangles,   modifyTb );
4254   createTool( SMESHOp::OpSplitVolumes,           modifyTb );
4255   createTool( SMESHOp::OpSmoothing,              modifyTb );
4256   createTool( SMESHOp::OpExtrusion,              modifyTb );
4257   createTool( SMESHOp::OpExtrusionAlongAPath,    modifyTb );
4258   createTool( SMESHOp::OpRevolution,             modifyTb );
4259   createTool( SMESHOp::OpPatternMapping,         modifyTb );
4260   createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4261   createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4262
4263   createTool( SMESHOp::OpMinimumDistance, measuremTb );
4264
4265   createTool( SMESHOp::OpUpdate, dispModeTb );
4266
4267   QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
4268   QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4269
4270   myRules.clear();
4271   QString OB = "'ObjectBrowser'",
4272           View = "'" + SVTK_Viewer::Type() + "'",
4273           pat = "'%1'",
4274           mesh    = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4275           group   = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4276           hypo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4277           algo    = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4278           elems   = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4279                        arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4280                        arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4281                        arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4282                        arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4283                        arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4284                        arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4285           subMesh = elems,
4286           mesh_part = mesh + " " + subMesh + " " + group,
4287           mesh_group = mesh + " " + group,
4288           hyp_alg = hypo + " " + algo;
4289
4290   // popup for object browser
4291   QString
4292     isInvisible("not( isVisible )"),
4293     isEmpty("numberOfNodes = 0"),
4294     isNotEmpty("numberOfNodes <> 0"),
4295
4296     // has nodes, edges, etc in VISIBLE! actor
4297     hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4298     hasElems("(count( elemTypes ) > 0)"),
4299     hasDifferentElems("(count( elemTypes ) > 1)"),
4300     hasBalls("({'BallElem'} in elemTypes)"),
4301     hasElems0d("({'Elem0d'} in elemTypes)"),
4302     hasEdges("({'Edge'} in elemTypes)"),
4303     hasFaces("({'Face'} in elemTypes)"),
4304     hasVolumes("({'Volume'} in elemTypes)");
4305
4306   createPopupItem( SMESHOp::OpFileInformation,      OB, mesh, "&& selcount=1 && isImported" );
4307   createPopupItem( SMESHOp::OpCreateSubMesh,        OB, mesh, "&& isComputable");
4308   createPopupItem( SMESHOp::OpEditMeshOrSubMesh,    OB, mesh, "&& isComputable");
4309   createPopupItem( SMESHOp::OpEditMeshOrSubMesh,    OB, subMesh, "&& isComputable" );
4310   createPopupItem( SMESHOp::OpEditGroup,            OB, group );
4311   createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4312
4313   popupMgr()->insert( separator(), -1, 0 );
4314   createPopupItem( SMESHOp::OpCompute,                OB, mesh, "&& isComputable" );
4315   createPopupItem( SMESHOp::OpPreCompute,             OB, mesh, "&& isComputable && isPreComputable" );
4316   createPopupItem( SMESHOp::OpEvaluate,               OB, mesh, "&& isComputable" );
4317   createPopupItem( SMESHOp::OpMeshOrder,              OB, mesh, "&& isComputable" );
4318   createPopupItem( SMESHOp::OpUpdate,                 OB, mesh_part );
4319   createPopupItem( SMESHOp::OpMeshInformation,        OB, mesh_part );
4320   createPopupItem( SMESHOp::OpFindElementByPoint,     OB, mesh_group );
4321   createPopupItem( SMESHOp::OpOverallMeshQuality,     OB, mesh_part );
4322   popupMgr()->insert( separator(), -1, 0 );
4323   createPopupItem( SMESHOp::OpCreateGroup,            OB, mesh );
4324   createPopupItem( SMESHOp::OpCreateGeometryGroup,    OB, mesh );
4325   createPopupItem( SMESHOp::OpConstructGroup,         OB, subMesh );
4326   popupMgr()->insert( separator(), -1, 0 );
4327   createPopupItem( SMESHOp::OpEditHypothesis,         OB, hypo);
4328   createPopupItem( SMESHOp::OpUnassign,               OB, hyp_alg );     // REMOVE HYPOTHESIS / ALGORITHMS
4329   popupMgr()->insert( separator(), -1, 0 );
4330   createPopupItem( SMESHOp::OpClearMesh,              OB, mesh );
4331   popupMgr()->insert( separator(), -1, 0 );
4332   createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh + " " + subMesh );  // convert to quadratic
4333   createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh + " " + group,      // create 2D mesh from 3D
4334                    "&& dim>=2");
4335   popupMgr()->insert( separator(), -1, 0 );
4336
4337   QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4338   QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4339   QString only_one_2D        = only_one_non_empty + " && dim>1";
4340
4341   int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 );        // EXPORT submenu
4342   createPopupItem( SMESHOp::OpPopupExportMED,  OB, mesh_group, multiple_non_empty, anId );
4343   createPopupItem( SMESHOp::OpPopupExportUNV,  OB, mesh_group, only_one_non_empty, anId );
4344   createPopupItem( SMESHOp::OpPopupExportSTL,  OB, mesh_group, only_one_2D, anId );
4345 #ifdef WITH_CGNS
4346   createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4347 #endif
4348   createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, multiple_non_empty, anId );
4349   createPopupItem( SMESHOp::OpPopupExportGMF,  OB, mesh_group, multiple_non_empty, anId );
4350   createPopupItem( SMESHOp::OpPopupExportDAT,  OB, mesh_group, multiple_non_empty, anId );
4351   createPopupItem( SMESHOp::OpDelete,          OB, mesh_part + " " + hyp_alg );
4352   createPopupItem( SMESHOp::OpDeleteGroup,     OB, group );
4353   popupMgr()->insert( separator(), -1, 0 );
4354
4355   // popup for viewer
4356   createPopupItem( SMESHOp::OpEditGroup,            View, group );
4357   createPopupItem( SMESHOp::OpAddElemGroupPopup,    View, elems );
4358   createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4359
4360   popupMgr()->insert( separator(), -1, 0 );
4361   createPopupItem( SMESHOp::OpUpdate,             View, mesh_part );
4362   createPopupItem( SMESHOp::OpMeshInformation,    View, mesh_part );
4363   createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4364   createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4365   popupMgr()->insert( separator(), -1, 0 );
4366
4367   createPopupItem( SMESHOp::OpAutoColor,        OB + " " + View, mesh, "&& (not isAutoColor)" );
4368   createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4369   popupMgr()->insert( separator(), -1, 0 );
4370
4371   QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4372   QString aType = QString( "%1type in {%2}" ).arg( lc );
4373   aType = aType.arg( mesh_part );
4374   QString aMeshInVTK = aClient + "&&" + aType;
4375
4376   aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4377   QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4378   QString aSelCount = QString( "%1 > 0" ).arg( dc );
4379
4380   //-------------------------------------------------
4381   // Numbering
4382   //-------------------------------------------------
4383   anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4384
4385   popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4386   popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4387   popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4388
4389   popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4390   popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4391   popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4392
4393   popupMgr()->insert( separator(), -1, -1 );
4394
4395   //-------------------------------------------------
4396   // Display Mode
4397   //-------------------------------------------------
4398   anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4399
4400   popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4401   popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4402   popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4403
4404   popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4405   popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4406   popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4407
4408   popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4409   popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4410   popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4411
4412   popupMgr()->insert( separator(), anId, -1 );
4413
4414   popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4415   popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4416   popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4417
4418   //-------------------------------------------------
4419   // Display Entity
4420   //-------------------------------------------------
4421   QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4422
4423   anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4424
4425   popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4426   popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4427   popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4428
4429   popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4430   popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4431   popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4432
4433   popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4434   popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4435   popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4436
4437   popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4438   popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4439   popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4440
4441   popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4442   popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4443   popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4444
4445   popupMgr()->insert( separator(), anId, -1 );
4446
4447   popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4448   popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4449
4450   popupMgr()->insert( separator(), anId, -1 );
4451
4452   popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4453   popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4454
4455
4456   //-------------------------------------------------
4457   // Representation of the 2D Quadratic elements
4458   //-------------------------------------------------
4459   anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4460   popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4461   popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4462   popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4463
4464   popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4465   popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4466   popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4467
4468   //-------------------------------------------------
4469   // Orientation of faces
4470   //-------------------------------------------------
4471   popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4472   popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4473   popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4474
4475   //-------------------------------------------------
4476   // Color / Size
4477   //-------------------------------------------------
4478   popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4479   popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4480
4481   //-------------------------------------------------
4482   // Transparency
4483   //-------------------------------------------------
4484   popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4485   popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4486
4487   //-------------------------------------------------
4488   // Controls
4489   //-------------------------------------------------
4490   QString
4491     aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4492     aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4493     aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4494     aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4495
4496   anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4497
4498   popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4499   popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4500
4501   popupMgr()->insert( separator(), anId, -1 );
4502
4503   int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4504
4505   popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4506   popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4507   popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4508
4509   popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4510   popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4511   popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4512
4513   aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4514
4515   popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4516   popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4517   popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4518
4519   popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4520   popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4521   popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4522
4523   popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4524   popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4525   popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4526
4527   popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4528   popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4529   popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4530   popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4531   popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4532   popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4533
4534   aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4535
4536   popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4537   popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4538                                        QtxPopupMgr::VisibleRule );
4539   popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4540
4541   popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4542   popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4543   popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4544
4545   popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4546   popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4547   popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4548
4549   popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4550   popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4551   popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4552
4553   popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4554   popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4555   popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4556
4557   popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4558   popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4559   popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4560
4561   popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4562   popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4563   popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4564
4565   popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4566   popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4567   popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4568
4569   popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4570   popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4571   popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4572
4573   popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4574   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4575   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4576
4577   popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4578   popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4579   popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4580
4581   popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4582   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4583   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4584   popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4585   popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4586   popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4587
4588   aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4589
4590   popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D  ), aSubId, -1 );
4591   popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4592   popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4593
4594   popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4595   popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4596   popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4597
4598   popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4599   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4600   popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4601
4602   popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4603   popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4604   popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4605
4606   popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4607   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4608   popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4609
4610   popupMgr()->insert ( action( SMESHOp::OpEqualVolume  ), aSubId, -1 );
4611   popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4612   popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4613
4614   popupMgr()->insert( separator(), anId, -1 );
4615
4616   popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4617   popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4618
4619   popupMgr()->insert( separator(), anId, -1 );
4620
4621   aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4622
4623   popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4624   popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4625
4626   popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4627   popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4628   popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4629
4630 #ifndef DISABLE_PLOT2DVIEWER
4631   popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4632   popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4633 #endif
4634
4635   //-------------------------------------------------
4636   // Show / Hide
4637   //-------------------------------------------------
4638   popupMgr()->insert( separator(), -1, -1 );
4639   QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4640     aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4641   popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4642   popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4643
4644   popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4645   popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4646
4647   popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4648   popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4649
4650   popupMgr()->insert( separator(), -1, -1 );
4651
4652   //-------------------------------------------------
4653   // Clipping
4654   //-------------------------------------------------
4655   popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4656   popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4657
4658   popupMgr()->insert( separator(), -1, -1 );
4659
4660   popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4661   popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4662   popupMgr()->insert( separator(), -1, -1 );
4663
4664   connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4665            this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4666
4667   connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4668            this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4669 }
4670
4671 //================================================================================
4672 /*!
4673  * \brief Return true if SMESH or GEOM objects are selected.
4674  * Is called form LightApp_Module::activateModule() which clear selection if
4675  * not isSelectionCompatible()
4676  */
4677 //================================================================================
4678
4679 bool SMESHGUI::isSelectionCompatible()
4680 {
4681   bool isCompatible = true;
4682   SALOME_ListIO selected;
4683   if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4684     Sel->selectedObjects( selected );
4685
4686   SALOME_ListIteratorOfListIO It( selected );
4687   for ( ; isCompatible && It.More(); It.Next())
4688     isCompatible =
4689       ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4690       ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4691
4692   return isCompatible;
4693 }
4694
4695
4696 bool SMESHGUI::reusableOperation( const int id )
4697 {
4698   // compute, evaluate and precompute are not reusable operations
4699   return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4700 }
4701
4702 bool SMESHGUI::activateModule( SUIT_Study* study )
4703 {
4704   bool res = SalomeApp_Module::activateModule( study );
4705
4706   setMenuShown( true );
4707   setToolShown( true );
4708
4709   // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4710   PyGILState_STATE gstate = PyGILState_Ensure();
4711   PyObjWrapper pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4712   if ( !pluginsmanager ) {
4713     PyErr_Print();
4714   }
4715   else {
4716     PyObjWrapper result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4717     if ( !result )
4718       PyErr_Print();
4719   }
4720   PyGILState_Release(gstate);
4721   // end of SMESH plugins loading
4722
4723   // Reset actions accelerator keys
4724   //action(SMESHOp::OpImportDAT)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B));
4725   action(SMESHOp::OpImportUNV)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U));
4726   action(SMESHOp::OpImportMED)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M));
4727
4728   action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4729
4730   //  0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4731   GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4732   if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4733     if ( _PTR(Study) aStudy = s->studyDS()) {
4734       GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4735       updateObjBrowser(); // objects can be removed
4736     }
4737
4738   // get all view currently opened in the study and connect their signals  to
4739   // the corresponding slots of the class.
4740   SUIT_Desktop* aDesk = study->application()->desktop();
4741   if ( aDesk ) {
4742     QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4743     SUIT_ViewWindow* wnd;
4744     foreach ( wnd, wndList )
4745       connectView( wnd );
4746   }
4747
4748   return res;
4749 }
4750
4751 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4752 {
4753   setMenuShown( false );
4754   setToolShown( false );
4755
4756   EmitSignalCloseAllDialogs();
4757
4758   // Unset actions accelerator keys
4759   //action(SMESHOp::OpImportDAT)->setShortcut(QKeySequence());
4760   action(SMESHOp::OpImportUNV)->setShortcut(QKeySequence());
4761   action(SMESHOp::OpImportMED)->setShortcut(QKeySequence());
4762
4763   action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4764
4765   return SalomeApp_Module::deactivateModule( study );
4766 }
4767
4768 void SMESHGUI::studyClosed( SUIT_Study* s )
4769 {
4770   if( !s )
4771     return;
4772   SMESH::RemoveVisuData( s->id() );
4773   SalomeApp_Module::studyClosed( s );
4774 }
4775
4776 void SMESHGUI::OnGUIEvent()
4777 {
4778   const QObject* obj = sender();
4779   if ( !obj || !obj->inherits( "QAction" ) )
4780     return;
4781   int id = actionId((QAction*)obj);
4782   if ( id != -1 )
4783     OnGUIEvent( id );
4784 }
4785
4786 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4787 {
4788   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4789   if ( CORBA::is_nil( myComponentSMESH ) )
4790     {
4791       SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4792       if ( aStudy )
4793         aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4794       return aGUI.myComponentSMESH;
4795     }
4796   if ( aStudy )
4797     myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4798   return myComponentSMESH;
4799 }
4800
4801 QString SMESHGUI::engineIOR() const
4802 {
4803   CORBA::ORB_var anORB = getApp()->orb();
4804   CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4805   return QString( anIOR.in() );
4806 }
4807
4808 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4809 {
4810   SalomeApp_Module::contextMenuPopup( client, menu, title );
4811   SALOME_ListIO lst;
4812   selectionMgr()->selectedObjects( lst );
4813   if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4814     Handle(SALOME_InteractiveObject) io = lst.First();
4815     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4816     _PTR(Study) study = appStudy->studyDS();
4817     _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4818     if ( obj ) {
4819       QString aName = QString( QString::fromUtf8(obj->GetName().c_str()) );
4820       while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4821           aName.remove( (aName.length() - 1), 1 );
4822       title = aName;
4823     }
4824   }
4825 }
4826
4827 LightApp_Selection* SMESHGUI::createSelection() const
4828 {
4829   return new SMESHGUI_Selection();
4830 }
4831
4832 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4833 {
4834   aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4835   aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4836   aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4837 }
4838
4839 void SMESHGUI::viewManagers( QStringList& list ) const
4840 {
4841   list.append( SVTK_Viewer::Type() );
4842 }
4843
4844 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4845 {
4846   if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4847     SMESH::UpdateSelectionProp( this );
4848
4849     QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4850     for(int i = 0; i < aViews.count() ; i++){
4851       SUIT_ViewWindow *sf = aViews[i];
4852       connectView( sf );
4853     }
4854   }
4855 }
4856
4857 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4858 {
4859   if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4860     myClippingPlaneInfoMap.erase( theViewManager );
4861 }
4862
4863 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4864 {
4865   theActor->AddObserver( SMESH::DeleteActorEvent,
4866                          myEventCallbackCommand.GetPointer(),
4867                          myPriority );
4868 }
4869
4870 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4871                               unsigned long theEvent,
4872                               void* theClientData,
4873                               void* theCallData )
4874 {
4875   if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4876     if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4877       if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4878         SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4879         SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4880         for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4881           SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4882           SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4883           for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4884             SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4885             std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4886             SMESH::TActorList::iterator anIter3 = anActorList.begin();
4887             for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4888               if( anActor == *anIter3 ) {
4889                 anActorList.erase( anIter3 );
4890                 break;
4891               }
4892             }
4893           }
4894         }
4895       }
4896     }
4897   }
4898 }
4899
4900 void SMESHGUI::createPreferences()
4901 {
4902   // General tab ------------------------------------------------------------------------
4903   int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4904
4905   int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4906   setPreferenceProperty( autoUpdate, "columns", 2 );
4907   int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4908   setPreferenceProperty( lim, "min",  0 );
4909   setPreferenceProperty( lim, "max",  100000000 );
4910   setPreferenceProperty( lim, "step", 1000 );
4911   setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4912   addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4913
4914   int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4915   setPreferenceProperty( qaGroup, "columns", 2 );
4916   addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4917   addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4918   int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4919   setPreferenceProperty( prec, "min", 0 );
4920   setPreferenceProperty( prec, "max", 16 );
4921   int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4922   setPreferenceProperty( doubleNodesTol, "precision", 10 );
4923   setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4924   setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4925   setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4926
4927   int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4928   setPreferenceProperty( dispgroup, "columns", 2 );
4929   int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4930   QStringList modes;
4931   modes.append( tr("MEN_WIRE") );
4932   modes.append( tr("MEN_SHADE") );
4933   modes.append( tr("MEN_NODES") );
4934   modes.append( tr("MEN_SHRINK") );
4935   QList<QVariant> indices;
4936   indices.append( 0 );
4937   indices.append( 1 );
4938   indices.append( 2 );
4939   indices.append( 3 );
4940   setPreferenceProperty( dispmode, "strings", modes );
4941   setPreferenceProperty( dispmode, "indexes", indices );
4942
4943   int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4944   setPreferenceProperty( arcgroup, "columns", 2 );
4945   int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4946   QStringList quadraticModes;
4947   quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4948   quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4949   indices.clear();
4950   indices.append( 0 );
4951   indices.append( 1 );
4952   setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4953   setPreferenceProperty( quadraticmode, "indexes", indices );
4954
4955   int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4956                               "SMESH", "max_angle" );
4957   setPreferenceProperty( maxAngle, "min", 1 );
4958   setPreferenceProperty( maxAngle, "max", 90 );
4959
4960
4961
4962   int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4963   setPreferenceProperty( exportgroup, "columns", 2 );
4964   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4965   //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4966
4967   int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4968   setPreferenceProperty( computeGroup, "columns", 2 );
4969   int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4970   modes.clear();
4971   modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4972   modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4973   modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4974   indices.clear();
4975   indices.append( 0 );
4976   indices.append( 1 );
4977   indices.append( 2 );
4978   setPreferenceProperty( notifyMode, "strings", modes );
4979   setPreferenceProperty( notifyMode, "indexes", indices );
4980
4981   int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4982   setPreferenceProperty( infoGroup, "columns", 2 );
4983   int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4984   modes.clear();
4985   modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4986   modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4987   indices.clear();
4988   indices.append( 0 );
4989   indices.append( 1 );
4990   setPreferenceProperty( elemInfo, "strings", modes );
4991   setPreferenceProperty( elemInfo, "indexes", indices );
4992   int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4993   setPreferenceProperty( nodesLim, "min", 0 );
4994   setPreferenceProperty( nodesLim, "max", 10000000 );
4995   setPreferenceProperty( nodesLim, "step", 10000 );
4996   setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4997   int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
4998   setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4999   setPreferenceProperty( ctrlLim, "min", 0 );
5000   setPreferenceProperty( ctrlLim, "max", 10000000 );
5001   setPreferenceProperty( ctrlLim, "step", 1000 );
5002   addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5003   addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5004   addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5005   addPreference( tr( "PREF_DUMP_ADD_INFO"  ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5006   addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5007
5008   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5009   setPreferenceProperty( segGroup, "columns", 2 );
5010   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5011                               "SMESH", "segmentation" );
5012   setPreferenceProperty( segLen, "min", 1 );
5013   setPreferenceProperty( segLen, "max", 10000000 );
5014   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5015                              "SMESH", "nb_segments_per_edge" );
5016   setPreferenceProperty( nbSeg, "min", 1 );
5017   setPreferenceProperty( nbSeg, "max", 10000000 );
5018
5019   int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5020   addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5021                  "SMESH", "forget_mesh_on_hyp_modif" );
5022
5023
5024   // Quantities with individual precision settings
5025   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5026   setPreferenceProperty( precGroup, "columns", 2 );
5027
5028   const int nbQuantities = 6;
5029   int precs[nbQuantities], ii = 0;
5030   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5031                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5032   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5033                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5034   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5035                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5036   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5037                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5038   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5039                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5040   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5041                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5042
5043   // Set property for precision value for spinboxes
5044   for ( ii = 0; ii < nbQuantities; ii++ ){
5045     setPreferenceProperty( precs[ii], "min", -14 );
5046     setPreferenceProperty( precs[ii], "max", 14 );
5047     setPreferenceProperty( precs[ii], "precision", 2 );
5048   }
5049
5050   int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5051   setPreferenceProperty( previewGroup, "columns", 2 );
5052   int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5053   setPreferenceProperty( chunkSize, "min",  1 );
5054   setPreferenceProperty( chunkSize, "max",  1000 );
5055   setPreferenceProperty( chunkSize, "step", 50 );
5056
5057   int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5058   addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5059
5060   // Mesh tab ------------------------------------------------------------------------
5061   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5062   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5063   setPreferenceProperty( nodeGroup, "columns", 3 );
5064
5065   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5066
5067   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5068
5069   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5070   QList<QVariant> aMarkerTypeIndicesList;
5071   QList<QVariant> aMarkerTypeIconsList;
5072   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5073     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5074     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5075     aMarkerTypeIndicesList << i;
5076     aMarkerTypeIconsList << pixmap;
5077   }
5078   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5079   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
5080
5081   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5082
5083   QList<QVariant> aMarkerScaleIndicesList;
5084   QStringList     aMarkerScaleValuesList;
5085   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5086     aMarkerScaleIndicesList << i;
5087     aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5088   }
5089   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5090   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5091
5092   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5093   //setPreferenceProperty( elemGroup, "columns", 2 );
5094
5095   int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5096   setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5097   ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5098   setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5099   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5100   addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5101   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5102   addPreference( tr( "PREF_WIREFRAME"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5103   addPreference( tr( "PREF_PREVIEW_COLOR"  ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5104
5105
5106   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5107   setPreferenceProperty( grpGroup, "columns", 2 );
5108
5109   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5110   addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5111
5112   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5113                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5114   int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5115                              LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
5116   double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5117                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5118   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
5119                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
5120   int outW  = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5121                              LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5122   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5123                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5124
5125   setPreferenceProperty( size0d, "min", 1 );
5126   setPreferenceProperty( size0d, "max", 10 );
5127
5128   setPreferenceProperty( ballSize, "min", 1 );
5129   setPreferenceProperty( ballSize, "max", 10 );
5130
5131   setPreferenceProperty( ballScale, "min", 1e-2 );
5132   setPreferenceProperty( ballScale, "max", 1e7 );
5133   setPreferenceProperty( ballScale, "step", 0.5 );
5134
5135   setPreferenceProperty( elemW, "min", 1 );
5136   setPreferenceProperty( elemW, "max", 5 );
5137
5138   setPreferenceProperty( outW, "min", 1 );
5139   setPreferenceProperty( outW, "max", 5 );
5140
5141   setPreferenceProperty( shrink, "min", 0 );
5142   setPreferenceProperty( shrink, "max", 100 );
5143
5144   int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5145   setPreferenceProperty( numGroup, "columns", 2 );
5146
5147   addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5148   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5149
5150   addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5151   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5152
5153   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5154   setPreferenceProperty( orientGroup, "columns", 1 );
5155
5156   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5157   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5158
5159   setPreferenceProperty( orientScale, "min", 0.05 );
5160   setPreferenceProperty( orientScale, "max", 0.5 );
5161   setPreferenceProperty( orientScale, "step", 0.05 );
5162
5163   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5164
5165   // Selection tab ------------------------------------------------------------------------
5166   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5167
5168   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5169   setPreferenceProperty( selGroup, "columns", 2 );
5170
5171   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5172   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5173
5174   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5175   setPreferenceProperty( preGroup, "columns", 2 );
5176
5177   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5178
5179   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5180   setPreferenceProperty( precSelGroup, "columns", 2 );
5181
5182   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5183   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5184   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5185
5186   // Scalar Bar tab ------------------------------------------------------------------------
5187   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5188   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5189   setPreferenceProperty( fontGr, "columns", 2 );
5190
5191   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5192   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5193
5194   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5195   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5196
5197   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5198   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5199
5200   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5201   setPreferenceProperty( numcol, "min", 2 );
5202   setPreferenceProperty( numcol, "max", 256 );
5203
5204   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5205   setPreferenceProperty( numlab, "min", 2 );
5206   setPreferenceProperty( numlab, "max", 65 );
5207
5208   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5209   setPreferenceProperty( orientGr, "columns", 2 );
5210   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5211   QStringList orients;
5212   orients.append( tr( "SMESH_VERTICAL" ) );
5213   orients.append( tr( "SMESH_HORIZONTAL" ) );
5214   indices.clear(); indices.append( 0 ); indices.append( 1 );
5215   setPreferenceProperty( orient, "strings", orients );
5216   setPreferenceProperty( orient, "indexes", indices );
5217
5218   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5219   setPreferenceProperty( posVSizeGr, "columns", 2 );
5220   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5221   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5222   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5223   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5224   setPreferenceProperty( xv, "step", 0.1 );
5225   setPreferenceProperty( xv, "min", 0.0 );
5226   setPreferenceProperty( xv, "max", 1.0 );
5227   setPreferenceProperty( yv, "step", 0.1 );
5228   setPreferenceProperty( yv, "min", 0.0 );
5229   setPreferenceProperty( yv, "max", 1.0 );
5230   setPreferenceProperty( wv, "step", 0.1 );
5231   setPreferenceProperty( wv, "min", 0.0 );
5232   setPreferenceProperty( wv, "max", 1.0 );
5233   setPreferenceProperty( hv, "min", 0.0 );
5234   setPreferenceProperty( hv, "max", 1.0 );
5235   setPreferenceProperty( hv, "step", 0.1 );
5236
5237   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5238   setPreferenceProperty( posHSizeGr, "columns", 2 );
5239   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5240   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5241   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5242   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5243   setPreferenceProperty( xv, "min", 0.0 );
5244   setPreferenceProperty( xv, "max", 1.0 );
5245   setPreferenceProperty( xv, "step", 0.1 );
5246   setPreferenceProperty( xh, "min", 0.0 );
5247   setPreferenceProperty( xh, "max", 1.0 );
5248   setPreferenceProperty( xh, "step", 0.1 );
5249   setPreferenceProperty( yh, "min", 0.0 );
5250   setPreferenceProperty( yh, "max", 1.0 );
5251   setPreferenceProperty( yh, "step", 0.1 );
5252   setPreferenceProperty( wh, "min", 0.0 );
5253   setPreferenceProperty( wh, "max", 1.0 );
5254   setPreferenceProperty( wh, "step", 0.1 );
5255   setPreferenceProperty( hh, "min", 0.0 );
5256   setPreferenceProperty( hh, "max", 1.0 );
5257   setPreferenceProperty( hh, "step", 0.1 );
5258
5259   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5260   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5261   setPreferenceProperty( distributionGr, "columns", 3 );
5262   QStringList types;
5263   types.append( tr( "SMESH_MONOCOLOR" ) );
5264   types.append( tr( "SMESH_MULTICOLOR" ) );
5265   indices.clear(); indices.append( 0 ); indices.append( 1 );
5266   setPreferenceProperty( coloringType, "strings", types );
5267   setPreferenceProperty( coloringType, "indexes", indices );
5268   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5269
5270 }
5271
5272 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5273 {
5274   if( sect=="SMESH" ) {
5275     float sbX1,sbY1,sbW,sbH;
5276     float aTol = 1.00000009999999;
5277     std::string aWarning;
5278     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5279     if( name=="selection_object_color" || name=="selection_element_color" ||
5280         name=="highlight_color" ||
5281         name=="selection_precision_node" || name=="selection_precision_element" ||
5282         name=="selection_precision_object")
5283       SMESH::UpdateSelectionProp( this );
5284     else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5285       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5286       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5287       if(sbX1+sbW > aTol){
5288         aWarning = "Origin and Size Vertical: X+Width > 1\n";
5289         sbX1=0.01;
5290         sbW=0.08;
5291         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5292         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5293       }
5294     }
5295     else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5296       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5297       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5298       if(sbY1+sbH > aTol){
5299         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5300         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5301         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5302       }
5303     }
5304     else if(name ==  QString("scalar_bar_horizontal_x") || name ==  QString("scalar_bar_horizontal_width")){
5305       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5306       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5307       if(sbX1+sbW > aTol){
5308         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5309         sbX1=0.1;
5310         sbW=0.08;
5311         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5312         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5313       }
5314     }
5315     else if(name ==  QString("scalar_bar_horizontal_y") || name ==  QString("scalar_bar_horizontal_height")){
5316       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5317       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5318       if(sbY1+sbH > aTol){
5319         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5320         sbY1=0.01;
5321         sbH=0.08;
5322         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5323         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5324       }
5325     }
5326     else if ( name == "segmentation" ) {
5327       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5328       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5329     }
5330     else if ( name == "nb_segments_per_edge" ) {
5331       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5332       myComponentSMESH->SetDefaultNbSegments( nbSeg );
5333     }
5334     else if ( name == "historical_python_dump" ||
5335               name == "forget_mesh_on_hyp_modif") {
5336       QString val = aResourceMgr->stringValue( "SMESH", name );
5337       myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5338     }
5339     else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5340       SMESH::UpdateFontProp( this );
5341     }
5342     else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5343       SMESH::UpdateFontProp( this );
5344     }
5345
5346     if(aWarning.size() != 0){
5347       aWarning += "The default values are applied instead.";
5348       SUIT_MessageBox::warning(SMESHGUI::desktop(),
5349                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5350                                QObject::tr(aWarning.c_str()));
5351     }
5352   }
5353 }
5354
5355 //================================================================================
5356 /*!
5357  * \brief Update something in accordance with update flags
5358   * \param theFlags - update flags
5359 *
5360 * Update viewer or/and object browser etc. in accordance with update flags ( see
5361 * LightApp_UpdateFlags enumeration ).
5362 */
5363 //================================================================================
5364 void SMESHGUI::update( const int flags )
5365 {
5366   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5367     SMESH::UpdateView();
5368   else
5369     SalomeApp_Module::update( flags );
5370 }
5371
5372 //================================================================================
5373 /*!
5374  * \brief Set default selection mode
5375 *
5376 * SLOT called when operation commited. Sets default selection mode
5377 */
5378 //================================================================================
5379 void SMESHGUI::onOperationCommited( 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 Set default selection mode
5390 *
5391 * SLOT called when operation aborted. Sets default selection mode
5392 */
5393 //================================================================================
5394 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5395 {
5396   SVTK_ViewWindow* vtkWnd =
5397     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5398   if ( vtkWnd )
5399     vtkWnd->SetSelectionMode( ActorSelection );
5400 }
5401
5402 //================================================================================
5403 /*!
5404  * \brief Creates operation with given identifier
5405   * \param id - identifier of operation to be started
5406   * \return Pointer on created operation or NULL if operation is not created
5407 *
5408 * Virtual method redefined from the base class creates operation with given id.
5409 * It is called called automatically from startOperation method of base class.
5410 */
5411 //================================================================================
5412 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5413 {
5414   LightApp_Operation* op = 0;
5415   // to do : create operation here
5416   switch( id )
5417   {
5418     case SMESHOp::OpConvertMeshToQuadratic:
5419       op = new SMESHGUI_ConvToQuadOp();
5420     break;
5421     case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5422       op = new SMESHGUI_Make2DFrom3DOp();
5423     break;
5424     case SMESHOp::OpReorientFaces:
5425       op = new SMESHGUI_ReorientFacesOp();
5426       break;
5427     case SMESHOp::OpCreateMesh:
5428       op = new SMESHGUI_MeshOp( true, true );
5429     break;
5430     case SMESHOp::OpCreateSubMesh:
5431       op = new SMESHGUI_MeshOp( true, false );
5432     break;
5433     case SMESHOp::OpEditMeshOrSubMesh:
5434       op = new SMESHGUI_MeshOp( false );
5435     break;
5436     case SMESHOp::OpCompute:
5437       op = new SMESHGUI_ComputeOp();
5438     break;
5439     case SMESHOp::OpPreCompute:
5440       op = new SMESHGUI_PrecomputeOp();
5441     break;
5442     case SMESHOp::OpEvaluate:
5443       op = new SMESHGUI_EvaluateOp();
5444     break;
5445     case SMESHOp::OpMeshOrder:
5446       op = new SMESHGUI_MeshOrderOp();
5447     break;
5448     case SMESHOp::OpCreateGeometryGroup:
5449       op = new SMESHGUI_GroupOnShapeOp();
5450       break;
5451     case SMESHOp::OpFindElementByPoint:
5452       op = new SMESHGUI_FindElemByPointOp();
5453       break;
5454     case SMESHOp::OpMoveNode: // Make mesh pass through point
5455       op = new SMESHGUI_MakeNodeAtPointOp();
5456       break;
5457     case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5458       op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5459       break;
5460     default:
5461     break;
5462   }
5463
5464   if( !op )
5465     op = SalomeApp_Module::createOperation( id );
5466   return op;
5467 }
5468
5469 //================================================================================
5470 /*!
5471  * \brief Stops current operations and starts a given one
5472   * \param id - The id of the operation to start
5473  */
5474 //================================================================================
5475
5476 void SMESHGUI::switchToOperation(int id)
5477 {
5478   if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5479     activeStudy()->abortAllOperations();
5480   startOperation( id );
5481 }
5482
5483 LightApp_Displayer* SMESHGUI::displayer()
5484 {
5485   if( !myDisplayer )
5486     myDisplayer = new SMESHGUI_Displayer( getApp() );
5487   return myDisplayer;
5488 }
5489
5490 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5491 {
5492   int aHue = -1;
5493   int aTolerance = 64;
5494   int anIterations = 0;
5495   int aPeriod = 5;
5496
5497   while( 1 )
5498   {
5499     anIterations++;
5500     if( anIterations % aPeriod == 0 )
5501     {
5502       aTolerance /= 2;
5503       if( aTolerance < 1 )
5504         break;
5505     }
5506
5507     aHue = (int)( 360.0 * rand() / RAND_MAX );
5508
5509     bool ok = true;
5510     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5511     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5512     for( ; it != itEnd; ++it )
5513     {
5514       SALOMEDS::Color anAutoColor = *it;
5515       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5516
5517       int h, s, v;
5518       aQColor.getHsv( &h, &s, &v );
5519       if( abs( h - aHue ) < aTolerance )
5520       {
5521         ok = false;
5522         break;
5523       }
5524     }
5525
5526     if( ok )
5527       break;
5528   }
5529
5530   QColor aColor;
5531   aColor.setHsv( aHue, 255, 255 );
5532
5533   SALOMEDS::Color aSColor;
5534   aSColor.R = aColor.redF();
5535   aSColor.G = aColor.greenF();
5536   aSColor.B = aColor.blueF();
5537
5538   return aSColor;
5539 }
5540
5541 const char* gSeparator = "_"; // character used to separate parameter names
5542 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5543 const char* gPathSep   = "|"; // character used to separate paths
5544
5545 /*!
5546  * \brief Store visual parameters
5547  *
5548  * This method is called just before the study document is saved.
5549  * Store visual parameters in AttributeParameter attribue(s)
5550  */
5551 void SMESHGUI::storeVisualParameters (int savePoint)
5552 {
5553   // localizing
5554   Kernel_Utils::Localizer loc;
5555
5556   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5557   if (!appStudy || !appStudy->studyDS())
5558     return;
5559   _PTR(Study) studyDS = appStudy->studyDS();
5560
5561   // componentName is used for encoding of entries when storing them in IParameters
5562   std::string componentName = myComponentSMESH->ComponentDataType();
5563   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5564   //if (!aSComponent) return;
5565
5566   // IParameters
5567   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5568                                                              componentName.c_str(),
5569                                                              savePoint);
5570   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5571
5572   // store map of custom markers
5573   const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5574   if( !aMarkerMap.empty() )
5575   {
5576     VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5577     for( ; anIter != aMarkerMap.end(); anIter++ )
5578     {
5579       int anId = anIter->first;
5580       VTK::MarkerData aMarkerData = anIter->second;
5581       std::string aMarkerFileName = aMarkerData.first;
5582       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5583       if( aMarkerTexture.size() < 3 )
5584         continue; // should contain at least width, height and the first value
5585
5586       QString aPropertyName( "texture" );
5587       aPropertyName += gSeparator;
5588       aPropertyName += QString::number( anId );
5589
5590       QString aPropertyValue = aMarkerFileName.c_str();
5591       aPropertyValue += gPathSep;
5592
5593       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5594       ushort aWidth = *aTextureIter++;
5595       ushort aHeight = *aTextureIter++;
5596       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5597       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5598       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5599         aPropertyValue += QString::number( *aTextureIter );
5600
5601       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5602     }
5603   }
5604
5605   // viewers counters are used for storing view_numbers in IParameters
5606   int vtkViewers = 0;
5607
5608   // main cycle to store parameters of displayed objects
5609   QList<SUIT_ViewManager*> lst;
5610   QList<SUIT_ViewManager*>::Iterator it;
5611   getApp()->viewManagers(lst);
5612   for (it = lst.begin(); it != lst.end(); it++)
5613   {
5614     SUIT_ViewManager* vman = *it;
5615     QString vType = vman->getType();
5616
5617     // saving VTK actors properties
5618     if (vType == SVTK_Viewer::Type())
5619     {
5620       // store the clipping planes attached to the view manager
5621       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5622       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5623       if( anIter != myClippingPlaneInfoMap.end() )
5624         aClippingPlaneInfoList = anIter->second;
5625
5626       if( !aClippingPlaneInfoList.empty() ) {
5627         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5628         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5629         {
5630           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5631           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5632
5633           QString aPropertyName( "ClippingPlane" );
5634           aPropertyName += gSeparator;
5635           aPropertyName += QString::number( vtkViewers );
5636           aPropertyName += gSeparator;
5637           aPropertyName += QString::number( anId );
5638
5639           QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5640           aPropertyValue += gDigitsSep;
5641           aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5642           aPropertyValue += gDigitsSep;
5643           if ( aPlane->PlaneMode == SMESH::Absolute ) {
5644             aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5645             aPropertyValue += gDigitsSep;
5646             aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5647             aPropertyValue += gDigitsSep;
5648             aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5649             aPropertyValue += gDigitsSep;
5650             aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5651             aPropertyValue += gDigitsSep;
5652             aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5653             aPropertyValue += gDigitsSep;
5654             aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5655             aPropertyValue += gDigitsSep;
5656             aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5657           }
5658           else if ( aPlane->PlaneMode == SMESH::Relative ) {
5659             aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5660             aPropertyValue += gDigitsSep;
5661             aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5662             aPropertyValue += gDigitsSep;
5663             aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5664             aPropertyValue += gDigitsSep;
5665             aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5666           }
5667
5668           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5669         }
5670       }
5671
5672       QVector<SUIT_ViewWindow*> views = vman->getViews();
5673       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5674       {
5675         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5676         {
5677           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5678           vtkActorCollection* allActors = aCopy.GetActors();
5679           allActors->InitTraversal();
5680           while (vtkActor* actor = allActors->GetNextActor())
5681           {
5682             if (actor->GetVisibility()) // store only visible actors
5683             {
5684               SMESH_Actor* aSmeshActor = 0;
5685               if (actor->IsA("SMESH_Actor"))
5686                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5687               if (aSmeshActor && aSmeshActor->hasIO())
5688               {
5689                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5690                 if (io->hasEntry())
5691                 {
5692                   // entry is "encoded" = it does NOT contain component adress,
5693                   // since it is a subject to change on next component loading
5694                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5695
5696                   std::string param, vtkParam = vType.toLatin1().data();
5697                   vtkParam += gSeparator;
5698                   vtkParam += QString::number(vtkViewers).toLatin1().data();
5699                   vtkParam += gSeparator;
5700
5701                   // Visibility
5702                   param = vtkParam + "Visibility";
5703                   ip->setParameter(entry, param, "On");
5704
5705                   // Representation
5706                   param = vtkParam + "Representation";
5707                   ip->setParameter(entry, param, QString::number
5708                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5709
5710                   // IsShrunk
5711                   param = vtkParam + "IsShrunk";
5712                   ip->setParameter(entry, param, QString::number
5713                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5714
5715                   // Displayed entities
5716                   unsigned int aMode = aSmeshActor->GetEntityMode();
5717                   bool isE  = aMode & SMESH_Actor::eEdges;
5718                   bool isF  = aMode & SMESH_Actor::eFaces;
5719                   bool isV  = aMode & SMESH_Actor::eVolumes;
5720                   bool is0d = aMode & SMESH_Actor::e0DElements;
5721                   bool isB  = aMode & SMESH_Actor::eBallElem;
5722
5723                   QString modeStr ("e");
5724                   modeStr += gDigitsSep; modeStr += QString::number(isE);
5725                   modeStr += gDigitsSep; modeStr += "f";
5726                   modeStr += gDigitsSep; modeStr += QString::number(isF);
5727                   modeStr += gDigitsSep; modeStr += "v";
5728                   modeStr += gDigitsSep; modeStr += QString::number(isV);
5729                   modeStr += gDigitsSep; modeStr += "0d";
5730                   modeStr += gDigitsSep; modeStr += QString::number(is0d);
5731                   modeStr += gDigitsSep; modeStr += "b";
5732                   modeStr += gDigitsSep; modeStr += QString::number(isB);
5733
5734                   param = vtkParam + "Entities";
5735                   ip->setParameter(entry, param, modeStr.toLatin1().data());
5736
5737                   // Colors
5738                   double r, g, b;
5739                   int delta;
5740
5741                   aSmeshActor->GetSufaceColor(r, g, b, delta);
5742                   QStringList colorStr;
5743                   colorStr << "surface";
5744                   colorStr << QString::number(r);
5745                   colorStr << QString::number(g);
5746                   colorStr << QString::number(b);
5747
5748                   colorStr << "backsurface";
5749                   colorStr << QString::number(delta);
5750
5751                   aSmeshActor->GetVolumeColor(r, g, b, delta);
5752                   colorStr << "volume";
5753                   colorStr << QString::number(r);
5754                   colorStr << QString::number(g);
5755                   colorStr << QString::number(b);
5756                   colorStr << QString::number(delta);
5757
5758                   aSmeshActor->GetEdgeColor(r, g, b);
5759                   colorStr << "edge";
5760                   colorStr << QString::number(r);
5761                   colorStr << QString::number(g);
5762                   colorStr << QString::number(b);
5763
5764                   aSmeshActor->GetNodeColor(r, g, b);
5765                   colorStr << "node";
5766                   colorStr << QString::number(r);
5767                   colorStr << QString::number(g);
5768                   colorStr << QString::number(b);
5769
5770                   aSmeshActor->GetOutlineColor(r, g, b);
5771                   colorStr << "outline";
5772                   colorStr << QString::number(r);
5773                   colorStr << QString::number(g);
5774                   colorStr << QString::number(b);
5775
5776                   aSmeshActor->Get0DColor(r, g, b);
5777                   colorStr << "elem0d";
5778                   colorStr << QString::number(r);
5779                   colorStr << QString::number(g);
5780                   colorStr << QString::number(b);
5781
5782                   aSmeshActor->GetBallColor(r, g, b);
5783                   colorStr << "ball";
5784                   colorStr << QString::number(r);
5785                   colorStr << QString::number(g);
5786                   colorStr << QString::number(b);
5787
5788                   aSmeshActor->GetFacesOrientationColor(r, g, b);
5789                   colorStr << "orientation";
5790                   colorStr << QString::number(r);
5791                   colorStr << QString::number(g);
5792                   colorStr << QString::number(b);
5793
5794                   param = vtkParam + "Colors";
5795                   ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5796
5797                   // Sizes
5798                   QStringList sizeStr;
5799                   sizeStr << "line";
5800                   sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5801                   sizeStr << "outline";
5802                   sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5803                   sizeStr << "elem0d";
5804                   sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5805                   sizeStr << "ball";
5806                   sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5807                   sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5808                   sizeStr << "shrink";
5809                   sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5810                   sizeStr << "orientation";
5811                   sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5812                   sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5813
5814                   param = vtkParam + "Sizes";
5815                   ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5816
5817                   // Point marker
5818                   QString markerStr;
5819
5820                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5821                   if( aMarkerType == VTK::MT_USER ) {
5822                     markerStr += "custom";
5823                     markerStr += gDigitsSep;
5824                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5825                   }
5826                   else {
5827                     markerStr += "std";
5828                     markerStr += gDigitsSep;
5829                     markerStr += QString::number( (int)aMarkerType );
5830                     markerStr += gDigitsSep;
5831                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5832                   }
5833
5834                   param = vtkParam + "PointMarker";
5835                   ip->setParameter(entry, param, markerStr.toLatin1().data());
5836
5837                   // Opacity
5838                   param = vtkParam + "Opacity";
5839                   ip->setParameter(entry, param,
5840                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5841
5842                   // Clipping
5843                   param = vtkParam + "ClippingPlane";
5844                   int aPlaneId = 0;
5845                   if( !aClippingPlaneInfoList.empty() ) {
5846                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5847                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5848                     {
5849                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5850                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5851                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
5852                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5853                         if( aSmeshActor == *anIter2 ) {
5854                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5855                                             QString::number( anId ).toLatin1().constData() );
5856                           break;
5857                         }
5858                       }
5859                     }
5860                   }
5861                   if( aPlaneId == 0 )
5862                     ip->setParameter( entry, param, "Off" );
5863                 } // if (io->hasEntry())
5864               } // SMESH_Actor && hasIO
5865             } // isVisible
5866           } // while.. actors traversal
5867         } // if (vtkView)
5868       } // for (views)
5869       vtkViewers++;
5870     } // if (SVTK view model)
5871   } // for (viewManagers)
5872 }
5873
5874 // data structures for clipping planes processing
5875 typedef struct {
5876   int Id;
5877   int Mode;
5878   bool isOpenGLClipping;
5879   vtkIdType RelativeOrientation;
5880   double Distance;
5881   double Angle[2];
5882   int AbsoluteOrientation;
5883   double X, Y, Z, Dx, Dy, Dz;
5884 } TPlaneData;
5885 typedef std::list<TPlaneData>         TPlaneDataList;
5886 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5887
5888 typedef std::list<vtkActor*>          TActorList;
5889 typedef struct {
5890   int PlaneId;
5891   TActorList ActorList;
5892   SUIT_ViewManager* ViewManager;
5893 } TPlaneInfo;
5894 typedef std::list<TPlaneInfo>         TPlaneInfoList;
5895 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5896
5897 /*!
5898  * \brief Restore visual parameters
5899  *
5900  * This method is called after the study document is opened.
5901  * Restore visual parameters from AttributeParameter attribue(s)
5902  */
5903 void SMESHGUI::restoreVisualParameters (int savePoint)
5904 {
5905   // localizing
5906   Kernel_Utils::Localizer loc;
5907
5908   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5909   if (!appStudy || !appStudy->studyDS())
5910     return;
5911   _PTR(Study) studyDS = appStudy->studyDS();
5912
5913   // componentName is used for encoding of entries when storing them in IParameters
5914   std::string componentName = myComponentSMESH->ComponentDataType();
5915   //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5916   //if (!aSComponent) return;
5917
5918   // IParameters
5919   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5920                                                              componentName.c_str(),
5921                                                              savePoint);
5922   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5923
5924   // restore map of custom markers and map of clipping planes
5925   VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5926   TPlaneDataMap aPlaneDataMap;
5927
5928   std::vector<std::string> properties = ip->getProperties();
5929   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5930   {
5931     std::string property = *propIt;
5932     QString aPropertyName( property.c_str() );
5933     QString aPropertyValue( ip->getProperty( property ).c_str() );
5934
5935     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5936     if( aPropertyNameList.isEmpty() )
5937       continue;
5938
5939     QString aPropertyType = aPropertyNameList[0];
5940     if( aPropertyType == "texture" )
5941     {
5942       if( aPropertyNameList.size() != 2 )
5943         continue;
5944
5945       bool ok = false;
5946       int anId = aPropertyNameList[1].toInt( &ok );
5947       if( !ok || anId < 1 )
5948         continue;
5949
5950       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5951       if( aPropertyValueList.size() != 2 )
5952         continue;
5953
5954       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5955       QString aMarkerTextureString = aPropertyValueList[1];
5956       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5957       if( aMarkerTextureStringList.size() != 3 )
5958         continue;
5959
5960       ok = false;
5961       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5962       if( !ok )
5963         continue;
5964
5965       ok = false;
5966       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5967       if( !ok )
5968         continue;
5969
5970       VTK::MarkerTexture aMarkerTexture;
5971       aMarkerTexture.push_back( aWidth );
5972       aMarkerTexture.push_back( aHeight );
5973
5974       QString aMarkerTextureData = aMarkerTextureStringList[2];
5975       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5976       {
5977         QChar aChar = aMarkerTextureData.at( i );
5978         if( aChar.isDigit() )
5979           aMarkerTexture.push_back( aChar.digitValue() );
5980       }
5981
5982       aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5983     }
5984     else if( aPropertyType == "ClippingPlane" )
5985     {
5986       if( aPropertyNameList.size() != 3 )
5987         continue;
5988
5989       bool ok = false;
5990       int aViewId = aPropertyNameList[1].toInt( &ok );
5991       if( !ok || aViewId < 0 )
5992         continue;
5993
5994       ok = false;
5995       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5996       if( !ok || aClippingPlaneId < 0 )
5997         continue;
5998
5999       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6000       if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6001         continue;
6002
6003       TPlaneData aPlaneData;
6004       aPlaneData.Id = aClippingPlaneId;
6005
6006       ok = false;
6007       aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6008       if( !ok )
6009         continue;
6010
6011       ok = false;
6012       aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6013       if( !ok )
6014         continue;
6015
6016       if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6017       {
6018         ok = false;
6019         aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6020         if( !ok )
6021           continue;
6022
6023         ok = false;
6024         aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6025         if( !ok )
6026           continue;
6027
6028         ok = false;
6029         aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6030         if( !ok )
6031           continue;
6032
6033         ok = false;
6034         aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6035         if( !ok )
6036           continue;
6037
6038         ok = false;
6039         aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6040         if( !ok )
6041           continue;
6042
6043         ok = false;
6044         aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6045         if( !ok )
6046           continue;
6047
6048         ok = false;
6049         aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6050         if( !ok )
6051           continue;
6052       }
6053       else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6054         ok = false;
6055         aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6056         if( !ok )
6057           continue;
6058
6059         ok = false;
6060         aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6061         if( !ok )
6062           continue;
6063
6064         ok = false;
6065         aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6066         if( !ok )
6067           continue;
6068
6069         ok = false;
6070         aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6071         if( !ok )
6072           continue;
6073       }
6074
6075       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6076       aPlaneDataList.push_back( aPlaneData );
6077     }
6078   }
6079
6080   TPlaneInfoMap aPlaneInfoMap;
6081
6082   std::vector<std::string> entries = ip->getEntries();
6083
6084   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6085   {
6086     // entry is a normal entry - it should be "decoded" (setting base adress of component)
6087     QString entry (ip->decodeEntry(*entIt).c_str());
6088
6089     // Check that the entry corresponds to a real object in the Study
6090     // as the object may be deleted or modified after the visual state is saved.
6091     _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6092     if (!so) continue; //Skip the not existent entry
6093
6094     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6095     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6096
6097     std::vector<std::string>::iterator namesIt = paramNames.begin();
6098     std::vector<std::string>::iterator valuesIt = paramValues.begin();
6099
6100     // actors are stored in a map after displaying of them for
6101     // quicker access in the future: map < viewID to actor >
6102     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6103
6104     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6105     {
6106       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6107       // '_' is used as separator and should not be used in viewer type or parameter names.
6108       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6109       if (lst.size() != 3)
6110         continue;
6111
6112       QString viewerTypStr = lst[0];
6113       QString viewIndexStr = lst[1];
6114       QString paramNameStr = lst[2];
6115
6116       bool ok;
6117       int viewIndex = viewIndexStr.toUInt(&ok);
6118       if (!ok) // bad conversion of view index to integer
6119         continue;
6120
6121       // viewers
6122       if (viewerTypStr == SVTK_Viewer::Type())
6123       {
6124         SMESH_Actor* aSmeshActor = 0;
6125         if (vtkActors.IsBound(viewIndex))
6126           aSmeshActor = vtkActors.Find(viewIndex);
6127
6128         QList<SUIT_ViewManager*> lst;
6129         getApp()->viewManagers(viewerTypStr, lst);
6130
6131         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6132         SUIT_ViewManager* vman = NULL;
6133         if (viewIndex >= 0 && viewIndex < lst.count())
6134           vman = lst.at(viewIndex);
6135
6136         if (paramNameStr == "Visibility")
6137         {
6138           if (!aSmeshActor && displayer() && vman)
6139           {
6140             SUIT_ViewModel* vmodel = vman->getViewModel();
6141             // SVTK view model can be casted to SALOME_View
6142             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6143
6144             // store displayed actor in a temporary map for quicker
6145             // access later when restoring other parameters
6146             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6147             vtkRenderer* Renderer = vtkView->getRenderer();
6148             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6149             vtkActorCollection* theActors = aCopy.GetActors();
6150             theActors->InitTraversal();
6151             bool isFound = false;
6152             vtkActor *ac = theActors->GetNextActor();
6153             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6154               if (ac->IsA("SMESH_Actor")) {
6155                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6156                 if (aGeomAc->hasIO()) {
6157                   Handle(SALOME_InteractiveObject) io =
6158                     Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6159                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6160                     isFound = true;
6161                     vtkActors.Bind(viewIndex, aGeomAc);
6162                   }
6163                 }
6164               }
6165             }
6166           }
6167         } // if (paramNameStr == "Visibility")
6168         else
6169         {
6170           // the rest properties "work" with SMESH_Actor
6171           if (aSmeshActor)
6172           {
6173             QString val ((*valuesIt).c_str());
6174
6175             // Representation
6176             if (paramNameStr == "Representation") {
6177               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6178             }
6179             // IsShrunk
6180             else if (paramNameStr == "IsShrunk") {
6181               if (val.toInt()) {
6182                 if (!aSmeshActor->IsShrunk())
6183                   aSmeshActor->SetShrink();
6184               }
6185               else {
6186                 if (aSmeshActor->IsShrunk())
6187                   aSmeshActor->UnShrink();
6188               }
6189             }
6190             // Displayed entities
6191             else if (paramNameStr == "Entities") {
6192               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6193               int aEntityMode = SMESH_Actor::eAllEntity;
6194               for ( int i = 0; i < mode.count(); i+=2 ) {
6195                 if ( i < mode.count()-1 ) {
6196                   QString type = mode[i];
6197                   bool val = mode[i+1].toInt();
6198                   if      ( type == "e" && !val )
6199                     aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6200                   else if ( type == "f" && !val )
6201                     aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6202                   else if ( type == "v" && !val )
6203                     aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6204                   else if ( type == "0d" && !val )
6205                     aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6206                   else if ( type == "b" && !val )
6207                     aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6208                 }
6209               }
6210               aSmeshActor->SetEntityMode( aEntityMode );
6211             }
6212             // Colors
6213             else if (paramNameStr == "Colors") {
6214               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6215               QColor nodeColor;
6216               QColor edgeColor;
6217               QColor faceColor;
6218               QColor volumeColor;
6219               QColor elem0dColor;
6220               QColor ballColor;
6221               QColor outlineColor;
6222               QColor orientationColor;
6223               int deltaF;
6224               int deltaV;
6225               QColor c;
6226               double r, g, b;
6227               bool bOk;
6228               // below lines are required to get default values for delta coefficients
6229               // of backface color for faces and color of reversed volumes
6230               SMESH::GetColor( "SMESH", "fill_color",   c, deltaF, "0,170,255|-100" );
6231               SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6232               for ( int i = 0; i < colors.count(); i++ ) {
6233                 QString type = colors[i];
6234                 if ( type == "surface" ) {
6235                   // face color is set by 3 values r:g:b, where
6236                   // - r,g,b - is rgb color components
6237                   if ( i+1 >= colors.count() ) break;                  // format error
6238                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6239                   if ( i+2 >= colors.count() ) break;                  // format error
6240                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6241                   if ( i+3 >= colors.count() ) break;                  // format error
6242                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6243                   faceColor.setRgbF( r, g, b );
6244                   i += 3;
6245                 }
6246                 else if ( type == "backsurface" ) {
6247                   // backface color can be defined in several ways
6248                   // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6249                   // - in latest versions, it is set as delta coefficient
6250                   bool rgbOk = false, deltaOk;
6251                   if ( i+1 >= colors.count() ) break;                  // format error
6252                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6253                   int delta = colors[i+1].toInt( &deltaOk );
6254                   i++;                                 // shift index
6255                   if ( i+1 < colors.count() )          // index is shifted to 1
6256                     g = colors[i+1].toDouble( &rgbOk );
6257                   if ( rgbOk ) i++;                    // shift index
6258                   if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6259                     b = colors[i+1].toDouble( &rgbOk );
6260                   if ( rgbOk ) i++;
6261                   // - as currently there's no way to set directly backsurface color as it was before,
6262                   // we ignore old dump where r,g,b triple was set
6263                   // - also we check that delta parameter is set properly
6264                   if ( !rgbOk && deltaOk )
6265                     deltaF = delta;
6266                 }
6267                 else if ( type == "volume" ) {
6268                   // volume color is set by 4 values r:g:b:delta, where
6269                   // - r,g,b - is a normal volume rgb color components
6270                   // - delta - is a reversed volume color delta coefficient
6271                   if ( i+1 >= colors.count() ) break;                  // format error
6272                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6273                   if ( i+2 >= colors.count() ) break;                  // format error
6274                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6275                   if ( i+3 >= colors.count() ) break;                  // format error
6276                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6277                   if ( i+4 >= colors.count() ) break;                  // format error
6278                   int delta = colors[i+4].toInt( &bOk );
6279                   if ( !bOk ) break;                                   // format error
6280                   volumeColor.setRgbF( r, g, b );
6281                   deltaV = delta;
6282                   i += 4;
6283                 }
6284                 else if ( type == "edge" ) {
6285                   // edge color is set by 3 values r:g:b, where
6286                   // - r,g,b - is rgb color components
6287                   if ( i+1 >= colors.count() ) break;                  // format error
6288                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6289                   if ( i+2 >= colors.count() ) break;                  // format error
6290                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6291                   if ( i+3 >= colors.count() ) break;                  // format error
6292                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6293                   edgeColor.setRgbF( r, g, b );
6294                   i += 3;
6295                 }
6296                 else if ( type == "node" ) {
6297                   // node color is set by 3 values r:g:b, where
6298                   // - r,g,b - is rgb color components
6299                   if ( i+1 >= colors.count() ) break;                  // format error
6300                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6301                   if ( i+2 >= colors.count() ) break;                  // format error
6302                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6303                   if ( i+3 >= colors.count() ) break;                  // format error
6304                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6305                   nodeColor.setRgbF( r, g, b );
6306                   i += 3;
6307                 }
6308                 else if ( type == "elem0d" ) {
6309                   // 0d element color is set by 3 values r:g:b, where
6310                   // - r,g,b - is rgb color components
6311                   if ( i+1 >= colors.count() ) break;                  // format error
6312                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6313                   if ( i+2 >= colors.count() ) break;                  // format error
6314                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6315                   if ( i+3 >= colors.count() ) break;                  // format error
6316                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6317                   elem0dColor.setRgbF( r, g, b );
6318                   i += 3;
6319                 }
6320                 else if ( type == "ball" ) {
6321                   // ball color is set by 3 values r:g:b, where
6322                   // - r,g,b - is rgb color components
6323                   if ( i+1 >= colors.count() ) break;                  // format error
6324                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6325                   if ( i+2 >= colors.count() ) break;                  // format error
6326                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6327                   if ( i+3 >= colors.count() ) break;                  // format error
6328                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6329                   ballColor.setRgbF( r, g, b );
6330                   i += 3;
6331                 }
6332                 else if ( type == "outline" ) {
6333                   // outline color is set by 3 values r:g:b, where
6334                   // - r,g,b - is rgb color components
6335                   if ( i+1 >= colors.count() ) break;                  // format error
6336                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6337                   if ( i+2 >= colors.count() ) break;                  // format error
6338                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6339                   if ( i+3 >= colors.count() ) break;                  // format error
6340                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6341                   outlineColor.setRgbF( r, g, b );
6342                   i += 3;
6343                 }
6344                 else if ( type == "orientation" ) {
6345                   // orientation color is set by 3 values r:g:b, where
6346                   // - r,g,b - is rgb color components
6347                   if ( i+1 >= colors.count() ) break;                  // format error
6348                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6349                   if ( i+2 >= colors.count() ) break;                  // format error
6350                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6351                   if ( i+3 >= colors.count() ) break;                  // format error
6352                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6353                   orientationColor.setRgbF( r, g, b );
6354                   i += 3;
6355                 }
6356               }
6357               // node color
6358               if ( nodeColor.isValid() )
6359                 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6360               // edge color
6361               if ( edgeColor.isValid() )
6362                 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6363               // face color
6364               if ( faceColor.isValid() )
6365                 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6366               // volume color
6367               if ( volumeColor.isValid() )
6368                 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6369               else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6370                 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6371               // 0d element color
6372               if ( elem0dColor.isValid() )
6373                 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6374               // ball color
6375               if ( ballColor.isValid() )
6376                 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6377               // outline color
6378               if ( outlineColor.isValid() )
6379                 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6380               // orientation color
6381               if ( orientationColor.isValid() )
6382                 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6383             }
6384             // Sizes
6385             else if (paramNameStr == "Sizes") {
6386               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6387               bool bOk;
6388               int lineWidth = -1;
6389               int outlineWidth = -1;
6390               int elem0dSize = -1;
6391               int ballSize = -1;
6392               double ballScale = -1.0;
6393               double shrinkSize = -1;
6394               double orientationSize = -1;
6395               bool orientation3d = false;
6396               for ( int i = 0; i < sizes.count(); i++ ) {
6397                 QString type = sizes[i];
6398                 if ( type == "line" ) {
6399                   // line (wireframe) width is given as single integer value
6400                   if ( i+1 >= sizes.count() ) break;                    // format error
6401                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6402                   lineWidth = v;
6403                   i++;
6404                 }
6405                 if ( type == "outline" ) {
6406                   // outline width is given as single integer value
6407                   if ( i+1 >= sizes.count() ) break;                    // format error
6408                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6409                   outlineWidth = v;
6410                   i++;
6411                 }
6412                 else if ( type == "elem0d" ) {
6413                   // 0d element size is given as single integer value
6414                   if ( i+1 >= sizes.count() ) break;                    // format error
6415                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6416                   elem0dSize = v;
6417                   i++;
6418                 }
6419                 else if ( type == "ball" ) {
6420                   // balls are specified by two values: size:scale, where
6421                   // - size - is a integer value specifying size
6422                   // - scale - is a double value specifying scale factor
6423                   if ( i+1 >= sizes.count() ) break;                       // format error
6424                   int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6425                   if ( i+2 >= sizes.count() ) break;                       // format error
6426                   double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6427                   ballSize = v1;
6428                   ballScale = v2;
6429                   i += 2;
6430                 }
6431                 else if ( type == "shrink" ) {
6432                   // shrink factor is given as single floating point value
6433                   if ( i+1 >= sizes.count() ) break;                          // format error
6434                   double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break;  // format error
6435                   shrinkSize = v;
6436                   i++;
6437                 }
6438                 else if ( type == "orientation" ) {
6439                   // orientation vectors are specified by two values size:3d, where
6440                   // - size - is a floating point value specifying scale factor
6441                   // - 3d - is a boolean
6442                   if ( i+1 >= sizes.count() ) break;                          // format error
6443                   double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6444                   if ( i+2 >= sizes.count() ) break;                          // format error
6445                   int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break;       // format error
6446                   orientationSize = v1;
6447                   orientation3d = (bool)v2;
6448                   i += 2;
6449                 }
6450               }
6451               // line (wireframe) width
6452               if ( lineWidth > 0 )
6453                 aSmeshActor->SetLineWidth( lineWidth );
6454               // outline width
6455               if ( outlineWidth > 0 )
6456                 aSmeshActor->SetOutlineWidth( outlineWidth );
6457               else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6458                 aSmeshActor->SetOutlineWidth( lineWidth );
6459               // 0d element size
6460               if ( elem0dSize > 0 )
6461                 aSmeshActor->Set0DSize( elem0dSize );
6462               // ball size
6463               if ( ballSize > 0 )
6464                 aSmeshActor->SetBallSize( ballSize );
6465               // ball scale
6466               if ( ballScale > 0.0 )
6467                 aSmeshActor->SetBallScale( ballScale );
6468               // shrink factor
6469               if ( shrinkSize > 0 )
6470                 aSmeshActor->SetShrinkFactor( shrinkSize );
6471               // orientation vectors
6472               if ( orientationSize > 0 ) {
6473                 aSmeshActor->SetFacesOrientationScale( orientationSize );
6474                 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6475               }
6476             }
6477             // Point marker
6478             else if (paramNameStr == "PointMarker") {
6479               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6480               if( data.count() >= 2 ) {
6481                 bool ok = false;
6482                 int aParam1 = data[1].toInt( &ok );
6483                 if( ok ) {
6484                   if( data[0] == "std" && data.count() == 3 ) {
6485                     int aParam2 = data[2].toInt( &ok );
6486                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6487                   }
6488                   else if( data[0] == "custom" ) {
6489                     VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6490                     if( markerIt != aMarkerMap.end() ) {
6491                       VTK::MarkerData aMarkerData = markerIt->second;
6492                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6493                     }
6494                   }
6495                 }
6496               }
6497             }
6498             // Opacity
6499             else if (paramNameStr == "Opacity") {
6500               aSmeshActor->SetOpacity(val.toFloat());
6501             }
6502             // Clipping
6503             else if (paramNameStr.startsWith("ClippingPlane")) {
6504               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6505               // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6506               // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6507               // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6508               // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6509               // new format - val looks like "Off" or "0" (plane id)
6510               // (note: in new format "Off" value is used only for consistency,
6511               //  so it is processed together with values in old format)
6512               bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6513               if( anIsOldFormat ) {
6514                 if (paramNameStr == "ClippingPlane1" || val == "Off")
6515                   aSmeshActor->RemoveAllClippingPlanes();
6516                 if (val != "Off") {
6517                   QList<SUIT_ViewManager*> lst;
6518                   getApp()->viewManagers(viewerTypStr, lst);
6519                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6520                   if (viewIndex >= 0 && viewIndex < lst.count()) {
6521                     SUIT_ViewManager* vman = lst.at(viewIndex);
6522                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6523
6524                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6525
6526                     SMESH::TActorList anActorList;
6527                     anActorList.push_back( aSmeshActor );
6528                     SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6529                     aPlane->myViewWindow = vtkView;
6530                     SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6531                     aPlane->PlaneMode = aMode;
6532                     bool isOpenGLClipping = ( bool )vals[1].toInt();
6533                     aPlane->IsOpenGLClipping = isOpenGLClipping;
6534                     if ( aMode == SMESH::Absolute ) {
6535                       aPlane->myAbsoluteOrientation = vals[2].toInt();
6536                       aPlane->X = vals[3].toFloat();
6537                       aPlane->Y = vals[4].toFloat();
6538                       aPlane->Z = vals[5].toFloat();
6539                       aPlane->Dx = vals[6].toFloat();
6540                       aPlane->Dy = vals[7].toFloat();
6541                       aPlane->Dz = vals[8].toFloat();
6542                     }
6543                     else if ( aMode == SMESH::Relative ) {
6544                       aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6545                       aPlane->myDistance = vals[3].toFloat();
6546                       aPlane->myAngle[0] = vals[4].toFloat();
6547                       aPlane->myAngle[1] = vals[5].toFloat();
6548                     }
6549
6550                     if( aPlane ) {
6551                       if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6552                         SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6553                         aClippingPlaneInfo.Plane = aPlane;
6554                         aClippingPlaneInfo.ActorList = anActorList;
6555                         aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6556                       }
6557                     }
6558                   }
6559                 }
6560               }
6561               else {
6562                 bool ok = false;
6563                 int aPlaneId = val.toInt( &ok );
6564                 if( ok && aPlaneId >= 0 ) {
6565                   bool anIsDefinedPlane = false;
6566                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6567                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6568                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6569                     TPlaneInfo& aPlaneInfo = *anIter;
6570                     if( aPlaneInfo.PlaneId == aPlaneId ) {
6571                       aPlaneInfo.ActorList.push_back( aSmeshActor );
6572                       anIsDefinedPlane = true;
6573                       break;
6574                     }
6575                   }
6576                   if( !anIsDefinedPlane ) {
6577                     TPlaneInfo aPlaneInfo;
6578                     aPlaneInfo.PlaneId = aPlaneId;
6579                     aPlaneInfo.ActorList.push_back( aSmeshActor );
6580                     aPlaneInfo.ViewManager = vman;
6581
6582                     // to make the list sorted by plane id
6583                     anIter = aPlaneInfoList.begin();
6584                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6585                       const TPlaneInfo& aPlaneInfoRef = *anIter;
6586                       if( aPlaneInfoRef.PlaneId > aPlaneId )
6587                         break;
6588                     }
6589                     aPlaneInfoList.insert( anIter, aPlaneInfo );
6590                   }
6591                 }
6592               }
6593             }
6594           } // if (aSmeshActor)
6595         } // other parameters than Visibility
6596       }
6597     } // for names/parameters iterator
6598   } // for entries iterator
6599
6600   // take into account planes with empty list of actors referred to them
6601   QList<SUIT_ViewManager*> aVMList;
6602   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6603
6604   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6605   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6606     int aViewId = aPlaneDataIter->first;
6607     if( aViewId >= 0 && aViewId < aVMList.count() ) {
6608       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6609
6610       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6611
6612       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6613       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6614       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6615         const TPlaneData& aPlaneData = *anIter2;
6616         int aPlaneId = aPlaneData.Id;
6617
6618         bool anIsFound = false;
6619         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6620         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6621           const TPlaneInfo& aPlaneInfo = *anIter3;
6622           if( aPlaneInfo.PlaneId == aPlaneId ) {
6623             anIsFound = true;
6624             break;
6625           }
6626         }
6627
6628         if( !anIsFound ) {
6629           TPlaneInfo aPlaneInfo; // ActorList field is empty
6630           aPlaneInfo.PlaneId = aPlaneId;
6631           aPlaneInfo.ViewManager = aViewManager;
6632
6633           // to make the list sorted by plane id
6634           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6635           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6636             const TPlaneInfo& aPlaneInfoRef = *anIter4;
6637             if( aPlaneInfoRef.PlaneId > aPlaneId )
6638               break;
6639           }
6640           aPlaneInfoList.insert( anIter4, aPlaneInfo );
6641         }
6642       }
6643     }
6644   }
6645
6646   // add clipping planes to actors according to the restored parameters
6647   // and update the clipping plane map
6648   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6649   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6650     int aViewId = anIter1->first;
6651     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6652
6653     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6654     if( anIter2 == aPlaneDataMap.end() )
6655       continue;
6656     const TPlaneDataList& aPlaneDataList = anIter2->second;
6657
6658     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6659     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6660       const TPlaneInfo& aPlaneInfo = *anIter3;
6661       int aPlaneId = aPlaneInfo.PlaneId;
6662       const TActorList& anActorList = aPlaneInfo.ActorList;
6663       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6664       if( !aViewManager )
6665         continue;
6666
6667       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6668       if( !aViewWindow )
6669         continue;
6670
6671       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6672
6673       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6674       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6675         const TPlaneData& aPlaneData = *anIter4;
6676         if( aPlaneData.Id == aPlaneId ) {
6677           SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6678           aPlane->myViewWindow = aViewWindow;
6679           aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6680           aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6681           if ( aPlane->PlaneMode == SMESH::Absolute ) {
6682             aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6683             aPlane->X = aPlaneData.X;
6684             aPlane->Y = aPlaneData.Y;
6685             aPlane->Z = aPlaneData.Z;
6686             aPlane->Dx = aPlaneData.Dx;
6687             aPlane->Dy = aPlaneData.Dy;
6688             aPlane->Dz = aPlaneData.Dz;
6689           }
6690           else if ( aPlane->PlaneMode == SMESH::Relative ) {
6691             aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6692             aPlane->myDistance = aPlaneData.Distance;
6693             aPlane->myAngle[0] = aPlaneData.Angle[0];
6694             aPlane->myAngle[1] = aPlaneData.Angle[1];
6695           }
6696           if( aPlane ) {
6697             if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6698               SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6699               aClippingPlaneInfo.Plane = aPlane;
6700               aClippingPlaneInfo.ActorList = anActorList;
6701               aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6702             }
6703           }
6704           break;
6705         }
6706       }
6707
6708     }
6709   }
6710
6711
6712   // update all VTK views
6713   QList<SUIT_ViewManager*> lst;
6714   getApp()->viewManagers(lst);
6715   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6716     SUIT_ViewModel* vmodel = (*it)->getViewModel();
6717     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6718       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6719       // set OpenGL clipping planes
6720       VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6721       vtkActorCollection* anAllActors = aCopy.GetActors();
6722       anAllActors->InitTraversal();
6723       while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6724         if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6725           anActor->SetOpenGLClippingPlane();
6726
6727       vtkView->getRenderer()->ResetCameraClippingRange();
6728       vtkView->Repaint();
6729     }
6730   }
6731 }
6732
6733 /*!
6734   \brief Adds preferences for dfont of VTK viewer
6735   \param label label
6736   \param pIf group identifier
6737   \param param parameter
6738   \return identifier of preferences
6739 */
6740 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6741 {
6742   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6743
6744   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6745
6746   QStringList fam;
6747   fam.append( tr( "SMESH_FONT_ARIAL" ) );
6748   fam.append( tr( "SMESH_FONT_COURIER" ) );
6749   fam.append( tr( "SMESH_FONT_TIMES" ) );
6750
6751   setPreferenceProperty( tfont, "fonts", fam );
6752
6753   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6754   if ( needSize ) f = f | QtxFontEdit::Size;
6755   setPreferenceProperty( tfont, "features", f );
6756
6757   return tfont;
6758 }
6759
6760 /*!
6761   \brief Actions after hypothesis edition
6762   Updates object browser after hypothesis edition
6763 */
6764 void SMESHGUI::onHypothesisEdit( int result )
6765 {
6766   if( result == 1 )
6767     SMESHGUI::Modified();
6768   updateObjBrowser( true );
6769 }
6770
6771
6772 /*!
6773   \brief Signal handler closing(SUIT_ViewWindow*) of a view
6774   \param pview view being closed
6775 */
6776 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6777 #ifndef DISABLE_PLOT2DVIEWER
6778   //Crear all Plot2d Viewers if need.
6779   SMESH::ClearPlot2Viewers(pview);
6780 #endif
6781 }
6782
6783 void SMESHGUI::message( const QString& msg )
6784 {
6785   // dispatch message
6786   QStringList data = msg.split("/");
6787   if ( data.count() > 0 ) {
6788     if ( data.first() == "mesh_loading" ) {
6789       // get mesh entry
6790       QString entry = data.count() > 1 ? data[1] : QString();
6791       if ( entry.isEmpty() )
6792         return;
6793       // get study
6794       _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6795       // get mesh name
6796       _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6797       QString name;
6798       if ( obj )
6799         name = QString::fromUtf8(obj->GetName().c_str());
6800       if ( name.isEmpty() )
6801         return;
6802
6803       if ( data.last() == "stop" )
6804         application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6805       else
6806         application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6807       QApplication::processEvents();
6808     }
6809   }
6810 }
6811
6812 /*!
6813   \brief Connects or disconnects signals about activating and cloning view on the module slots
6814   \param pview view which is connected/disconnected
6815 */
6816 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6817   if(!pview)
6818     return;
6819
6820   SUIT_ViewManager* viewMgr = pview->getViewManager();
6821   if ( viewMgr ) {
6822     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6823                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6824
6825     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6826              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6827   }
6828 }
6829
6830 /*!
6831   \brief Return \c true if object can be renamed
6832 */
6833 bool SMESHGUI::renameAllowed( const QString& entry) const {
6834   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6835   if( !anApp )
6836     return false;
6837
6838   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6839   if( !appStudy )
6840     return false;
6841
6842   SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6843
6844   if(!obj)
6845     return false;
6846
6847   if(appStudy->isComponent(entry) || obj->isReference())
6848     return false;
6849
6850   // check type to prevent renaming of inappropriate objects
6851   int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6852   if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6853       aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6854       aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6855       aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6856       aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6857     return true;
6858
6859   return false;
6860 }
6861
6862 /*!
6863   Rename object by entry.
6864   \param entry entry of the object
6865   \param name new name of the object
6866   \brief Return \c true if rename operation finished successfully, \c false otherwise.
6867 */
6868 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6869
6870   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6871   if( !anApp )
6872     return false;
6873
6874   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6875
6876   if(!appStudy)
6877     return false;
6878
6879   _PTR(Study) aStudy = appStudy->studyDS();
6880
6881   if(!aStudy)
6882     return false;
6883
6884   bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6885   if ( aLocked ) {
6886     SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6887     return false;
6888   }
6889
6890
6891   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6892   _PTR(GenericAttribute) anAttr;
6893   _PTR(AttributeName) aName;
6894   if ( obj ) {
6895     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6896       aName = anAttr;
6897       // check type to prevent renaming of inappropriate objects
6898       int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6899       if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6900           aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6901           aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6902           aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6903           aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6904         if ( !name.isEmpty() ) {
6905           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6906
6907           // update name of group object and its actor
6908           Handle(SALOME_InteractiveObject) IObject =
6909             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6910
6911           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6912           if( !aGroupObject->_is_nil() ) {
6913             aGroupObject->SetName( qPrintable(name) );
6914             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6915               anActor->setName( qPrintable(name) );
6916           }
6917           return true;
6918         }
6919       }
6920     }
6921   }
6922   return false;
6923 }
6924
6925 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6926 {
6927   static QList<QColor> colors;
6928
6929   if ( colors.isEmpty() ) {
6930
6931     for (int s = 0; s < 2 ; s++)
6932     {
6933       for (int v = 100; v >= 40; v = v - 20)
6934       {
6935         for (int h = 0; h < 359 ; h = h + 60)
6936         {
6937           colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
6938         }
6939       }
6940     }
6941   }
6942   static int currentColor = 0;
6943
6944   SALOMEDS::Color color;
6945   color.R = (double)colors[currentColor].red()   / 255.0;
6946   color.G = (double)colors[currentColor].green() / 255.0;
6947   color.B = (double)colors[currentColor].blue()  / 255.0;
6948
6949   currentColor = (currentColor+1) % colors.count();
6950
6951   return color;
6952 }