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