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