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