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