src/SMESHGUI/SMESHGUI.cxx

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