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