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