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       updateObjBrowser(); // objects can be removed
4796     }
4797
4798   // get all view currently opened in the study and connect their signals  to
4799   // the corresponding slots of the class.
4800   SUIT_Desktop* aDesk = study->application()->desktop();
4801   if ( aDesk ) {
4802     QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4803     SUIT_ViewWindow* wnd;
4804     foreach ( wnd, wndList )
4805       connectView( wnd );
4806   }
4807
4808   Py_XDECREF(pluginsmanager);
4809   return res;
4810 }
4811
4812 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4813 {
4814   setMenuShown( false );
4815   setToolShown( false );
4816
4817   EmitSignalCloseAllDialogs();
4818
4819   // Unset actions accelerator keys
4820   action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4821
4822   return SalomeApp_Module::deactivateModule( study );
4823 }
4824
4825 void SMESHGUI::studyClosed( SUIT_Study* s )
4826 {
4827   if( !s )
4828     return;
4829   SMESH::RemoveVisuData( s->id() );
4830   SalomeApp_Module::studyClosed( s );
4831 }
4832
4833 void SMESHGUI::OnGUIEvent()
4834 {
4835   const QObject* obj = sender();
4836   if ( !obj || !obj->inherits( "QAction" ) )
4837     return;
4838   int id = actionId((QAction*)obj);
4839   if ( id != -1 )
4840     OnGUIEvent( id );
4841 }
4842
4843 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4844 {
4845   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4846   if ( CORBA::is_nil( myComponentSMESH ) )
4847     {
4848       SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4849       if ( aStudy )
4850         aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4851       return aGUI.myComponentSMESH;
4852     }
4853   if ( aStudy )
4854     myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4855   return myComponentSMESH;
4856 }
4857
4858 QString SMESHGUI::engineIOR() const
4859 {
4860   CORBA::ORB_var anORB = getApp()->orb();
4861   CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4862   return QString( anIOR.in() );
4863 }
4864
4865 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4866 {
4867   SalomeApp_Module::contextMenuPopup( client, menu, title );
4868   SALOME_ListIO lst;
4869   selectionMgr()->selectedObjects( lst );
4870   if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4871     Handle(SALOME_InteractiveObject) io = lst.First();
4872     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4873     _PTR(Study) study = appStudy->studyDS();
4874     _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4875     if ( obj ) {
4876       QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4877       while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4878           aName.remove( (aName.length() - 1), 1 );
4879       title = aName;
4880     }
4881   }
4882 }
4883
4884 LightApp_Selection* SMESHGUI::createSelection() const
4885 {
4886   return new SMESHGUI_Selection();
4887 }
4888
4889 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4890 {
4891   aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4892   aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4893 #ifndef DISABLE_PYCONSOLE
4894   aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4895 #endif
4896 }
4897
4898 void SMESHGUI::viewManagers( QStringList& list ) const
4899 {
4900   list.append( SVTK_Viewer::Type() );
4901 }
4902
4903 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4904 {
4905   if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4906     SMESH::UpdateSelectionProp( this );
4907
4908     QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4909     for(int i = 0; i < aViews.count() ; i++){
4910       SUIT_ViewWindow *sf = aViews[i];
4911       connectView( sf );
4912     }
4913     EmitSignalActivatedViewManager();
4914   }
4915 }
4916
4917 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4918 {
4919   if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4920     myClippingPlaneInfoMap.erase( theViewManager );
4921 }
4922
4923 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4924 {
4925   theActor->AddObserver( SMESH::DeleteActorEvent,
4926                          myEventCallbackCommand.GetPointer(),
4927                          myPriority );
4928 }
4929
4930 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4931                               unsigned long theEvent,
4932                               void* theClientData,
4933                               void* theCallData )
4934 {
4935   if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4936     if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4937       if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4938         SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4939         SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4940         for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4941           SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4942           SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4943           for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4944             SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4945             std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4946             SMESH::TActorList::iterator anIter3 = anActorList.begin();
4947             for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4948               if( anActor == *anIter3 ) {
4949                 anActorList.erase( anIter3 );
4950                 break;
4951               }
4952             }
4953           }
4954         }
4955       }
4956     }
4957   }
4958 }
4959
4960 void SMESHGUI::createPreferences()
4961 {
4962   // General tab ------------------------------------------------------------------------
4963   int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4964
4965   int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4966   setPreferenceProperty( autoUpdate, "columns", 2 );
4967   int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4968   setPreferenceProperty( lim, "min",  0 );
4969   setPreferenceProperty( lim, "max",  100000000 );
4970   setPreferenceProperty( lim, "step", 1000 );
4971   setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4972   addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4973
4974   int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4975   setPreferenceProperty( qaGroup, "columns", 2 );
4976   addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4977   addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4978   int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4979   setPreferenceProperty( prec, "min", 0 );
4980   setPreferenceProperty( prec, "max", 100 );
4981   int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4982   setPreferenceProperty( doubleNodesTol, "precision", 10 );
4983   setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4984   setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4985   setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4986
4987   int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
4988   setPreferenceProperty( dispgroup, "columns", 2 );
4989   int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4990   QStringList modes;
4991   modes.append( tr("MEN_WIRE") );
4992   modes.append( tr("MEN_SHADE") );
4993   modes.append( tr("MEN_NODES") );
4994   modes.append( tr("MEN_SHRINK") );
4995   QList<QVariant> indices;
4996   indices.append( 0 );
4997   indices.append( 1 );
4998   indices.append( 2 );
4999   indices.append( 3 );
5000   setPreferenceProperty( dispmode, "strings", modes );
5001   setPreferenceProperty( dispmode, "indexes", indices );
5002
5003   int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5004   setPreferenceProperty( arcgroup, "columns", 2 );
5005   int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5006   QStringList quadraticModes;
5007   quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5008   quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5009   indices.clear();
5010   indices.append( 0 );
5011   indices.append( 1 );
5012   setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5013   setPreferenceProperty( quadraticmode, "indexes", indices );
5014
5015   int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5016                               "SMESH", "max_angle" );
5017   setPreferenceProperty( maxAngle, "min", 1 );
5018   setPreferenceProperty( maxAngle, "max", 90 );
5019
5020
5021
5022   int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5023   setPreferenceProperty( exportgroup, "columns", 2 );
5024   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5025   //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5026
5027   int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5028   setPreferenceProperty( computeGroup, "columns", 2 );
5029   int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5030   modes.clear();
5031   modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5032   modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5033   modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5034   indices.clear();
5035   indices.append( 0 );
5036   indices.append( 1 );
5037   indices.append( 2 );
5038   setPreferenceProperty( notifyMode, "strings", modes );
5039   setPreferenceProperty( notifyMode, "indexes", indices );
5040
5041   int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5042   setPreferenceProperty( infoGroup, "columns", 2 );
5043   int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5044   modes.clear();
5045   modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5046   modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5047   indices.clear();
5048   indices.append( 0 );
5049   indices.append( 1 );
5050   setPreferenceProperty( elemInfo, "strings", modes );
5051   setPreferenceProperty( elemInfo, "indexes", indices );
5052   int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5053   setPreferenceProperty( nodesLim, "min", 0 );
5054   setPreferenceProperty( nodesLim, "max", 10000000 );
5055   setPreferenceProperty( nodesLim, "step", 10000 );
5056   setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5057   int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5058   setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5059   setPreferenceProperty( ctrlLim, "min", 0 );
5060   setPreferenceProperty( ctrlLim, "max", 10000000 );
5061   setPreferenceProperty( ctrlLim, "step", 1000 );
5062   addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5063   addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5064   addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5065   addPreference( tr( "PREF_DUMP_ADD_INFO"  ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5066   addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5067
5068   int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5069   setPreferenceProperty( segGroup, "columns", 2 );
5070   int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5071                               "SMESH", "segmentation" );
5072   setPreferenceProperty( segLen, "min", 1 );
5073   setPreferenceProperty( segLen, "max", 10000000 );
5074   int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5075                              "SMESH", "nb_segments_per_edge" );
5076   setPreferenceProperty( nbSeg, "min", 1 );
5077   setPreferenceProperty( nbSeg, "max", 10000000 );
5078
5079   int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5080   addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5081                  "SMESH", "forget_mesh_on_hyp_modif" );
5082
5083
5084   // Quantities with individual precision settings
5085   int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5086   setPreferenceProperty( precGroup, "columns", 2 );
5087
5088   const int nbQuantities = 6;
5089   int precs[nbQuantities], ii = 0;
5090   precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5091                             LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5092   precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5093                             LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5094   precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5095                             LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5096   precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5097                             LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5098   precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5099                             LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5100   precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5101                             LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5102
5103   // Set property for precision value for spinboxes
5104   for ( ii = 0; ii < nbQuantities; ii++ ){
5105     setPreferenceProperty( precs[ii], "min", -14 );
5106     setPreferenceProperty( precs[ii], "max", 14 );
5107     setPreferenceProperty( precs[ii], "precision", 2 );
5108   }
5109
5110   int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5111   setPreferenceProperty( previewGroup, "columns", 2 );
5112   int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5113   setPreferenceProperty( chunkSize, "min",  1 );
5114   setPreferenceProperty( chunkSize, "max",  1000 );
5115   setPreferenceProperty( chunkSize, "step", 50 );
5116
5117   int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5118   addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5119
5120   // Mesh tab ------------------------------------------------------------------------
5121   int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5122   int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5123   setPreferenceProperty( nodeGroup, "columns", 3 );
5124
5125   addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5126
5127   int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5128
5129   SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5130   QList<QVariant> aMarkerTypeIndicesList;
5131   QList<QVariant> aMarkerTypeIconsList;
5132   for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5133     QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5134     QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5135     aMarkerTypeIndicesList << i;
5136     aMarkerTypeIconsList << pixmap;
5137   }
5138   setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5139   setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );
5140
5141   int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5142
5143   QList<QVariant> aMarkerScaleIndicesList;
5144   QStringList     aMarkerScaleValuesList;
5145   for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5146     aMarkerScaleIndicesList << i;
5147     aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5148   }
5149   setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5150   setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5151
5152   int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5153   //setPreferenceProperty( elemGroup, "columns", 2 );
5154
5155   int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5156   setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5157   ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5158   setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5159   addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5160   addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5161   addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5162   addPreference( tr( "PREF_WIREFRAME"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5163   addPreference( tr( "PREF_PREVIEW_COLOR"  ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5164
5165
5166   int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5167   setPreferenceProperty( grpGroup, "columns", 2 );
5168
5169   addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5170   addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5171
5172   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5173                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5174   /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5175                              LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5176   double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5177                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5178   double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5179                              LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5180   int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
5181                              LightApp_Preferences::IntSpin, "SMESH", "element_width");
5182   int outW  = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5183                              LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5184   int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5185                              LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5186
5187   setPreferenceProperty( size0d, "min", 1 );
5188   setPreferenceProperty( size0d, "max", 10 );
5189
5190  // setPreferenceProperty( ballSize, "min", 1 );
5191  // setPreferenceProperty( ballSize, "max", 10 );
5192
5193   setPreferenceProperty( ballDiameter, "min", 1e-7 );
5194   setPreferenceProperty( ballDiameter, "max", 1e9 );
5195   setPreferenceProperty( ballDiameter, "step", 0.1 );
5196
5197   setPreferenceProperty( ballScale, "min", 1e-2 );
5198   setPreferenceProperty( ballScale, "max", 1e7 );
5199   setPreferenceProperty( ballScale, "step", 0.5 );
5200
5201   setPreferenceProperty( elemW, "min", 1 );
5202   setPreferenceProperty( elemW, "max", 5 );
5203
5204   setPreferenceProperty( outW, "min", 1 );
5205   setPreferenceProperty( outW, "max", 5 );
5206
5207   setPreferenceProperty( shrink, "min", 0 );
5208   setPreferenceProperty( shrink, "max", 100 );
5209
5210   int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5211   setPreferenceProperty( numGroup, "columns", 2 );
5212
5213   addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5214   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5215
5216   addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5217   addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5218
5219   int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5220   setPreferenceProperty( orientGroup, "columns", 1 );
5221
5222   addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5223   int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5224
5225   setPreferenceProperty( orientScale, "min", 0.05 );
5226   setPreferenceProperty( orientScale, "max", 0.5 );
5227   setPreferenceProperty( orientScale, "step", 0.05 );
5228
5229   addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5230
5231   // Selection tab ------------------------------------------------------------------------
5232   int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5233
5234   int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5235   setPreferenceProperty( selGroup, "columns", 2 );
5236
5237   addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5238   addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5239
5240   int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5241   setPreferenceProperty( preGroup, "columns", 2 );
5242
5243   addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5244
5245   int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5246   setPreferenceProperty( precSelGroup, "columns", 2 );
5247
5248   addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5249   addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5250   addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5251
5252   // Scalar Bar tab ------------------------------------------------------------------------
5253   int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5254   int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5255   setPreferenceProperty( fontGr, "columns", 2 );
5256
5257   addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5258   addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5259
5260   addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5261   addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5262
5263   int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5264   setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5265
5266   int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5267   setPreferenceProperty( numcol, "min", 2 );
5268   setPreferenceProperty( numcol, "max", 256 );
5269
5270   int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5271   setPreferenceProperty( numlab, "min", 2 );
5272   setPreferenceProperty( numlab, "max", 65 );
5273
5274   int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5275   setPreferenceProperty( orientGr, "columns", 2 );
5276   int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5277   QStringList orients;
5278   orients.append( tr( "SMESH_VERTICAL" ) );
5279   orients.append( tr( "SMESH_HORIZONTAL" ) );
5280   indices.clear(); indices.append( 0 ); indices.append( 1 );
5281   setPreferenceProperty( orient, "strings", orients );
5282   setPreferenceProperty( orient, "indexes", indices );
5283
5284   int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5285   setPreferenceProperty( posVSizeGr, "columns", 2 );
5286   int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5287   int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5288   int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5289   int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5290   setPreferenceProperty( xv, "step", 0.1 );
5291   setPreferenceProperty( xv, "min", 0.0 );
5292   setPreferenceProperty( xv, "max", 1.0 );
5293   setPreferenceProperty( yv, "step", 0.1 );
5294   setPreferenceProperty( yv, "min", 0.0 );
5295   setPreferenceProperty( yv, "max", 1.0 );
5296   setPreferenceProperty( wv, "step", 0.1 );
5297   setPreferenceProperty( wv, "min", 0.0 );
5298   setPreferenceProperty( wv, "max", 1.0 );
5299   setPreferenceProperty( hv, "min", 0.0 );
5300   setPreferenceProperty( hv, "max", 1.0 );
5301   setPreferenceProperty( hv, "step", 0.1 );
5302
5303   int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5304   setPreferenceProperty( posHSizeGr, "columns", 2 );
5305   int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5306   int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5307   int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5308   int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5309   setPreferenceProperty( xv, "min", 0.0 );
5310   setPreferenceProperty( xv, "max", 1.0 );
5311   setPreferenceProperty( xv, "step", 0.1 );
5312   setPreferenceProperty( xh, "min", 0.0 );
5313   setPreferenceProperty( xh, "max", 1.0 );
5314   setPreferenceProperty( xh, "step", 0.1 );
5315   setPreferenceProperty( yh, "min", 0.0 );
5316   setPreferenceProperty( yh, "max", 1.0 );
5317   setPreferenceProperty( yh, "step", 0.1 );
5318   setPreferenceProperty( wh, "min", 0.0 );
5319   setPreferenceProperty( wh, "max", 1.0 );
5320   setPreferenceProperty( wh, "step", 0.1 );
5321   setPreferenceProperty( hh, "min", 0.0 );
5322   setPreferenceProperty( hh, "max", 1.0 );
5323   setPreferenceProperty( hh, "step", 0.1 );
5324
5325   int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5326   int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5327   setPreferenceProperty( distributionGr, "columns", 3 );
5328   QStringList types;
5329   types.append( tr( "SMESH_MONOCOLOR" ) );
5330   types.append( tr( "SMESH_MULTICOLOR" ) );
5331   indices.clear(); indices.append( 0 ); indices.append( 1 );
5332   setPreferenceProperty( coloringType, "strings", types );
5333   setPreferenceProperty( coloringType, "indexes", indices );
5334   addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5335
5336 }
5337
5338 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5339 {
5340   if( sect=="SMESH" ) {
5341     float sbX1,sbY1,sbW,sbH;
5342     float aTol = 1.00000009999999;
5343     std::string aWarning;
5344     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5345     if( name=="selection_object_color" || name=="selection_element_color" ||
5346         name=="highlight_color" ||
5347         name=="selection_precision_node" || name=="selection_precision_element" ||
5348         name=="selection_precision_object")
5349       SMESH::UpdateSelectionProp( this );
5350     else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5351       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5352       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5353       if(sbX1+sbW > aTol){
5354         aWarning = "Origin and Size Vertical: X+Width > 1\n";
5355         sbX1=0.01;
5356         sbW=0.08;
5357         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5358         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5359       }
5360     }
5361     else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5362       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5363       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5364       if(sbY1+sbH > aTol){
5365         aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5366         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5367         aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5368       }
5369     }
5370     else if(name ==  QString("scalar_bar_horizontal_x") || name ==  QString("scalar_bar_horizontal_width")){
5371       sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5372       sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5373       if(sbX1+sbW > aTol){
5374         aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5375         sbX1=0.1;
5376         sbW=0.08;
5377         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5378         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5379       }
5380     }
5381     else if(name ==  QString("scalar_bar_horizontal_y") || name ==  QString("scalar_bar_horizontal_height")){
5382       sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5383       sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5384       if(sbY1+sbH > aTol){
5385         aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5386         sbY1=0.01;
5387         sbH=0.08;
5388         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5389         aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5390       }
5391     }
5392     else if ( name == "segmentation" ) {
5393       int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5394       myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5395     }
5396     else if ( name == "nb_segments_per_edge" ) {
5397       int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5398       myComponentSMESH->SetDefaultNbSegments( nbSeg );
5399     }
5400     else if ( name == "historical_python_dump" ||
5401               name == "forget_mesh_on_hyp_modif") {
5402       QString val = aResourceMgr->stringValue( "SMESH", name );
5403       myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5404     }
5405     else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5406       SMESH::UpdateFontProp( this );
5407     }
5408     else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5409       SMESH::UpdateFontProp( this );
5410     }
5411
5412     if(aWarning.size() != 0){
5413       aWarning += "The default values are applied instead.";
5414       SUIT_MessageBox::warning(SMESHGUI::desktop(),
5415                                QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5416                                QObject::tr(aWarning.c_str()));
5417     }
5418   }
5419 }
5420
5421 //================================================================================
5422 /*!
5423  * \brief Update something in accordance with update flags
5424   * \param theFlags - update flags
5425 *
5426 * Update viewer or/and object browser etc. in accordance with update flags ( see
5427 * LightApp_UpdateFlags enumeration ).
5428 */
5429 //================================================================================
5430 void SMESHGUI::update( const int flags )
5431 {
5432   if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5433     SMESH::UpdateView();
5434   else
5435     SalomeApp_Module::update( flags );
5436 }
5437
5438 //================================================================================
5439 /*!
5440  * \brief Set default selection mode
5441 *
5442 * SLOT called when operation commited. Sets default selection mode
5443 */
5444 //================================================================================
5445 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5446 {
5447   SVTK_ViewWindow* vtkWnd =
5448     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5449   if ( vtkWnd )
5450     vtkWnd->SetSelectionMode( ActorSelection );
5451 }
5452
5453 //================================================================================
5454 /*!
5455  * \brief Set default selection mode
5456 *
5457 * SLOT called when operation aborted. Sets default selection mode
5458 */
5459 //================================================================================
5460 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5461 {
5462   SVTK_ViewWindow* vtkWnd =
5463     dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5464   if ( vtkWnd )
5465     vtkWnd->SetSelectionMode( ActorSelection );
5466 }
5467
5468 //================================================================================
5469 /*!
5470  * \brief Creates operation with given identifier
5471   * \param id - identifier of operation to be started
5472   * \return Pointer on created operation or NULL if operation is not created
5473 *
5474 * Virtual method redefined from the base class creates operation with given id.
5475 * It is called called automatically from startOperation method of base class.
5476 */
5477 //================================================================================
5478 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5479 {
5480   LightApp_Operation* op = 0;
5481   // to do : create operation here
5482   switch( id )
5483   {
5484     case SMESHOp::OpConvertMeshToQuadratic:
5485       op = new SMESHGUI_ConvToQuadOp();
5486     break;
5487     case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5488       op = new SMESHGUI_Make2DFrom3DOp();
5489     break;
5490     case SMESHOp::OpReorientFaces:
5491       op = new SMESHGUI_ReorientFacesOp();
5492       break;
5493     case SMESHOp::OpCreateMesh:
5494       op = new SMESHGUI_MeshOp( true, true );
5495     break;
5496     case SMESHOp::OpCreateSubMesh:
5497       op = new SMESHGUI_MeshOp( true, false );
5498     break;
5499     case SMESHOp::OpEditMeshOrSubMesh:
5500       op = new SMESHGUI_MeshOp( false );
5501     break;
5502     case SMESHOp::OpCompute:
5503       op = new SMESHGUI_ComputeOp();
5504     break;
5505     case SMESHOp::OpPreCompute:
5506       op = new SMESHGUI_PrecomputeOp();
5507     break;
5508     case SMESHOp::OpEvaluate:
5509       op = new SMESHGUI_EvaluateOp();
5510     break;
5511     case SMESHOp::OpMeshOrder:
5512       op = new SMESHGUI_MeshOrderOp();
5513     break;
5514     case SMESHOp::OpCreateGeometryGroup:
5515       op = new SMESHGUI_GroupOnShapeOp();
5516       break;
5517     case SMESHOp::OpFindElementByPoint:
5518       op = new SMESHGUI_FindElemByPointOp();
5519       break;
5520     case SMESHOp::OpMoveNode: // Make mesh pass through point
5521       op = new SMESHGUI_MakeNodeAtPointOp();
5522       break;
5523     case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5524       op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5525       break;
5526     default:
5527     break;
5528   }
5529
5530   if( !op )
5531     op = SalomeApp_Module::createOperation( id );
5532   return op;
5533 }
5534
5535 //================================================================================
5536 /*!
5537  * \brief Stops current operations and starts a given one
5538   * \param id - The id of the operation to start
5539  */
5540 //================================================================================
5541
5542 void SMESHGUI::switchToOperation(int id)
5543 {
5544   if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5545     activeStudy()->abortAllOperations();
5546   startOperation( id );
5547 }
5548
5549 LightApp_Displayer* SMESHGUI::displayer()
5550 {
5551   if( !myDisplayer )
5552     myDisplayer = new SMESHGUI_Displayer( getApp() );
5553   return myDisplayer;
5554 }
5555
5556 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5557 {
5558   int aHue = -1;
5559   int aTolerance = 64;
5560   int anIterations = 0;
5561   int aPeriod = 5;
5562
5563   while( 1 )
5564   {
5565     anIterations++;
5566     if( anIterations % aPeriod == 0 )
5567     {
5568       aTolerance /= 2;
5569       if( aTolerance < 1 )
5570         break;
5571     }
5572
5573     aHue = (int)( 360.0 * rand() / RAND_MAX );
5574
5575     bool ok = true;
5576     QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5577     QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5578     for( ; it != itEnd; ++it )
5579     {
5580       SALOMEDS::Color anAutoColor = *it;
5581       QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5582
5583       int h, s, v;
5584       aQColor.getHsv( &h, &s, &v );
5585       if( abs( h - aHue ) < aTolerance )
5586       {
5587         ok = false;
5588         break;
5589       }
5590     }
5591
5592     if( ok )
5593       break;
5594   }
5595
5596   QColor aColor;
5597   aColor.setHsv( aHue, 255, 255 );
5598
5599   SALOMEDS::Color aSColor;
5600   aSColor.R = aColor.redF();
5601   aSColor.G = aColor.greenF();
5602   aSColor.B = aColor.blueF();
5603
5604   return aSColor;
5605 }
5606
5607 const char* gSeparator = "_"; // character used to separate parameter names
5608 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5609 const char* gPathSep   = "|"; // character used to separate paths
5610
5611 /*!
5612  * \brief Store visual parameters
5613  *
5614  * This method is called just before the study document is saved.
5615  * Store visual parameters in AttributeParameter attribue(s)
5616  */
5617 void SMESHGUI::storeVisualParameters (int savePoint)
5618 {
5619   // localizing
5620   Kernel_Utils::Localizer loc;
5621
5622   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5623   if (!appStudy || !appStudy->studyDS())
5624     return;
5625   _PTR(Study) studyDS = appStudy->studyDS();
5626
5627   // componentName is used for encoding of entries when storing them in IParameters
5628   std::string componentName = myComponentSMESH->ComponentDataType();
5629   //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5630   //if (!aSComponent) return;
5631
5632   // IParameters
5633   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5634                                                              componentName.c_str(),
5635                                                              savePoint);
5636   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5637
5638   // store map of custom markers
5639   const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5640   if( !aMarkerMap.empty() )
5641   {
5642     VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5643     for( ; anIter != aMarkerMap.end(); anIter++ )
5644     {
5645       int anId = anIter->first;
5646       VTK::MarkerData aMarkerData = anIter->second;
5647       std::string aMarkerFileName = aMarkerData.first;
5648       VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5649       if( aMarkerTexture.size() < 3 )
5650         continue; // should contain at least width, height and the first value
5651
5652       QString aPropertyName( "texture" );
5653       aPropertyName += gSeparator;
5654       aPropertyName += QString::number( anId );
5655
5656       QString aPropertyValue = aMarkerFileName.c_str();
5657       aPropertyValue += gPathSep;
5658
5659       VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5660       ushort aWidth = *aTextureIter++;
5661       ushort aHeight = *aTextureIter++;
5662       aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5663       aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5664       for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5665         aPropertyValue += QString::number( *aTextureIter );
5666
5667       ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5668     }
5669   }
5670
5671   // viewers counters are used for storing view_numbers in IParameters
5672   int vtkViewers = 0;
5673
5674   // main cycle to store parameters of displayed objects
5675   QList<SUIT_ViewManager*> lst;
5676   QList<SUIT_ViewManager*>::Iterator it;
5677   getApp()->viewManagers(lst);
5678   for (it = lst.begin(); it != lst.end(); it++)
5679   {
5680     SUIT_ViewManager* vman = *it;
5681     QString vType = vman->getType();
5682
5683     // saving VTK actors properties
5684     if (vType == SVTK_Viewer::Type())
5685     {
5686       // store the clipping planes attached to the view manager
5687       SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5688       SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5689       if( anIter != myClippingPlaneInfoMap.end() )
5690         aClippingPlaneInfoList = anIter->second;
5691
5692       if( !aClippingPlaneInfoList.empty() ) {
5693         SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5694         for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5695         {
5696           const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5697           SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5698
5699           QString aPropertyName( "ClippingPlane" );
5700           aPropertyName += gSeparator;
5701           aPropertyName += QString::number( vtkViewers );
5702           aPropertyName += gSeparator;
5703           aPropertyName += QString::number( anId );
5704
5705           QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5706           aPropertyValue += gDigitsSep;
5707           aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5708           aPropertyValue += gDigitsSep;
5709           if ( aPlane->PlaneMode == SMESH::Absolute ) {
5710             aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5711             aPropertyValue += gDigitsSep;
5712             aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5713             aPropertyValue += gDigitsSep;
5714             aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5715             aPropertyValue += gDigitsSep;
5716             aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5717             aPropertyValue += gDigitsSep;
5718             aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5719             aPropertyValue += gDigitsSep;
5720             aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5721             aPropertyValue += gDigitsSep;
5722             aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5723           }
5724           else if ( aPlane->PlaneMode == SMESH::Relative ) {
5725             aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5726             aPropertyValue += gDigitsSep;
5727             aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5728             aPropertyValue += gDigitsSep;
5729             aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5730             aPropertyValue += gDigitsSep;
5731             aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5732           }
5733
5734           ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5735         }
5736       }
5737
5738       QVector<SUIT_ViewWindow*> views = vman->getViews();
5739       for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5740       {
5741         if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5742         {
5743           VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5744           vtkActorCollection* allActors = aCopy.GetActors();
5745           allActors->InitTraversal();
5746           while (vtkActor* actor = allActors->GetNextActor())
5747           {
5748             if (actor->GetVisibility()) // store only visible actors
5749             {
5750               SMESH_Actor* aSmeshActor = 0;
5751               if (actor->IsA("SMESH_Actor"))
5752                 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5753               if (aSmeshActor && aSmeshActor->hasIO())
5754               {
5755                 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5756                 if (io->hasEntry())
5757                 {
5758                   // entry is "encoded" = it does NOT contain component adress,
5759                   // since it is a subject to change on next component loading
5760                   std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5761
5762                   std::string param, vtkParam = vType.toLatin1().data();
5763                   vtkParam += gSeparator;
5764                   vtkParam += QString::number(vtkViewers).toLatin1().data();
5765                   vtkParam += gSeparator;
5766
5767                   // Visibility
5768                   param = vtkParam + "Visibility";
5769                   ip->setParameter(entry, param, "On");
5770
5771                   // Representation
5772                   param = vtkParam + "Representation";
5773                   ip->setParameter(entry, param, QString::number
5774                                    ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5775
5776                   // IsShrunk
5777                   param = vtkParam + "IsShrunk";
5778                   ip->setParameter(entry, param, QString::number
5779                                    ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5780
5781                   // Displayed entities
5782                   unsigned int aMode = aSmeshActor->GetEntityMode();
5783                   bool isE  = aMode & SMESH_Actor::eEdges;
5784                   bool isF  = aMode & SMESH_Actor::eFaces;
5785                   bool isV  = aMode & SMESH_Actor::eVolumes;
5786                   bool is0d = aMode & SMESH_Actor::e0DElements;
5787                   bool isB  = aMode & SMESH_Actor::eBallElem;
5788
5789                   QString modeStr ("e");
5790                   modeStr += gDigitsSep; modeStr += QString::number(isE);
5791                   modeStr += gDigitsSep; modeStr += "f";
5792                   modeStr += gDigitsSep; modeStr += QString::number(isF);
5793                   modeStr += gDigitsSep; modeStr += "v";
5794                   modeStr += gDigitsSep; modeStr += QString::number(isV);
5795                   modeStr += gDigitsSep; modeStr += "0d";
5796                   modeStr += gDigitsSep; modeStr += QString::number(is0d);
5797                   modeStr += gDigitsSep; modeStr += "b";
5798                   modeStr += gDigitsSep; modeStr += QString::number(isB);
5799
5800                   param = vtkParam + "Entities";
5801                   ip->setParameter(entry, param, modeStr.toLatin1().data());
5802
5803                   // Colors
5804                   double r, g, b;
5805                   int delta;
5806
5807                   aSmeshActor->GetSufaceColor(r, g, b, delta);
5808                   QStringList colorStr;
5809                   colorStr << "surface";
5810                   colorStr << QString::number(r);
5811                   colorStr << QString::number(g);
5812                   colorStr << QString::number(b);
5813
5814                   colorStr << "backsurface";
5815                   colorStr << QString::number(delta);
5816
5817                   aSmeshActor->GetVolumeColor(r, g, b, delta);
5818                   colorStr << "volume";
5819                   colorStr << QString::number(r);
5820                   colorStr << QString::number(g);
5821                   colorStr << QString::number(b);
5822                   colorStr << QString::number(delta);
5823
5824                   aSmeshActor->GetEdgeColor(r, g, b);
5825                   colorStr << "edge";
5826                   colorStr << QString::number(r);
5827                   colorStr << QString::number(g);
5828                   colorStr << QString::number(b);
5829
5830                   aSmeshActor->GetNodeColor(r, g, b);
5831                   colorStr << "node";
5832                   colorStr << QString::number(r);
5833                   colorStr << QString::number(g);
5834                   colorStr << QString::number(b);
5835
5836                   aSmeshActor->GetOutlineColor(r, g, b);
5837                   colorStr << "outline";
5838                   colorStr << QString::number(r);
5839                   colorStr << QString::number(g);
5840                   colorStr << QString::number(b);
5841
5842                   aSmeshActor->Get0DColor(r, g, b);
5843                   colorStr << "elem0d";
5844                   colorStr << QString::number(r);
5845                   colorStr << QString::number(g);
5846                   colorStr << QString::number(b);
5847
5848                   aSmeshActor->GetBallColor(r, g, b);
5849                   colorStr << "ball";
5850                   colorStr << QString::number(r);
5851                   colorStr << QString::number(g);
5852                   colorStr << QString::number(b);
5853
5854                   aSmeshActor->GetFacesOrientationColor(r, g, b);
5855                   colorStr << "orientation";
5856                   colorStr << QString::number(r);
5857                   colorStr << QString::number(g);
5858                   colorStr << QString::number(b);
5859
5860                   param = vtkParam + "Colors";
5861                   ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5862
5863                   // Sizes
5864                   QStringList sizeStr;
5865                   sizeStr << "line";
5866                   sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5867                   sizeStr << "outline";
5868                   sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5869                   sizeStr << "elem0d";
5870                   sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5871                   sizeStr << "ball";
5872                   //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5873                   sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5874                   sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5875                   sizeStr << "shrink";
5876                   sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5877                   sizeStr << "orientation";
5878                   sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5879                   sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5880
5881                   param = vtkParam + "Sizes";
5882                   ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5883
5884                   // Point marker
5885                   QString markerStr;
5886
5887                   VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5888                   if( aMarkerType == VTK::MT_USER ) {
5889                     markerStr += "custom";
5890                     markerStr += gDigitsSep;
5891                     markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5892                   }
5893                   else {
5894                     markerStr += "std";
5895                     markerStr += gDigitsSep;
5896                     markerStr += QString::number( (int)aMarkerType );
5897                     markerStr += gDigitsSep;
5898                     markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5899                   }
5900
5901                   param = vtkParam + "PointMarker";
5902                   ip->setParameter(entry, param, markerStr.toLatin1().data());
5903
5904                   // Opacity
5905                   param = vtkParam + "Opacity";
5906                   ip->setParameter(entry, param,
5907                                    QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5908
5909                   // Clipping
5910                   param = vtkParam + "ClippingPlane";
5911                   int aPlaneId = 0;
5912                   if( !aClippingPlaneInfoList.empty() ) {
5913                     SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5914                     for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5915                     {
5916                       const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5917                       std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5918                       SMESH::TActorList::iterator anIter2 = anActorList.begin();
5919                       for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5920                         if( aSmeshActor == *anIter2 ) {
5921                           ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5922                                             QString::number( anId ).toLatin1().constData() );
5923                           break;
5924                         }
5925                       }
5926                     }
5927                   }
5928                   if( aPlaneId == 0 )
5929                     ip->setParameter( entry, param, "Off" );
5930                 } // if (io->hasEntry())
5931               } // SMESH_Actor && hasIO
5932             } // isVisible
5933           } // while.. actors traversal
5934         } // if (vtkView)
5935       } // for (views)
5936       vtkViewers++;
5937     } // if (SVTK view model)
5938   } // for (viewManagers)
5939 }
5940
5941 // data structures for clipping planes processing
5942 typedef struct {
5943   int Id;
5944   int Mode;
5945   bool isOpenGLClipping;
5946   vtkIdType RelativeOrientation;
5947   double Distance;
5948   double Angle[2];
5949   int AbsoluteOrientation;
5950   double X, Y, Z, Dx, Dy, Dz;
5951 } TPlaneData;
5952 typedef std::list<TPlaneData>         TPlaneDataList;
5953 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5954
5955 typedef std::list<vtkActor*>          TActorList;
5956 typedef struct {
5957   int PlaneId;
5958   TActorList ActorList;
5959   SUIT_ViewManager* ViewManager;
5960 } TPlaneInfo;
5961 typedef std::list<TPlaneInfo>         TPlaneInfoList;
5962 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5963
5964 /*!
5965  * \brief Restore visual parameters
5966  *
5967  * This method is called after the study document is opened.
5968  * Restore visual parameters from AttributeParameter attribue(s)
5969  */
5970 void SMESHGUI::restoreVisualParameters (int savePoint)
5971 {
5972   // localizing
5973   Kernel_Utils::Localizer loc;
5974
5975   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5976   if (!appStudy || !appStudy->studyDS())
5977     return;
5978   _PTR(Study) studyDS = appStudy->studyDS();
5979
5980   // componentName is used for encoding of entries when storing them in IParameters
5981   std::string componentName = myComponentSMESH->ComponentDataType();
5982   //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5983   //if (!aSComponent) return;
5984
5985   // IParameters
5986   _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5987                                                              componentName.c_str(),
5988                                                              savePoint);
5989   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5990
5991   // restore map of custom markers and map of clipping planes
5992   VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5993   TPlaneDataMap aPlaneDataMap;
5994
5995   std::vector<std::string> properties = ip->getProperties();
5996   for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5997   {
5998     std::string property = *propIt;
5999     QString aPropertyName( property.c_str() );
6000     QString aPropertyValue( ip->getProperty( property ).c_str() );
6001
6002     QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6003     if( aPropertyNameList.isEmpty() )
6004       continue;
6005
6006     QString aPropertyType = aPropertyNameList[0];
6007     if( aPropertyType == "texture" )
6008     {
6009       if( aPropertyNameList.size() != 2 )
6010         continue;
6011
6012       bool ok = false;
6013       int anId = aPropertyNameList[1].toInt( &ok );
6014       if( !ok || anId < 1 )
6015         continue;
6016
6017       QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6018       if( aPropertyValueList.size() != 2 )
6019         continue;
6020
6021       std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6022       QString aMarkerTextureString = aPropertyValueList[1];
6023       QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6024       if( aMarkerTextureStringList.size() != 3 )
6025         continue;
6026
6027       ok = false;
6028       ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6029       if( !ok )
6030         continue;
6031
6032       ok = false;
6033       ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6034       if( !ok )
6035         continue;
6036
6037       VTK::MarkerTexture aMarkerTexture;
6038       aMarkerTexture.push_back( aWidth );
6039       aMarkerTexture.push_back( aHeight );
6040
6041       QString aMarkerTextureData = aMarkerTextureStringList[2];
6042       for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6043       {
6044         QChar aChar = aMarkerTextureData.at( i );
6045         if( aChar.isDigit() )
6046           aMarkerTexture.push_back( aChar.digitValue() );
6047       }
6048
6049       aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6050     }
6051     else if( aPropertyType == "ClippingPlane" )
6052     {
6053       if( aPropertyNameList.size() != 3 )
6054         continue;
6055
6056       bool ok = false;
6057       int aViewId = aPropertyNameList[1].toInt( &ok );
6058       if( !ok || aViewId < 0 )
6059         continue;
6060
6061       ok = false;
6062       int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6063       if( !ok || aClippingPlaneId < 0 )
6064         continue;
6065
6066       QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6067       if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6068         continue;
6069
6070       TPlaneData aPlaneData;
6071       aPlaneData.Id = aClippingPlaneId;
6072
6073       ok = false;
6074       aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6075       if( !ok )
6076         continue;
6077
6078       ok = false;
6079       aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6080       if( !ok )
6081         continue;
6082
6083       if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6084       {
6085         ok = false;
6086         aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6087         if( !ok )
6088           continue;
6089
6090         ok = false;
6091         aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6092         if( !ok )
6093           continue;
6094
6095         ok = false;
6096         aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6097         if( !ok )
6098           continue;
6099
6100         ok = false;
6101         aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6102         if( !ok )
6103           continue;
6104
6105         ok = false;
6106         aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6107         if( !ok )
6108           continue;
6109
6110         ok = false;
6111         aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6112         if( !ok )
6113           continue;
6114
6115         ok = false;
6116         aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6117         if( !ok )
6118           continue;
6119       }
6120       else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6121         ok = false;
6122         aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6123         if( !ok )
6124           continue;
6125
6126         ok = false;
6127         aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6128         if( !ok )
6129           continue;
6130
6131         ok = false;
6132         aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6133         if( !ok )
6134           continue;
6135
6136         ok = false;
6137         aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6138         if( !ok )
6139           continue;
6140       }
6141
6142       TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6143       aPlaneDataList.push_back( aPlaneData );
6144     }
6145   }
6146
6147   TPlaneInfoMap aPlaneInfoMap;
6148
6149   std::vector<std::string> entries = ip->getEntries();
6150
6151   for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6152   {
6153     // entry is a normal entry - it should be "decoded" (setting base adress of component)
6154     QString entry (ip->decodeEntry(*entIt).c_str());
6155
6156     // Check that the entry corresponds to a real object in the Study
6157     // as the object may be deleted or modified after the visual state is saved.
6158     _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6159     if (!so) continue; //Skip the not existent entry
6160
6161     std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6162     std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6163
6164     std::vector<std::string>::iterator namesIt = paramNames.begin();
6165     std::vector<std::string>::iterator valuesIt = paramValues.begin();
6166
6167     // actors are stored in a map after displaying of them for
6168     // quicker access in the future: map < viewID to actor >
6169     NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6170
6171     for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6172     {
6173       // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6174       // '_' is used as separator and should not be used in viewer type or parameter names.
6175       QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6176       if (lst.size() != 3)
6177         continue;
6178
6179       QString viewerTypStr = lst[0];
6180       QString viewIndexStr = lst[1];
6181       QString paramNameStr = lst[2];
6182
6183       bool ok;
6184       int viewIndex = viewIndexStr.toUInt(&ok);
6185       if (!ok) // bad conversion of view index to integer
6186         continue;
6187
6188       // viewers
6189       if (viewerTypStr == SVTK_Viewer::Type())
6190       {
6191         SMESH_Actor* aSmeshActor = 0;
6192         if (vtkActors.IsBound(viewIndex))
6193           aSmeshActor = vtkActors.Find(viewIndex);
6194
6195         QList<SUIT_ViewManager*> lst;
6196         getApp()->viewManagers(viewerTypStr, lst);
6197
6198         // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6199         SUIT_ViewManager* vman = NULL;
6200         if (viewIndex >= 0 && viewIndex < lst.count())
6201           vman = lst.at(viewIndex);
6202
6203         if (paramNameStr == "Visibility")
6204         {
6205           if (!aSmeshActor && displayer() && vman)
6206           {
6207             SUIT_ViewModel* vmodel = vman->getViewModel();
6208             // SVTK view model can be casted to SALOME_View
6209             displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6210
6211             // store displayed actor in a temporary map for quicker
6212             // access later when restoring other parameters
6213             SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6214             vtkRenderer* Renderer = vtkView->getRenderer();
6215             VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6216             vtkActorCollection* theActors = aCopy.GetActors();
6217             theActors->InitTraversal();
6218             bool isFound = false;
6219             vtkActor *ac = theActors->GetNextActor();
6220             for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6221               if (ac->IsA("SMESH_Actor")) {
6222                 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6223                 if (aGeomAc->hasIO()) {
6224                   Handle(SALOME_InteractiveObject) io =
6225                     Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6226                   if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6227                     isFound = true;
6228                     vtkActors.Bind(viewIndex, aGeomAc);
6229                   }
6230                 }
6231               }
6232             }
6233           }
6234         } // if (paramNameStr == "Visibility")
6235         else
6236         {
6237           // the rest properties "work" with SMESH_Actor
6238           if (aSmeshActor)
6239           {
6240             QString val ((*valuesIt).c_str());
6241
6242             // Representation
6243             if (paramNameStr == "Representation") {
6244               aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6245             }
6246             // IsShrunk
6247             else if (paramNameStr == "IsShrunk") {
6248               if (val.toInt()) {
6249                 if (!aSmeshActor->IsShrunk())
6250                   aSmeshActor->SetShrink();
6251               }
6252               else {
6253                 if (aSmeshActor->IsShrunk())
6254                   aSmeshActor->UnShrink();
6255               }
6256             }
6257             // Displayed entities
6258             else if (paramNameStr == "Entities") {
6259               QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6260               int aEntityMode = SMESH_Actor::eAllEntity;
6261               for ( int i = 0; i < mode.count(); i+=2 ) {
6262                 if ( i < mode.count()-1 ) {
6263                   QString type = mode[i];
6264                   bool val = mode[i+1].toInt();
6265                   if      ( type == "e" && !val )
6266                     aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6267                   else if ( type == "f" && !val )
6268                     aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6269                   else if ( type == "v" && !val )
6270                     aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6271                   else if ( type == "0d" && !val )
6272                     aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6273                   else if ( type == "b" && !val )
6274                     aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6275                 }
6276               }
6277               aSmeshActor->SetEntityMode( aEntityMode );
6278             }
6279             // Colors
6280             else if (paramNameStr == "Colors") {
6281               QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6282               QColor nodeColor;
6283               QColor edgeColor;
6284               QColor faceColor;
6285               QColor volumeColor;
6286               QColor elem0dColor;
6287               QColor ballColor;
6288               QColor outlineColor;
6289               QColor orientationColor;
6290               int deltaF;
6291               int deltaV;
6292               QColor c;
6293               double r, g, b;
6294               bool bOk;
6295               // below lines are required to get default values for delta coefficients
6296               // of backface color for faces and color of reversed volumes
6297               SMESH::GetColor( "SMESH", "fill_color",   c, deltaF, "0,170,255|-100" );
6298               SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6299               for ( int i = 0; i < colors.count(); i++ ) {
6300                 QString type = colors[i];
6301                 if ( type == "surface" ) {
6302                   // face color is set by 3 values r:g:b, where
6303                   // - r,g,b - is rgb color components
6304                   if ( i+1 >= colors.count() ) break;                  // format error
6305                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6306                   if ( i+2 >= colors.count() ) break;                  // format error
6307                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6308                   if ( i+3 >= colors.count() ) break;                  // format error
6309                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6310                   faceColor.setRgbF( r, g, b );
6311                   i += 3;
6312                 }
6313                 else if ( type == "backsurface" ) {
6314                   // backface color can be defined in several ways
6315                   // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6316                   // - in latest versions, it is set as delta coefficient
6317                   bool rgbOk = false, deltaOk;
6318                   if ( i+1 >= colors.count() ) break;                  // format error
6319                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6320                   int delta = colors[i+1].toInt( &deltaOk );
6321                   i++;                                 // shift index
6322                   if ( i+1 < colors.count() )          // index is shifted to 1
6323                     g = colors[i+1].toDouble( &rgbOk );
6324                   if ( rgbOk ) i++;                    // shift index
6325                   if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6326                     b = colors[i+1].toDouble( &rgbOk );
6327                   if ( rgbOk ) i++;
6328                   // - as currently there's no way to set directly backsurface color as it was before,
6329                   // we ignore old dump where r,g,b triple was set
6330                   // - also we check that delta parameter is set properly
6331                   if ( !rgbOk && deltaOk )
6332                     deltaF = delta;
6333                 }
6334                 else if ( type == "volume" ) {
6335                   // volume color is set by 4 values r:g:b:delta, where
6336                   // - r,g,b - is a normal volume rgb color components
6337                   // - delta - is a reversed volume color delta coefficient
6338                   if ( i+1 >= colors.count() ) break;                  // format error
6339                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6340                   if ( i+2 >= colors.count() ) break;                  // format error
6341                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6342                   if ( i+3 >= colors.count() ) break;                  // format error
6343                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6344                   if ( i+4 >= colors.count() ) break;                  // format error
6345                   int delta = colors[i+4].toInt( &bOk );
6346                   if ( !bOk ) break;                                   // format error
6347                   volumeColor.setRgbF( r, g, b );
6348                   deltaV = delta;
6349                   i += 4;
6350                 }
6351                 else if ( type == "edge" ) {
6352                   // edge color is set by 3 values r:g:b, where
6353                   // - r,g,b - is rgb color components
6354                   if ( i+1 >= colors.count() ) break;                  // format error
6355                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6356                   if ( i+2 >= colors.count() ) break;                  // format error
6357                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6358                   if ( i+3 >= colors.count() ) break;                  // format error
6359                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6360                   edgeColor.setRgbF( r, g, b );
6361                   i += 3;
6362                 }
6363                 else if ( type == "node" ) {
6364                   // node color is set by 3 values r:g:b, where
6365                   // - r,g,b - is rgb color components
6366                   if ( i+1 >= colors.count() ) break;                  // format error
6367                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6368                   if ( i+2 >= colors.count() ) break;                  // format error
6369                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6370                   if ( i+3 >= colors.count() ) break;                  // format error
6371                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6372                   nodeColor.setRgbF( r, g, b );
6373                   i += 3;
6374                 }
6375                 else if ( type == "elem0d" ) {
6376                   // 0d element color is set by 3 values r:g:b, where
6377                   // - r,g,b - is rgb color components
6378                   if ( i+1 >= colors.count() ) break;                  // format error
6379                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6380                   if ( i+2 >= colors.count() ) break;                  // format error
6381                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6382                   if ( i+3 >= colors.count() ) break;                  // format error
6383                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6384                   elem0dColor.setRgbF( r, g, b );
6385                   i += 3;
6386                 }
6387                 else if ( type == "ball" ) {
6388                   // ball color is set by 3 values r:g:b, where
6389                   // - r,g,b - is rgb color components
6390                   if ( i+1 >= colors.count() ) break;                  // format error
6391                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6392                   if ( i+2 >= colors.count() ) break;                  // format error
6393                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6394                   if ( i+3 >= colors.count() ) break;                  // format error
6395                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6396                   ballColor.setRgbF( r, g, b );
6397                   i += 3;
6398                 }
6399                 else if ( type == "outline" ) {
6400                   // outline color is set by 3 values r:g:b, where
6401                   // - r,g,b - is rgb color components
6402                   if ( i+1 >= colors.count() ) break;                  // format error
6403                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6404                   if ( i+2 >= colors.count() ) break;                  // format error
6405                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6406                   if ( i+3 >= colors.count() ) break;                  // format error
6407                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6408                   outlineColor.setRgbF( r, g, b );
6409                   i += 3;
6410                 }
6411                 else if ( type == "orientation" ) {
6412                   // orientation color is set by 3 values r:g:b, where
6413                   // - r,g,b - is rgb color components
6414                   if ( i+1 >= colors.count() ) break;                  // format error
6415                   r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6416                   if ( i+2 >= colors.count() ) break;                  // format error
6417                   g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6418                   if ( i+3 >= colors.count() ) break;                  // format error
6419                   b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6420                   orientationColor.setRgbF( r, g, b );
6421                   i += 3;
6422                 }
6423               }
6424               // node color
6425               if ( nodeColor.isValid() )
6426                 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6427               // edge color
6428               if ( edgeColor.isValid() )
6429                 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6430               // face color
6431               if ( faceColor.isValid() )
6432                 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6433               // volume color
6434               if ( volumeColor.isValid() )
6435                 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6436               else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6437                 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6438               // 0d element color
6439               if ( elem0dColor.isValid() )
6440                 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6441               // ball color
6442               if ( ballColor.isValid() )
6443                 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6444               // outline color
6445               if ( outlineColor.isValid() )
6446                 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6447               // orientation color
6448               if ( orientationColor.isValid() )
6449                 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6450             }
6451             // Sizes
6452             else if (paramNameStr == "Sizes") {
6453               QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6454               bool bOk;
6455               int lineWidth = -1;
6456               int outlineWidth = -1;
6457               int elem0dSize = -1;
6458               //int ballSize = -1;
6459               double ballDiameter = -1.0;
6460               double ballScale = -1.0;
6461               double shrinkSize = -1;
6462               double orientationSize = -1;
6463               bool orientation3d = false;
6464               for ( int i = 0; i < sizes.count(); i++ ) {
6465                 QString type = sizes[i];
6466                 if ( type == "line" ) {
6467                   // line (wireframe) width is given as single integer value
6468                   if ( i+1 >= sizes.count() ) break;                    // format error
6469                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6470                   lineWidth = v;
6471                   i++;
6472                 }
6473                 if ( type == "outline" ) {
6474                   // outline width is given as single integer value
6475                   if ( i+1 >= sizes.count() ) break;                    // format error
6476                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6477                   outlineWidth = v;
6478                   i++;
6479                 }
6480                 else if ( type == "elem0d" ) {
6481                   // 0d element size is given as single integer value
6482                   if ( i+1 >= sizes.count() ) break;                    // format error
6483                   int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;  // format error
6484                   elem0dSize = v;
6485                   i++;
6486                 }
6487                 else if ( type == "ball" ) {
6488                   // balls are specified by two values: size:scale, where
6489                   // - size - is a integer value specifying size
6490                   // - scale - is a double value specifying scale factor
6491                   if ( i+1 >= sizes.count() ) break;                       // format error
6492                   //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6493                   double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break;    // format error
6494                   if ( i+2 >= sizes.count() ) break;                       // format error
6495                   double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6496                   //ballSize = v1;
6497                   ballDiameter = v1;
6498                   ballScale = v2;
6499                   i += 2;
6500                 }
6501                 else if ( type == "shrink" ) {
6502                   // shrink factor is given as single floating point value
6503                   if ( i+1 >= sizes.count() ) break;                          // format error
6504                   double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break;  // format error
6505                   shrinkSize = v;
6506                   i++;
6507                 }
6508                 else if ( type == "orientation" ) {
6509                   // orientation vectors are specified by two values size:3d, where
6510                   // - size - is a floating point value specifying scale factor
6511                   // - 3d - is a boolean
6512                   if ( i+1 >= sizes.count() ) break;                          // format error
6513                   double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6514                   if ( i+2 >= sizes.count() ) break;                          // format error
6515                   int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break;       // format error
6516                   orientationSize = v1;
6517                   orientation3d = (bool)v2;
6518                   i += 2;
6519                 }
6520               }
6521               // line (wireframe) width
6522               if ( lineWidth > 0 )
6523                 aSmeshActor->SetLineWidth( lineWidth );
6524               // outline width
6525               if ( outlineWidth > 0 )
6526                 aSmeshActor->SetOutlineWidth( outlineWidth );
6527               else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6528                 aSmeshActor->SetOutlineWidth( lineWidth );
6529               // 0d element size
6530               if ( elem0dSize > 0 )
6531                 aSmeshActor->Set0DSize( elem0dSize );
6532               // ball size
6533               /*if ( ballSize > 0 )
6534                 aSmeshActor->SetBallSize( ballSize );*/
6535               // ball diameter
6536               if ( ballDiameter > 0 )
6537                 aSmeshActor->SetBallSize( ballDiameter );
6538               // ball scale
6539               if ( ballScale > 0.0 )
6540                 aSmeshActor->SetBallScale( ballScale );
6541               // shrink factor
6542               if ( shrinkSize > 0 )
6543                 aSmeshActor->SetShrinkFactor( shrinkSize );
6544               // orientation vectors
6545               if ( orientationSize > 0 ) {
6546                 aSmeshActor->SetFacesOrientationScale( orientationSize );
6547                 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6548               }
6549             }
6550             // Point marker
6551             else if (paramNameStr == "PointMarker") {
6552               QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6553               if( data.count() >= 2 ) {
6554                 bool ok = false;
6555                 int aParam1 = data[1].toInt( &ok );
6556                 if( ok ) {
6557                   if( data[0] == "std" && data.count() == 3 ) {
6558                     int aParam2 = data[2].toInt( &ok );
6559                     aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6560                   }
6561                   else if( data[0] == "custom" ) {
6562                     VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6563                     if( markerIt != aMarkerMap.end() ) {
6564                       VTK::MarkerData aMarkerData = markerIt->second;
6565                       aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6566                     }
6567                   }
6568                 }
6569               }
6570             }
6571             // Opacity
6572             else if (paramNameStr == "Opacity") {
6573               aSmeshActor->SetOpacity(val.toFloat());
6574             }
6575             // Clipping
6576             else if (paramNameStr.startsWith("ClippingPlane")) {
6577               QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6578               // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6579               // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6580               // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6581               // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6582               // new format - val looks like "Off" or "0" (plane id)
6583               // (note: in new format "Off" value is used only for consistency,
6584               //  so it is processed together with values in old format)
6585               bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6586               if( anIsOldFormat ) {
6587                 if (paramNameStr == "ClippingPlane1" || val == "Off")
6588                   aSmeshActor->RemoveAllClippingPlanes();
6589                 if (val != "Off") {
6590                   QList<SUIT_ViewManager*> lst;
6591                   getApp()->viewManagers(viewerTypStr, lst);
6592                   // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6593                   if (viewIndex >= 0 && viewIndex < lst.count()) {
6594                     SUIT_ViewManager* vman = lst.at(viewIndex);
6595                     SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6596
6597                     SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6598
6599                     SMESH::TActorList anActorList;
6600                     anActorList.push_back( aSmeshActor );
6601                     SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6602                     aPlane->myViewWindow = vtkView;
6603                     SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6604                     aPlane->PlaneMode = aMode;
6605                     bool isOpenGLClipping = ( bool )vals[1].toInt();
6606                     aPlane->IsOpenGLClipping = isOpenGLClipping;
6607                     if ( aMode == SMESH::Absolute ) {
6608                       aPlane->myAbsoluteOrientation = vals[2].toInt();
6609                       aPlane->X = vals[3].toFloat();
6610                       aPlane->Y = vals[4].toFloat();
6611                       aPlane->Z = vals[5].toFloat();
6612                       aPlane->Dx = vals[6].toFloat();
6613                       aPlane->Dy = vals[7].toFloat();
6614                       aPlane->Dz = vals[8].toFloat();
6615                     }
6616                     else if ( aMode == SMESH::Relative ) {
6617                       aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6618                       aPlane->myDistance = vals[3].toFloat();
6619                       aPlane->myAngle[0] = vals[4].toFloat();
6620                       aPlane->myAngle[1] = vals[5].toFloat();
6621                     }
6622
6623                     if( aPlane ) {
6624                       if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6625                         SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6626                         aClippingPlaneInfo.Plane = aPlane;
6627                         aClippingPlaneInfo.ActorList = anActorList;
6628                         aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6629                       }
6630                     }
6631                   }
6632                 }
6633               }
6634               else {
6635                 bool ok = false;
6636                 int aPlaneId = val.toInt( &ok );
6637                 if( ok && aPlaneId >= 0 ) {
6638                   bool anIsDefinedPlane = false;
6639                   TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6640                   TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6641                   for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6642                     TPlaneInfo& aPlaneInfo = *anIter;
6643                     if( aPlaneInfo.PlaneId == aPlaneId ) {
6644                       aPlaneInfo.ActorList.push_back( aSmeshActor );
6645                       anIsDefinedPlane = true;
6646                       break;
6647                     }
6648                   }
6649                   if( !anIsDefinedPlane ) {
6650                     TPlaneInfo aPlaneInfo;
6651                     aPlaneInfo.PlaneId = aPlaneId;
6652                     aPlaneInfo.ActorList.push_back( aSmeshActor );
6653                     aPlaneInfo.ViewManager = vman;
6654
6655                     // to make the list sorted by plane id
6656                     anIter = aPlaneInfoList.begin();
6657                     for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6658                       const TPlaneInfo& aPlaneInfoRef = *anIter;
6659                       if( aPlaneInfoRef.PlaneId > aPlaneId )
6660                         break;
6661                     }
6662                     aPlaneInfoList.insert( anIter, aPlaneInfo );
6663                   }
6664                 }
6665               }
6666             }
6667           } // if (aSmeshActor)
6668         } // other parameters than Visibility
6669       }
6670     } // for names/parameters iterator
6671   } // for entries iterator
6672
6673   // take into account planes with empty list of actors referred to them
6674   QList<SUIT_ViewManager*> aVMList;
6675   getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6676
6677   TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6678   for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6679     int aViewId = aPlaneDataIter->first;
6680     if( aViewId >= 0 && aViewId < aVMList.count() ) {
6681       SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6682
6683       const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6684
6685       TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6686       TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6687       for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6688         const TPlaneData& aPlaneData = *anIter2;
6689         int aPlaneId = aPlaneData.Id;
6690
6691         bool anIsFound = false;
6692         TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6693         for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6694           const TPlaneInfo& aPlaneInfo = *anIter3;
6695           if( aPlaneInfo.PlaneId == aPlaneId ) {
6696             anIsFound = true;
6697             break;
6698           }
6699         }
6700
6701         if( !anIsFound ) {
6702           TPlaneInfo aPlaneInfo; // ActorList field is empty
6703           aPlaneInfo.PlaneId = aPlaneId;
6704           aPlaneInfo.ViewManager = aViewManager;
6705
6706           // to make the list sorted by plane id
6707           TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6708           for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6709             const TPlaneInfo& aPlaneInfoRef = *anIter4;
6710             if( aPlaneInfoRef.PlaneId > aPlaneId )
6711               break;
6712           }
6713           aPlaneInfoList.insert( anIter4, aPlaneInfo );
6714         }
6715       }
6716     }
6717   }
6718
6719   // add clipping planes to actors according to the restored parameters
6720   // and update the clipping plane map
6721   TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6722   for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6723     int aViewId = anIter1->first;
6724     const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6725
6726     TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6727     if( anIter2 == aPlaneDataMap.end() )
6728       continue;
6729     const TPlaneDataList& aPlaneDataList = anIter2->second;
6730
6731     TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6732     for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6733       const TPlaneInfo& aPlaneInfo = *anIter3;
6734       int aPlaneId = aPlaneInfo.PlaneId;
6735       const TActorList& anActorList = aPlaneInfo.ActorList;
6736       SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6737       if( !aViewManager )
6738         continue;
6739
6740       SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6741       if( !aViewWindow )
6742         continue;
6743
6744       SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6745
6746       TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6747       for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6748         const TPlaneData& aPlaneData = *anIter4;
6749         if( aPlaneData.Id == aPlaneId ) {
6750           SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6751           aPlane->myViewWindow = aViewWindow;
6752           aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6753           aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6754           if ( aPlane->PlaneMode == SMESH::Absolute ) {
6755             aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6756             aPlane->X = aPlaneData.X;
6757             aPlane->Y = aPlaneData.Y;
6758             aPlane->Z = aPlaneData.Z;
6759             aPlane->Dx = aPlaneData.Dx;
6760             aPlane->Dy = aPlaneData.Dy;
6761             aPlane->Dz = aPlaneData.Dz;
6762           }
6763           else if ( aPlane->PlaneMode == SMESH::Relative ) {
6764             aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6765             aPlane->myDistance = aPlaneData.Distance;
6766             aPlane->myAngle[0] = aPlaneData.Angle[0];
6767             aPlane->myAngle[1] = aPlaneData.Angle[1];
6768           }
6769           if( aPlane ) {
6770             if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6771               SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6772               aClippingPlaneInfo.Plane = aPlane;
6773               aClippingPlaneInfo.ActorList = anActorList;
6774               aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6775             }
6776           }
6777           break;
6778         }
6779       }
6780
6781     }
6782   }
6783
6784
6785   // update all VTK views
6786   QList<SUIT_ViewManager*> lst;
6787   getApp()->viewManagers(lst);
6788   for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6789     SUIT_ViewModel* vmodel = (*it)->getViewModel();
6790     if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6791       SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6792       // set OpenGL clipping planes
6793       VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6794       vtkActorCollection* anAllActors = aCopy.GetActors();
6795       anAllActors->InitTraversal();
6796       while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6797         if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6798           anActor->SetOpenGLClippingPlane();
6799
6800       vtkView->getRenderer()->ResetCameraClippingRange();
6801       vtkView->Repaint();
6802     }
6803   }
6804 }
6805
6806 /*!
6807   \brief Adds preferences for dfont of VTK viewer
6808   \param label label
6809   \param pIf group identifier
6810   \param param parameter
6811   \return identifier of preferences
6812 */
6813 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6814 {
6815   int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6816
6817   setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6818
6819   QStringList fam;
6820   fam.append( tr( "SMESH_FONT_ARIAL" ) );
6821   fam.append( tr( "SMESH_FONT_COURIER" ) );
6822   fam.append( tr( "SMESH_FONT_TIMES" ) );
6823
6824   setPreferenceProperty( tfont, "fonts", fam );
6825
6826   int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6827   if ( needSize ) f = f | QtxFontEdit::Size;
6828   setPreferenceProperty( tfont, "features", f );
6829
6830   return tfont;
6831 }
6832
6833 /*!
6834   \brief Actions after hypothesis edition
6835   Updates object browser after hypothesis edition
6836 */
6837 void SMESHGUI::onHypothesisEdit( int result )
6838 {
6839   if( result == 1 )
6840     SMESHGUI::Modified();
6841   updateObjBrowser( true );
6842 }
6843
6844
6845 /*!
6846   \brief Signal handler closing(SUIT_ViewWindow*) of a view
6847   \param pview view being closed
6848 */
6849 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6850 #ifndef DISABLE_PLOT2DVIEWER
6851   //Crear all Plot2d Viewers if need.
6852   SMESH::ClearPlot2Viewers(pview);
6853 #endif
6854   EmitSignalCloseView();
6855 }
6856
6857 void SMESHGUI::message( const QString& msg )
6858 {
6859   // dispatch message
6860   QStringList data = msg.split("/");
6861   if ( data.count() > 0 ) {
6862     if ( data.first() == "mesh_loading" ) {
6863       // get mesh entry
6864       QString entry = data.count() > 1 ? data[1] : QString();
6865       if ( entry.isEmpty() )
6866         return;
6867       // get study
6868       _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6869       // get mesh name
6870       _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6871       QString name;
6872       if ( obj )
6873         name = SMESH::fromUtf8(obj->GetName());
6874       if ( name.isEmpty() )
6875         return;
6876
6877       if ( data.last() == "stop" )
6878         application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6879       else
6880         application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6881       QApplication::processEvents();
6882     }
6883   }
6884 }
6885
6886 /*!
6887   \brief Connects or disconnects signals about activating and cloning view on the module slots
6888   \param pview view which is connected/disconnected
6889 */
6890 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6891   if(!pview)
6892     return;
6893
6894   SUIT_ViewManager* viewMgr = pview->getViewManager();
6895   if ( viewMgr ) {
6896     disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6897                 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6898
6899     connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6900              this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6901   }
6902 }
6903
6904 /*!
6905   \brief Return \c true if object can be renamed
6906 */
6907 bool SMESHGUI::renameAllowed( const QString& entry) const {
6908   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6909   if( !anApp )
6910     return false;
6911
6912   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6913   if( !appStudy )
6914     return false;
6915
6916   SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6917
6918   if(!obj)
6919     return false;
6920
6921   if(appStudy->isComponent(entry) || obj->isReference())
6922     return false;
6923
6924   // check type to prevent renaming of inappropriate objects
6925   int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6926   if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6927       aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6928       aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6929       aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6930       aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6931     return true;
6932
6933   return false;
6934 }
6935
6936 /*!
6937   Rename object by entry.
6938   \param entry entry of the object
6939   \param name new name of the object
6940   \brief Return \c true if rename operation finished successfully, \c false otherwise.
6941 */
6942 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6943
6944   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6945   if( !anApp )
6946     return false;
6947
6948   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6949
6950   if(!appStudy)
6951     return false;
6952
6953   _PTR(Study) aStudy = appStudy->studyDS();
6954
6955   if(!aStudy)
6956     return false;
6957
6958   bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6959   if ( aLocked ) {
6960     SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6961     return false;
6962   }
6963
6964
6965   _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6966   _PTR(GenericAttribute) anAttr;
6967   _PTR(AttributeName) aName;
6968   if ( obj ) {
6969     if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6970       aName = anAttr;
6971       // check type to prevent renaming of inappropriate objects
6972       int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6973       if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6974           aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6975           aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6976           aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6977           aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6978         if ( !name.isEmpty() ) {
6979           SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6980
6981           // update name of group object and its actor
6982           Handle(SALOME_InteractiveObject) IObject =
6983             new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6984
6985           SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6986           if( !aGroupObject->_is_nil() ) {
6987             aGroupObject->SetName( qPrintable(name) );
6988             if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6989               anActor->setName( qPrintable(name) );
6990           }
6991           return true;
6992         }
6993       }
6994     }
6995   }
6996   return false;
6997 }
6998
6999 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7000 {
7001   static QList<QColor> colors;
7002
7003   if ( colors.isEmpty() ) {
7004
7005     for (int s = 0; s < 2 ; s++)
7006     {
7007       for (int v = 100; v >= 40; v = v - 20)
7008       {
7009         for (int h = 0; h < 359 ; h = h + 60)
7010         {
7011           colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7012         }
7013       }
7014     }
7015   }
7016   static int currentColor = randomize( colors.size() );
7017
7018   SALOMEDS::Color color;
7019   color.R = (double)colors[currentColor].red()   / 255.0;
7020   color.G = (double)colors[currentColor].green() / 255.0;
7021   color.B = (double)colors[currentColor].blue()  / 255.0;
7022
7023   currentColor = (currentColor+1) % colors.count();
7024
7025   return color;
7026 }