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