src/SMESHGUI/SMESHGUI.cxx

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