src/SMESHGUI/SMESHGUI.cxx

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