src/SMESHGUI/SMESHGUI.cxx

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