src/SMESHGUI/SMESHGUI.cxx

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