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