src/SMESHGUI/SMESHGUI.cxx

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