src/SMESHGUI/SMESHGUI.cxx

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