src/SMESHGUI/SMESHGUI.cxx

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