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