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