src/SMESHGUI/SMESHGUI.cxx

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