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