1 // Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
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.
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.
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
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FieldSelectorWdg.h"
48 #include "SMESHGUI_FileInfoDlg.h"
49 #include "SMESHGUI_FileValidator.h"
50 #include "SMESHGUI_FilterDlg.h"
51 #include "SMESHGUI_FilterLibraryDlg.h"
52 #include "SMESHGUI_FindElemByPointDlg.h"
53 #include "SMESHGUI_GroupDlg.h"
54 #include "SMESHGUI_GroupOnShapeDlg.h"
55 #include "SMESHGUI_GroupOpDlg.h"
56 #include "SMESHGUI_Hypotheses.h"
57 #include "SMESHGUI_Make2DFrom3DOp.h"
58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
59 #include "SMESHGUI_Measurements.h"
60 #include "SMESHGUI_MergeDlg.h"
61 #include "SMESHGUI_MeshInfo.h"
62 #include "SMESHGUI_MeshOp.h"
63 #include "SMESHGUI_MeshOrderOp.h"
64 #include "SMESHGUI_MeshPatternDlg.h"
65 #include "SMESHGUI_MultiEditDlg.h"
66 #include "SMESHGUI_NodesDlg.h"
67 #include "SMESHGUI_Operations.h"
68 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
69 #include "SMESHGUI_PropertiesDlg.h"
70 #include "SMESHGUI_RemoveElementsDlg.h"
71 #include "SMESHGUI_RemoveNodesDlg.h"
72 #include "SMESHGUI_RenumberingDlg.h"
73 #include "SMESHGUI_ReorientFacesDlg.h"
74 #include "SMESHGUI_RevolutionDlg.h"
75 #include "SMESHGUI_RotationDlg.h"
76 #include "SMESHGUI_ScaleDlg.h"
77 #include "SMESHGUI_Selection.h"
78 #include "SMESHGUI_SewingDlg.h"
79 #include "SMESHGUI_SingleEditDlg.h"
80 #include "SMESHGUI_SmoothingDlg.h"
81 #include "SMESHGUI_SymmetryDlg.h"
82 #include "SMESHGUI_TranslationDlg.h"
83 #include "SMESHGUI_TransparencyDlg.h"
84 #include "SMESHGUI_DisplayEntitiesDlg.h"
85 #include "SMESHGUI_SplitBiQuad.h"
87 #include "SMESHGUI_FilterUtils.h"
88 #include "SMESHGUI_GEOMGenUtils.h"
89 #include "SMESHGUI_GroupUtils.h"
90 #include "SMESHGUI_HypothesesUtils.h"
91 #include "SMESHGUI_MeshUtils.h"
92 #include "SMESHGUI_PatternUtils.h"
93 #include "SMESHGUI_Utils.h"
94 #include "SMESHGUI_VTKUtils.h"
96 #include "SMESH_version.h"
98 #include "SMESH_ControlsDef.hxx"
99 #include "SMESH_Actor.h"
100 #include "SMESH_ActorUtils.h"
101 #include "SMESH_Client.hxx"
102 #include "SMESH_ScalarBarActor.h"
103 #include "SMESH_TypeFilter.hxx"
105 // SALOME GUI includes
106 #include <SalomeApp_Application.h>
107 #include <SalomeApp_CheckFileDlg.h>
108 #include <SalomeApp_DataObject.h>
109 #include <SalomeApp_Study.h>
110 #include <SalomeApp_Tools.h>
112 #include <LightApp_DataOwner.h>
113 #include <LightApp_NameDlg.h>
114 #include <LightApp_Preferences.h>
115 #include <LightApp_SelectionMgr.h>
116 #include <LightApp_UpdateFlags.h>
118 #include <SVTK_ViewManager.h>
119 #include <SVTK_ViewModel.h>
120 #include <SVTK_ViewWindow.h>
122 #include <VTKViewer_Algorithm.h>
124 #include <SUIT_Desktop.h>
125 #include <SUIT_FileDlg.h>
126 #include <SUIT_MessageBox.h>
127 #include <SUIT_OverrideCursor.h>
128 #include <SUIT_ResourceMgr.h>
129 #include <SUIT_Session.h>
131 #include <QtxPopupMgr.h>
132 #include <QtxFontEdit.h>
134 #include <SALOME_ListIO.hxx>
136 #ifndef DISABLE_PLOT2DVIEWER
137 #include <SPlot2d_ViewModel.h>
138 #include <SPlot2d_Histogram.h>
142 #include <SALOMEconfig.h>
143 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
144 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
145 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
148 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
149 #include <QApplication>
151 #include <QTextStream>
156 #include <boost/shared_ptr.hpp>
159 #include <vtkCallbackCommand.h>
160 #include <vtkCamera.h>
161 #include <vtkLookupTable.h>
162 #include <vtkPlane.h>
163 #include <vtkRenderer.h>
165 // SALOME KERNEL includes
166 #include <SALOMEDSClient_ClientFactory.hxx>
167 #include <SALOMEDSClient_IParameters.hxx>
168 #include <SALOMEDSClient_SComponent.hxx>
169 #include <SALOMEDSClient_StudyBuilder.hxx>
170 #include <SALOMEDS_Study.hxx>
171 #include <SALOMEDS_SObject.hxx>
172 #include "utilities.h"
175 #include <Standard_ErrorHandler.hxx>
176 #include <NCollection_DataMap.hxx>
177 #include <NCollection_DoubleMap.hxx>
179 #include <Basics_Utils.hxx>
181 //To disable automatic genericobj management, the following line should be commented.
182 //Otherwise, it should be uncommented.
183 //Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
184 #define WITHGENERICOBJ
186 // Below macro, when uncommented, switches on simplified (more performant) algorithm
187 // of auto-color picking up
188 #define SIMPLE_AUTOCOLOR
193 //=============================================================
194 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
197 void ExportMeshToFile(int theCommandID);
199 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
201 void SetDisplayEntity(int theCommandID);
203 int ActionToControl( int theID, bool theReversed = false );
205 void Control( int theCommandID );
208 //================================================================================
210 * \brief Reads meshes from file
212 //================================================================================
214 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
218 std::string myExtension;
220 if ( theCommandID == SMESHOp::OpImportMED ) {
221 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
222 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
224 else if ( theCommandID == SMESHOp::OpImportUNV ) {
225 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
227 else if ( theCommandID == SMESHOp::OpImportDAT ) {
228 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
230 else if ( theCommandID == SMESHOp::OpImportSTL ) {
231 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
234 else if ( theCommandID == SMESHOp::OpImportCGNS ) {
235 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
238 else if ( theCommandID == SMESHOp::OpImportSAUV ) {
239 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
240 filter.append( QObject::tr( "All files (*)" ) );
242 else if ( theCommandID == SMESHOp::OpImportGMF ) {
243 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
244 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
247 QString anInitialPath = "";
248 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
249 anInitialPath = QDir::currentPath();
251 QStringList filenames;
252 bool toCreateGroups = true;
254 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
255 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
256 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
257 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
258 // fd->setNameFilters( filter );
259 // fd->SetChecked( true );
261 // filenames << fd->selectedFile();
262 // toCreateGroups = fd->IsChecked();
268 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
271 QObject::tr( "SMESH_IMPORT_MESH" ) );
273 if ( filenames.count() > 0 ) {
274 SUIT_OverrideCursor wc;
275 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
278 QStringList anEntryList;
279 bool isEmpty = false;
280 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
281 QString filename = *it;
282 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
284 switch ( theCommandID ) {
285 case SMESHOp::OpImportDAT:
287 // DAT format (currently unsupported)
288 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
289 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
292 case SMESHOp::OpImportUNV:
295 aMeshes->length( 1 );
296 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
297 if ( aMeshes[0]->_is_nil() )
298 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
299 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
302 case SMESHOp::OpImportMED:
305 SMESH::DriverMED_ReadStatus res;
306 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
307 if ( res != SMESH::DRS_OK ) {
308 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
309 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
313 case SMESHOp::OpImportSTL:
316 aMeshes->length( 1 );
317 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
318 if ( aMeshes[0]->_is_nil() ) {
319 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
320 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
325 case SMESHOp::OpImportCGNS:
328 SMESH::DriverMED_ReadStatus res;
329 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
330 if ( res != SMESH::DRS_OK ) {
331 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
332 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
337 case SMESHOp::OpImportSAUV:
340 SMESH::DriverMED_ReadStatus res;
341 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
342 if ( res != SMESH::DRS_OK ) {
343 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
344 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
348 case SMESHOp::OpImportGMF:
351 SMESH::ComputeError_var res;
352 aMeshes->length( 1 );
353 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
356 if ( res->code != SMESH::DRS_OK ) {
357 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
358 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
359 if ( strlen( res->comment.in() ) > 0 ) {
360 errors.back() += ": ";
361 errors.back() += res->comment.in();
368 catch ( const SALOME::SALOME_Exception& S_ex ) {
369 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
370 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
373 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
374 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
376 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
377 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
378 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
379 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
380 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
382 anEntryList.append( aMeshSO->GetID().c_str() );
390 // update Object browser
391 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
393 // browse to the published meshes
394 if( LightApp_Application* anApp =
395 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
396 anApp->browseObjects( anEntryList );
398 // show Error message box if there were errors
399 if ( errors.count() > 0 ) {
400 SUIT_MessageBox::critical( SMESHGUI::desktop(),
401 QObject::tr( "SMESH_ERROR" ),
402 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
405 // show warning message box, if some imported mesh is empty
407 SUIT_MessageBox::warning( SMESHGUI::desktop(),
408 QObject::tr( "SMESH_WRN_WARNING" ),
409 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
414 //================================================================================
416 * \brief Export selected meshes or groups into a file
418 //================================================================================
420 void ExportMeshToFile( int theCommandID )
422 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
423 SALOME_ListIO selected;
425 aSel->selectedObjects( selected );
427 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT || theCommandID == SMESHOp::OpPopupExportDAT );
428 const bool isMED = ( theCommandID == SMESHOp::OpExportMED || theCommandID == SMESHOp::OpPopupExportMED );
429 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV || theCommandID == SMESHOp::OpPopupExportUNV );
430 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL || theCommandID == SMESHOp::OpPopupExportSTL );
432 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS || theCommandID == SMESHOp::OpPopupExportCGNS );
434 const bool isCGNS= false;
436 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV || theCommandID == SMESHOp::OpPopupExportSAUV );
437 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF || theCommandID == SMESHOp::OpPopupExportGMF );
439 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
440 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
443 // get mesh object from selection and check duplication of their names
444 bool hasDuplicatedMeshNames = false;
445 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
446 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
447 SALOME_ListIteratorOfListIO It( selected );
448 for( ; It.More(); It.Next() )
450 Handle(SALOME_InteractiveObject) anIObject = It.Value();
451 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
452 if ( aMeshItem->_is_nil() ) {
453 SUIT_MessageBox::warning( SMESHGUI::desktop(),
454 QObject::tr( "SMESH_WRN_WARNING" ),
455 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
459 QString aMeshName = anIObject->getName();
461 // check for name duplications
462 if ( !hasDuplicatedMeshNames )
463 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
464 if( aMeshName == (*aMeshIter).second ) {
465 hasDuplicatedMeshNames = true;
470 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
473 if( hasDuplicatedMeshNames && isMED ) {
474 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
475 QObject::tr("SMESH_WRN_WARNING"),
476 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
477 QObject::tr("SMESH_BUT_YES"),
478 QObject::tr("SMESH_BUT_NO"), 0, 1);
483 aMeshIter = aMeshList.begin();
484 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
485 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
486 QString aMeshName = (*aMeshIter).second;
488 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
490 // check for equal group names within each mesh
491 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
492 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
493 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
494 int aRet = SUIT_MessageBox::warning
495 (SMESHGUI::desktop(),
496 QObject::tr("SMESH_WRN_WARNING"),
497 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
498 QObject::tr("SMESH_BUT_YES"),
499 QObject::tr("SMESH_BUT_NO"), 0, 1);
506 // Warn the user about presence of not supported elements
508 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
512 notSupportedElemTypes.push_back( SMESH::Entity_0D );
513 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
518 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
519 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
520 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
521 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
522 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
523 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
524 notSupportedElemTypes.push_back( SMESH::Entity_0D );
525 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
530 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
531 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
532 notSupportedElemTypes.push_back( SMESH::Entity_0D );
533 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
538 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
543 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
544 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
545 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
546 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
547 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
548 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
549 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
550 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
555 notSupportedElemTypes.push_back( SMESH::Entity_0D );
556 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
557 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
558 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
559 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
560 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
561 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
562 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
563 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
565 if ( ! notSupportedElemTypes.empty() )
567 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
568 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
569 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
570 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
572 if ( !presentNotSupported.empty() )
575 const char* typeMsg[SMESH::Entity_Last] = {
576 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
577 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
578 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
579 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
580 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
581 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
582 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
583 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
585 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
586 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
587 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
588 if ( iType != presentNotSupported.size() - 1 )
589 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
591 int aRet = SUIT_MessageBox::warning
592 (SMESHGUI::desktop(),
593 QObject::tr("SMESH_WRN_WARNING"),
594 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
595 QObject::tr("SMESH_BUT_YES"),
596 QObject::tr("SMESH_BUT_NO"), 0, 1);
601 // Get parameters of export operation
604 SMESH::MED_VERSION aFormat;
605 // Init the parameters with the default values
606 bool aIsASCII_STL = true;
607 bool toCreateGroups = false;
608 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
610 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
611 bool toOverwrite = true;
612 bool toFindOutDim = true;
614 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
615 QString anInitialPath = "";
616 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
617 anInitialPath = QDir::currentPath();
619 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
621 // Get a file name to write in and additional otions
622 if ( isUNV || isDAT || isGMF ) // Export w/o options
625 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
627 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
629 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
630 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
631 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
632 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
633 anInitialPath + QString("/") + aMeshName,
634 aFilter, aTitle, false);
636 else if ( isCGNS )// Export to CGNS
638 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
639 fd->setWindowTitle( aTitle );
640 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
641 if ( !anInitialPath.isEmpty() )
642 fd->setDirectory( anInitialPath );
643 fd->selectFile(aMeshName);
644 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
645 fd->setValidator( fv );
648 aFilename = fd->selectedFile();
649 toOverwrite = fv->isOverwrite();
653 else if ( isSTL ) // Export to STL
655 QMap<QString, int> aFilterMap;
656 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
657 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
660 QMap<QString, int>::const_iterator it = aFilterMap.begin();
661 for ( ; it != aFilterMap.end(); ++it )
662 filters.push_back( it.key() );
664 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
665 fd->setWindowTitle( aTitle );
666 fd->setNameFilters( filters );
667 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
668 if ( !anInitialPath.isEmpty() )
669 fd->setDirectory( anInitialPath );
670 fd->selectFile(aMeshName);
674 aFilename = fd->selectedFile();
675 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
680 else if ( isMED || isSAUV ) // Export to MED or SAUV
682 QMap<QString, SMESH::MED_VERSION> aFilterMap;
683 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
685 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
686 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
687 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
690 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
691 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
692 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
696 QString aDefaultFilter;
697 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
698 for ( ; it != aFilterMap.end(); ++it ) {
699 filters.push_back( it.key() );
700 if (it.value() == SMESH::MED_V2_2)
701 aDefaultFilter = it.key();
703 QStringList checkBoxes;
704 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
706 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
707 QList< QWidget* > wdgList;
708 if ( fieldSelWdg->GetAllFeilds( aMeshList, aFieldList ))
709 wdgList.append( fieldSelWdg );
711 SalomeApp_CheckFileDlg* fd =
712 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
713 fd->setWindowTitle( aTitle );
714 fd->setNameFilters( filters );
715 fd->selectNameFilter( aDefaultFilter );
716 fd->SetChecked( toCreateGroups, 0 );
717 fd->SetChecked( toFindOutDim, 1 );
718 if ( !anInitialPath.isEmpty() )
719 fd->setDirectory( anInitialPath );
720 fd->selectFile(aMeshName);
723 QListView *lview = fd->findChild<QListView*>("listView");
725 lview->setMinimumHeight(200);
727 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
729 tview->setMinimumHeight(200);
732 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
733 fd->setValidator( fv );
738 aFilename = fd->selectedFile();
740 aFilename = QString::null;
743 aFormat = aFilterMap[fd->selectedNameFilter()];
744 toOverwrite = fv->isOverwrite();
746 if ( !aFilename.isEmpty() ) {
747 // med-2.1 does not support poly elements
748 if ( aFormat==SMESH::MED_V2_1 )
749 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
750 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
751 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
752 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
753 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
755 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
756 QObject::tr("SMESH_WRN_WARNING"),
757 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
758 QObject::tr("SMESH_BUT_YES"),
759 QObject::tr("SMESH_BUT_NO"), 0, 1);
767 // can't append to an existing using other format
768 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
769 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
770 if( !isVersionOk || aVersion != aFormat ) {
771 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
772 QObject::tr("SMESH_WRN_WARNING"),
773 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
774 QObject::tr("SMESH_BUT_YES"),
775 QObject::tr("SMESH_BUT_NO"), 0, 1);
782 QStringList aMeshNamesCollisionList;
783 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
784 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
785 QString anExistingMeshName( aMeshNames[ i ] );
786 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
787 QString anExportMeshName = (*aMeshIter).second;
788 if( anExportMeshName == anExistingMeshName ) {
789 aMeshNamesCollisionList.append( anExportMeshName );
794 if( !aMeshNamesCollisionList.isEmpty() ) {
795 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
796 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
797 QObject::tr("SMESH_WRN_WARNING"),
798 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
799 QObject::tr("SMESH_BUT_YES"),
800 QObject::tr("SMESH_BUT_NO"),
801 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
810 toCreateGroups = fd->IsChecked(0);
811 toFindOutDim = fd->IsChecked(1);
812 fieldSelWdg->GetSelectedFeilds();
813 if ( !fieldSelWdg->parent() )
824 if ( !aFilename.isEmpty() ) {
825 // Check whether the file already exists and delete it if yes
826 QFile aFile( aFilename );
827 if ( aFile.exists() && toOverwrite )
829 SUIT_OverrideCursor wc;
832 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
833 // bool Renumber = false;
834 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
836 // Renumber= resMgr->booleanValue("renumbering");
838 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
839 // aMeshEditor->RenumberNodes();
840 // aMeshEditor->RenumberElements();
841 // if ( SMESHGUI::automaticUpdate() )
842 // SMESH::UpdateView();
846 aMeshIter = aMeshList.begin();
847 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
849 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
850 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
851 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
852 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
853 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
854 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
855 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
856 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
858 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
859 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
860 fields, geoAssFields.toLatin1().data() );
865 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
867 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
868 if( !aMeshItem->_is_nil() )
869 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
874 if ( aMeshOrGroup->_is_equivalent( aMesh ))
875 aMesh->ExportDAT( aFilename.toUtf8().data() );
877 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
881 if ( aMeshOrGroup->_is_equivalent( aMesh ))
882 aMesh->ExportUNV( aFilename.toUtf8().data() );
884 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
888 if ( aMeshOrGroup->_is_equivalent( aMesh ))
889 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
891 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
895 aMeshIter = aMeshList.begin();
896 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
898 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
899 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
900 aMeshItem->ExportCGNS( aMeshOrGroup,
901 aFilename.toUtf8().data(),
902 toOverwrite && aMeshIndex == 0 );
907 toCreateGroups = true;
908 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
911 catch (const SALOME::SALOME_Exception& S_ex){
913 SUIT_MessageBox::warning(SMESHGUI::desktop(),
914 QObject::tr("SMESH_WRN_WARNING"),
915 QObject::tr("SMESH_EXPORT_FAILED"));
921 inline void InverseEntityMode(unsigned int& theOutputMode,
922 unsigned int theMode)
924 bool anIsNotPresent = ~theOutputMode & theMode;
926 theOutputMode |= theMode;
928 theOutputMode &= ~theMode;
931 void SetDisplayEntity(int theCommandID){
932 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
933 SALOME_ListIO selected;
935 aSel->selectedObjects( selected );
937 if(selected.Extent() >= 1){
938 SALOME_ListIteratorOfListIO It( selected );
939 for( ; It.More(); It.Next()){
940 Handle(SALOME_InteractiveObject) IObject = It.Value();
941 if(IObject->hasEntry()){
942 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
943 unsigned int aMode = anActor->GetEntityMode();
944 switch(theCommandID){
945 case SMESHOp::OpDE0DElements:
946 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
948 case SMESHOp::OpDEEdges:
949 InverseEntityMode(aMode,SMESH_Actor::eEdges);
951 case SMESHOp::OpDEFaces:
952 InverseEntityMode(aMode,SMESH_Actor::eFaces);
954 case SMESHOp::OpDEVolumes:
955 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
957 case SMESHOp::OpDEBalls:
958 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
960 case SMESHOp::OpDEAllEntity:
961 aMode = SMESH_Actor::eAllEntity;
965 anActor->SetEntityMode(aMode);
974 SALOME_ListIO selected;
975 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
979 LightApp_SelectionMgr* aSel = app->selectionMgr();
980 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
981 if( !aSel || !appStudy )
984 aSel->selectedObjects( selected );
985 if( selected.IsEmpty() )
988 Handle(SALOME_InteractiveObject) anIObject = selected.First();
990 _PTR(Study) aStudy = appStudy->studyDS();
991 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
992 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
993 if( aMainObject->_is_nil() )
996 SUIT_OverrideCursor wc;
998 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1000 QList<SALOMEDS::Color> aReservedColors;
1002 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1003 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1005 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1006 //SALOMEDS::Color aColor = aGroupObject->GetColor();
1008 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1009 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1010 #else // old algorithm for auto-colors
1011 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1012 aReservedColors.append( aColor );
1013 #endif // SIMPLE_AUTOCOLOR
1014 aGroupObject->SetColor( aColor );
1016 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1017 if (aGroupSObject) {
1020 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1021 switch ( aGroupObject->GetType ()) {
1023 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1025 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1027 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1029 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1031 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1032 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1035 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1036 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1042 SMESH::RepaintCurrentView();
1045 void OverallMeshQuality() {
1046 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1047 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1048 SALOME_ListIO selected;
1050 aSel->selectedObjects( selected );
1052 if ( selected.IsEmpty() ) return;
1053 SALOME_ListIteratorOfListIO It( selected );
1054 for ( ; It.More(); It.Next() ) {
1055 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1056 ctrlDlg->showInfo( It.Value() );
1061 QString functorToString( SMESH::Controls::FunctorPtr f )
1063 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1064 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1065 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1066 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1067 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1068 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1069 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1070 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1071 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1072 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1073 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1074 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1075 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1076 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1077 type = QObject::tr( "WARP_ELEMENTS" );
1078 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1079 type = QObject::tr( "TAPER_ELEMENTS" );
1080 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1081 type = QObject::tr( "SKEW_ELEMENTS" );
1082 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1083 type = QObject::tr( "AREA_ELEMENTS" );
1084 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1085 type = QObject::tr( "LENGTH_EDGES" );
1086 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1087 type = QObject::tr( "LENGTH2D_EDGES" );
1088 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1089 type = QObject::tr( "MULTI_BORDERS" );
1090 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1091 type = QObject::tr( "MULTI2D_BORDERS" );
1092 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1093 type = QObject::tr( "FREE_NODES" );
1094 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1095 type = QObject::tr( "FREE_EDGES" );
1096 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1097 type = QObject::tr( "FREE_BORDERS" );
1098 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1099 type = QObject::tr( "FREE_FACES" );
1100 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1101 type = QObject::tr( "BARE_BORDER_VOLUME" );
1102 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1103 type = QObject::tr( "BARE_BORDER_FACE" );
1104 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1105 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1106 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1107 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1108 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1109 type = QObject::tr( "EQUAL_NODE" );
1110 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1111 type = QObject::tr( "EQUAL_EDGE" );
1112 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1113 type = QObject::tr( "EQUAL_FACE" );
1114 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1115 type = QObject::tr( "EQUAL_VOLUME" );
1119 void SaveDistribution()
1121 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1122 SALOME_ListIO selected;
1124 aSel->selectedObjects( selected );
1126 if ( selected.Extent() == 1 ) {
1127 Handle(SALOME_InteractiveObject) anIO = selected.First();
1128 if ( anIO->hasEntry() ) {
1129 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1130 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1131 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1132 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1133 if ( aScalarBarActor && aFunctor ) {
1134 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1136 std::vector<int> elements;
1137 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1138 if ( mesh->_is_nil() ) {
1139 SMESH::SMESH_IDSource_var idSource =
1140 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1141 if ( !idSource->_is_nil() )
1143 SMESH::long_array_var ids = idSource->GetIDs();
1144 elements.resize( ids->length() );
1145 for ( unsigned i = 0; i < elements.size(); ++i )
1146 elements[i] = ids[i];
1149 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1150 vtkLookupTable* lookupTable =
1151 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1152 double * minmax = lookupTable->GetRange();
1153 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1154 std::vector<int> nbEvents;
1155 std::vector<double> funValues;
1156 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
1157 QString anInitialPath = "";
1158 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1159 anInitialPath = QDir::currentPath();
1160 QString aMeshName = anIO->getName();
1162 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1163 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1164 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1165 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1166 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1169 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1171 if ( !aFilename.isEmpty() ) {
1172 QFile f( aFilename );
1173 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1174 QTextStream out( &f );
1175 out << "# Mesh: " << aMeshName << endl;
1176 out << "# Control: " << functorToString( aFunctor ) << endl;
1178 out.setFieldWidth( 10 );
1179 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1180 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1191 void ShowElement(int theCommandID ) {
1192 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1193 SALOME_ListIO selected;
1195 aSel->selectedObjects( selected );
1197 if ( selected.Extent() == 1 ) {
1198 Handle(SALOME_InteractiveObject) anIO = selected.First();
1199 if ( anIO->hasEntry() ) {
1200 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1201 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1202 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1203 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1204 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1206 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1207 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1214 #ifndef DISABLE_PLOT2DVIEWER
1215 void PlotDistribution() {
1216 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1220 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1221 SALOME_ListIO selected;
1223 aSel->selectedObjects( selected );
1225 if ( selected.Extent() == 1 ) {
1226 Handle(SALOME_InteractiveObject) anIO = selected.First();
1227 if ( anIO->hasEntry() ) {
1228 //Find Actor by entry before getting Plot2d viewer,
1229 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1230 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1232 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1237 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1241 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1245 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1246 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1247 QString functorName = functorToString( anActor->GetFunctor());
1248 QString aHistogramName("%1 : %2");
1249 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1250 aHistogram->setName(aHistogramName);
1251 aHistogram->setHorTitle(functorName);
1252 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1253 aPlot->displayObject(aHistogram, true);
1258 #endif //DISABLE_PLOT2DVIEWER
1260 void DisableAutoColor(){
1261 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1262 SALOME_ListIO selected;
1264 aSel->selectedObjects( selected );
1266 if(selected.Extent()){
1267 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1268 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1269 if ( !aMesh->_is_nil() ) {
1270 aMesh->SetAutoColor( false );
1275 void sortChildren(){
1276 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1277 SALOME_ListIO selected;
1279 aSel->selectedObjects( selected );
1281 if(selected.Extent()){
1282 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1283 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1284 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1286 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1287 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1294 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1296 SALOME_ListIO selected;
1297 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1301 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1302 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1303 if( !aSel || !appStudy )
1306 if( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1307 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1308 aModule->EmitSignalDeactivateDialog();
1309 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1310 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1315 _PTR(Study) aStudy = appStudy->studyDS();
1317 aSel->selectedObjects( selected );
1319 if(selected.Extent() >= 1){
1320 switch(theCommandID){
1321 case SMESHOp::OpTransparency:{
1322 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1323 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1326 case SMESHOp::OpProperties: {
1328 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1329 QColor orientationColor, outlineColor, volumeColor;
1330 int deltaF = 0, deltaV = 0;
1333 double ballScale = 1.0;
1335 int outlineWidth = 1;
1336 double shrinkCoef = 0.0;
1337 double orientationScale = 0.0;
1338 bool orientation3d = false;
1339 VTK::MarkerType markerType = VTK::MT_NONE;
1340 VTK::MarkerScale markerScale = VTK::MS_NONE;
1342 bool hasNodes = false;
1343 int presentEntities = 0;
1344 bool firstTime = true;
1346 SALOME_ListIteratorOfListIO It( selected );
1347 for ( ; It.More(); It.Next() ) {
1348 Handle(SALOME_InteractiveObject) IObject = It.Value();
1349 if ( !IObject->hasEntry() ) continue;
1350 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1351 if ( !anActor || !anActor->GetObject() ) continue;
1354 // nodes: color, marker
1355 anActor->GetNodeColor( color[0], color[1], color[2] );
1356 nodeColor.setRgbF( color[0], color[1], color[2] );
1357 markerType = anActor->GetMarkerType();
1358 markerScale = anActor->GetMarkerScale();
1359 markerId = anActor->GetMarkerTexture();
1360 // edges: color, width
1361 anActor->GetEdgeColor( color[0], color[1], color[2] );
1362 edgeColor.setRgbF( color[0], color[1], color[2] );
1363 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1364 // faces: front color, back color (delta)
1365 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1366 faceColor.setRgbF( color[0], color[1], color[2] );
1367 // faces: front color, back color (delta)
1368 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1369 volumeColor.setRgbF( color[0], color[1], color[2] );
1370 // 0d elements: color, size
1371 anActor->Get0DColor( color[0], color[1], color[2] );
1372 elem0dColor.setRgbF( color[0], color[1], color[2] );
1373 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1374 // balls: color, size
1375 anActor->GetBallColor( color[0], color[1], color[2] );
1376 ballColor.setRgbF( color[0], color[1], color[2] );
1377 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1378 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1380 anActor->GetOutlineColor( color[0], color[1], color[2] );
1381 outlineColor.setRgbF( color[0], color[1], color[2] );
1382 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1383 // orientation vectors: color, scale, 3d flag
1384 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1385 orientationColor.setRgbF( color[0], color[1], color[2] );
1386 orientationScale = anActor->GetFacesOrientationScale();
1387 orientation3d = anActor->GetFacesOrientation3DVectors();
1389 shrinkCoef = anActor->GetShrinkFactor();
1392 firstTime = false; // we only take properties from first object (for performance reasons)
1395 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1396 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1397 presentEntities = presentEntities | SMESH_Actor::eEdges;
1398 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1399 presentEntities = presentEntities | SMESH_Actor::eFaces;
1400 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1401 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1402 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1403 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1404 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1405 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1407 // as we know that all types of elements are present, we can exit the loop
1408 if ( presentEntities == SMESH_Actor::eAllEntity )
1412 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1413 // nodes: color, marker
1414 dlg.setNodeColor( nodeColor );
1415 if( markerType != VTK::MT_USER )
1416 dlg.setNodeMarker( markerType, markerScale );
1418 dlg.setNodeCustomMarker( markerId );
1419 // edges: color, line width
1420 dlg.setEdgeColor( edgeColor );
1421 dlg.setEdgeWidth( edgeWidth );
1422 // faces: front color, back color
1423 dlg.setFaceColor( faceColor, deltaF );
1424 // volumes: normal color, reversed color
1425 dlg.setVolumeColor( volumeColor, deltaV );
1426 // outlines: color, line width
1427 dlg.setOutlineColor( outlineColor );
1428 dlg.setOutlineWidth( outlineWidth );
1429 // 0d elements: color, size
1430 dlg.setElem0dColor( elem0dColor );
1431 dlg.setElem0dSize( elem0dSize );
1432 // balls: color, size
1433 dlg.setBallColor( ballColor );
1434 //dlg.setBallSize( ballSize );
1435 dlg.setBallScale( ballScale );
1436 // orientation: color, scale, 3d flag
1437 dlg.setOrientationColor( orientationColor );
1438 dlg.setOrientationSize( int( orientationScale * 100. ) );
1439 dlg.setOrientation3d( orientation3d );
1440 // shrink: scale factor
1441 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1442 // hide unused controls
1443 dlg.showControls( presentEntities, hasNodes );
1446 nodeColor = dlg.nodeColor();
1447 markerType = dlg.nodeMarkerType();
1448 markerScale = dlg.nodeMarkerScale();
1449 markerId = dlg.nodeMarkerId();
1450 edgeColor = dlg.edgeColor();
1451 edgeWidth = dlg.edgeWidth();
1452 faceColor = dlg.faceColor();
1453 deltaF = dlg.faceColorDelta();
1454 volumeColor = dlg.volumeColor();
1455 deltaV = dlg.volumeColorDelta();
1456 outlineColor = dlg.outlineColor();
1457 outlineWidth = dlg.outlineWidth();
1458 elem0dColor = dlg.elem0dColor();
1459 elem0dSize = dlg.elem0dSize();
1460 ballColor = dlg.ballColor();
1461 // ballSize = dlg.ballSize();
1462 ballScale = dlg.ballScale();
1463 orientationColor = dlg.orientationColor();
1464 orientationScale = dlg.orientationSize() / 100.;
1465 orientation3d = dlg.orientation3d();
1466 shrinkCoef = dlg.shrinkCoef() / 100.;
1468 // store point markers map that might be changed by the user
1469 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1471 // set properties from dialog box to the presentations
1472 SALOME_ListIteratorOfListIO It( selected );
1473 for ( ; It.More(); It.Next() ) {
1474 Handle(SALOME_InteractiveObject) IObject = It.Value();
1475 if ( !IObject->hasEntry() ) continue;
1476 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1477 if ( !anActor ) continue;
1479 // nodes: color, marker
1480 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1481 if ( markerType != VTK::MT_USER ) {
1482 anActor->SetMarkerStd( markerType, markerScale );
1485 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1486 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1487 if ( iter != markerMap.end() )
1488 anActor->SetMarkerTexture( markerId, iter->second.second );
1490 // volumes: normal color, reversed color (delta)
1491 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1492 // faces: front color, back color (delta)
1493 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1494 // edges: color, width
1495 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1496 anActor->SetLineWidth( edgeWidth );
1498 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1499 anActor->SetOutlineWidth( outlineWidth );
1500 // 0D elements: color, size
1501 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1502 anActor->Set0DSize( elem0dSize );
1503 // balls: color, size
1504 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1505 // anActor->SetBallSize( ballSize );
1506 anActor->SetBallScale( ballScale );
1507 // orientation: color, scale, 3d flag
1508 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1509 anActor->SetFacesOrientationScale( orientationScale );
1510 anActor->SetFacesOrientation3DVectors( orientation3d );
1512 anActor->SetShrinkFactor( shrinkCoef );
1514 // for groups, set also proper color
1515 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1516 if ( !aGroupObject->_is_nil() ) {
1517 SMESH::ElementType anElementType = aGroupObject->GetType();
1519 switch( anElementType ) {
1521 aColor = nodeColor; break;
1523 aColor = edgeColor; break;
1525 aColor = faceColor; break;
1527 aColor = volumeColor; break;
1529 aColor = elem0dColor; break;
1531 aColor = ballColor; break;
1535 if ( aColor.isValid() ) {
1536 SALOMEDS::Color aGroupColor;
1537 aGroupColor.R = aColor.redF();
1538 aGroupColor.G = aColor.greenF();
1539 aGroupColor.B = aColor.blueF();
1540 aGroupObject->SetColor( aGroupColor );
1542 } // if ( !aGroupObject->_is_nil() )
1543 } // for ( ; It.More(); It.Next() )
1544 SMESH::RepaintCurrentView();
1545 } // if ( dlg.exec() )
1547 } // case SMESHOp::OpProperties:
1548 } // switch(theCommandID)
1549 SALOME_ListIteratorOfListIO It( selected );
1550 for( ; It.More(); It.Next()){
1551 Handle(SALOME_InteractiveObject) IObject = It.Value();
1552 if(IObject->hasEntry()){
1553 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1554 switch(theCommandID){
1555 case SMESHOp::OpDMWireframe:
1556 anActor->SetRepresentation(SMESH_Actor::eEdge);
1558 case SMESHOp::OpDMShading:
1559 anActor->SetRepresentation(SMESH_Actor::eSurface);
1561 case SMESHOp::OpDMShrink:
1562 if(anActor->IsShrunk())
1563 anActor->UnShrink();
1565 anActor->SetShrink();
1567 case SMESHOp::OpDMNodes:
1568 anActor->SetRepresentation(SMESH_Actor::ePoint);
1570 case SMESHOp::OpRepresentationLines:
1571 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1572 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1574 case SMESHOp::OpRepresentationArcs:
1575 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1576 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1582 SMESH::RepaintCurrentView();
1586 int ActionToControl( int theID, bool theReversed )
1588 NCollection_DoubleMap<int,int> ActionControl;
1589 ActionControl.Bind( 0, SMESH_Actor::eNone );
1590 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1591 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1592 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1593 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1594 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1595 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1596 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1597 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1598 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1599 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1600 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1601 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1602 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1603 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1604 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1605 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1606 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1607 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1608 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1609 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1610 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1611 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1612 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1613 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1614 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1615 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1617 return theReversed ? ActionControl.Find2( theID ) : ActionControl.Find1( theID );
1620 void Control( int theCommandID )
1622 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ) );
1623 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1624 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1625 SALOME_ListIO selected;
1627 aSel->selectedObjects( selected );
1629 if( !selected.IsEmpty() ){
1630 SALOME_ListIteratorOfListIO It(selected);
1631 for ( ; It.More(); It.Next())
1633 Handle(SALOME_InteractiveObject) anIO = It.Value();
1635 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1637 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1638 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
1639 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
1640 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
1641 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
1642 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1643 anActor->SetControlMode(aControl);
1644 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1645 SMESH::RepaintCurrentView();
1646 #ifndef DISABLE_PLOT2DVIEWER
1647 if(anActor->GetPlot2Histogram()) {
1648 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1649 QString functorName = functorToString( anActor->GetFunctor());
1650 QString aHistogramName("%1 : %2");
1651 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1652 aHistogram->setName(aHistogramName);
1653 aHistogram->setHorTitle(functorName);
1654 SMESH::ProcessIn2DViewers(anActor);
1666 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1667 SMESH::MeshObjectType theType,
1668 const QString theInTypeName,
1669 QString & theOutTypeName)
1671 SMESH_TypeFilter aTypeFilter( theType );
1673 if( !theIO.IsNull() )
1675 entry = theIO->getEntry();
1676 LightApp_DataOwner owner( entry );
1677 if ( aTypeFilter.isOk( &owner )) {
1678 theOutTypeName = theInTypeName;
1686 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1688 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1689 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1691 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1692 CORBA::String_var anID = aSComp->GetID().c_str();
1693 if (!strcmp(anID.in(),theIO->getEntry()))
1699 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1700 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1701 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1702 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1703 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1711 QString CheckHomogeneousSelection()
1713 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1714 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1715 SALOME_ListIO selected;
1717 aSel->selectedObjects( selected );
1719 QString RefType = CheckTypeObject(selected.First());
1720 SALOME_ListIteratorOfListIO It(selected);
1721 for ( ; It.More(); It.Next())
1723 Handle(SALOME_InteractiveObject) IObject = It.Value();
1724 QString Type = CheckTypeObject(IObject);
1725 if (Type.compare(RefType) != 0)
1726 return "Heterogeneous Selection";
1732 uint randomize( uint size )
1734 static bool initialized = false;
1735 if ( !initialized ) {
1736 qsrand( QDateTime::currentDateTime().toTime_t() );
1740 v = uint( (double)( v ) / RAND_MAX * size );
1741 v = qMax( uint(0), qMin ( v, size-1 ) );
1747 void SMESHGUI::OnEditDelete()
1749 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1750 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1751 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1753 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1754 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1755 _PTR(GenericAttribute) anAttr;
1756 _PTR(AttributeIOR) anIOR;
1758 int objectCount = 0;
1760 QString aParentComponent = QString::null;
1761 Handle(SALOME_InteractiveObject) anIO;
1762 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1764 anIO = anIt.Value();
1765 QString cur = anIO->getComponentDataType();
1766 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1768 // check if object is reference
1769 _PTR(SObject) aRefSObj;
1770 aNameList.append("\n - ");
1771 if ( aSO->ReferencedObject( aRefSObj ) ) {
1772 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1773 aNameList.append( aRefName );
1774 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1777 aNameList.append(anIO->getName());
1781 if( aParentComponent.isNull() )
1782 aParentComponent = cur;
1783 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1784 aParentComponent = "";
1787 if ( objectCount == 0 )
1788 return; // No Valid Objects Selected
1790 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1791 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1792 QObject::tr("ERR_ERROR"),
1793 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1796 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1797 if (SUIT_MessageBox::warning
1798 (SMESHGUI::desktop(),
1799 QObject::tr("SMESH_WRN_WARNING"),
1800 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1801 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1802 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1805 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1807 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1808 // then treat them all starting from the deepest objects (at list back)
1809 std::list< _PTR(SObject) > listSO;
1810 SALOME_ListIteratorOfListIO It(selected);
1811 for( ; It.More(); It.Next()) // loop on selected IO's
1813 Handle(SALOME_InteractiveObject) IObject = It.Value();
1814 if(IObject->hasEntry()) {
1815 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1817 // disable removal of "SMESH" component object
1818 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1820 if ( engineIOR() == anIOR->Value().c_str() )
1823 //Check the referenced object
1824 _PTR(SObject) aRefSObject;
1825 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1826 aSO = aRefSObject; // Delete main Object instead of reference
1828 listSO.push_back( aSO );
1829 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1830 for ( ; itSO != listSO.end(); ++itSO ) {
1831 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1832 for (it->InitEx(false); it->More(); it->Next())
1833 listSO.push_back( it->Value() );
1837 // Check if none of objects to delete is referred from outside
1838 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1839 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1841 _PTR(SObject) SO = *ritSO;
1842 if ( !SO ) continue;
1843 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1844 for (size_t i = 0; i < aReferences.size(); i++) {
1845 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1846 std::string type = aComponent->ComponentDataType();
1847 if ( type != "SMESH" )
1849 SUIT_MessageBox::warning( anApp->desktop(),
1850 QObject::tr("WRN_WARNING"),
1851 QObject::tr("DEP_OBJECT") );
1852 return; // outside SMESH, there is an object depending on a SMESH object
1857 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1858 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1860 Handle(SALOME_InteractiveObject) IObject = It.Value();
1861 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1862 if ( !mesh->_is_nil() )
1866 // Treat SO's in the list starting from the back
1867 aStudyBuilder->NewCommand(); // There is a transaction
1868 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1870 _PTR(SObject) SO = *ritSO;
1871 if ( !SO ) continue;
1872 std::string anEntry = SO->GetID();
1874 /** Erase graphical object and remove all its data **/
1875 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1876 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1878 /** Remove an object from data structures **/
1879 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1880 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1881 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1882 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1883 aMesh->RemoveGroup( aGroup );
1885 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1886 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1887 aMesh->RemoveSubMesh( aSubMesh );
1889 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1891 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1894 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1895 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1896 QString objType = CheckTypeObject(IObject);
1897 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1898 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1899 aStudyBuilder->RemoveObjectWithChildren( SO );
1901 else {// default action: remove SObject from the study
1902 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1903 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1905 aStudyBuilder->RemoveObjectWithChildren( SO );
1909 } /* listSO back loop */
1911 aStudyBuilder->CommitCommand();
1913 /* Clear any previous selection */
1915 aSel->setSelectedObjects( l1 );
1917 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1921 SMESHGUI_EXPORT CAM_Module* createModule()
1923 return new SMESHGUI();
1926 SMESHGUI_EXPORT char* getModuleVersion() {
1927 return (char*)SMESH_VERSION_STR;
1931 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1933 //=============================================================================
1937 //=============================================================================
1938 SMESHGUI::SMESHGUI() :
1939 SalomeApp_Module( "SMESH" )
1941 if ( CORBA::is_nil( myComponentSMESH ) )
1943 CORBA::Boolean anIsEmbeddedMode;
1944 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1945 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1947 // 0019923: EDF 765 SMESH : default values of hypothesis
1948 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1949 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1950 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1951 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1952 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1954 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
1955 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1956 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1958 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1959 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1963 myActiveDialogBox = 0;
1964 myFilterLibraryDlg = 0;
1968 myEventCallbackCommand = vtkCallbackCommand::New();
1969 myEventCallbackCommand->Delete();
1970 myEventCallbackCommand->SetClientData( this );
1971 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1974 /* load resources for all available meshers */
1975 SMESH::InitAvailableHypotheses();
1978 //=============================================================================
1982 //=============================================================================
1983 SMESHGUI::~SMESHGUI()
1987 //=============================================================================
1991 //=============================================================================
1992 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1994 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1996 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2001 //=============================================================================
2005 //=============================================================================
2006 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2008 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2012 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2013 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2014 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2015 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2016 return autoUpdate && !exceeded;
2019 //=============================================================================
2023 //=============================================================================
2024 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2025 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2027 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2031 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2032 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2033 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2035 SMESH::long_array_var info = theMesh->GetMeshInfo();
2036 long nbOdElems = info[SMDSEntity_0D];
2037 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2038 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2039 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2040 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2041 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2042 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2043 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2044 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
2045 info[SMDSEntity_Polyhedra] +
2046 info[SMDSEntity_Hexagonal_Prism];
2047 long nbBalls = info[SMDSEntity_Ball];
2049 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2050 *nbElements = requestedSize;
2052 *entities = SMESH_Actor::eAllEntity;
2055 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2057 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2059 if ( incrementalLimit ) {
2062 if ( nbOdElems > 0 ) {
2063 if ( total + nbOdElems > updateLimit ) {
2064 *entities = *entities & ~SMESH_Actor::e0DElements;
2065 *hidden = *hidden | SMESH_Actor::e0DElements;
2072 if ( nbEdges > 0 ) {
2073 if ( total + nbEdges > updateLimit ) {
2074 *entities = *entities & ~SMESH_Actor::eEdges;
2075 *hidden = *hidden | SMESH_Actor::eEdges;
2082 if ( nbFaces > 0 ) {
2083 if ( total + nbFaces > updateLimit ) {
2084 *entities = *entities & ~SMESH_Actor::eFaces;
2085 *hidden = *hidden | SMESH_Actor::eFaces;
2092 if ( nbVolumes > 0 ) {
2093 if ( total + nbVolumes > updateLimit ) {
2094 *entities = *entities & ~SMESH_Actor::eVolumes;
2095 *hidden = *hidden | SMESH_Actor::eVolumes;
2102 if ( nbBalls > 0 ) {
2103 if ( total + nbBalls > updateLimit ) {
2104 *entities = *entities & ~SMESH_Actor::eBallElem;
2105 *hidden = *hidden | SMESH_Actor::eBallElem;
2113 return autoUpdate && !exceeded;
2116 //=============================================================================
2120 //=============================================================================
2121 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2123 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2126 //=============================================================================
2130 //=============================================================================
2131 SMESHGUI* SMESHGUI::GetSMESHGUI()
2133 SMESHGUI* smeshMod = 0;
2134 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2137 CAM_Module* module = app->module( "Mesh" );
2138 smeshMod = dynamic_cast<SMESHGUI*>( module );
2141 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2143 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2146 _PTR(Study) aStudy = study->studyDS();
2148 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2157 Standard_EXPORT SMESHGUI* GetComponentGUI()
2159 return SMESHGUI::GetSMESHGUI();
2163 //=============================================================================
2167 //=============================================================================
2168 void SMESHGUI::SetState(int aState)
2173 //=============================================================================
2177 //=============================================================================
2178 void SMESHGUI::ResetState()
2183 //=============================================================================
2187 //=============================================================================
2188 void SMESHGUI::EmitSignalDeactivateDialog()
2190 emit SignalDeactivateActiveDialog();
2193 //=============================================================================
2197 //=============================================================================
2198 void SMESHGUI::EmitSignalStudyFrameChanged()
2200 emit SignalStudyFrameChanged();
2203 //=============================================================================
2207 //=============================================================================
2208 void SMESHGUI::EmitSignalCloseAllDialogs()
2210 emit SignalCloseAllDialogs();
2213 //=============================================================================
2217 //=============================================================================
2218 void SMESHGUI::EmitSignalVisibilityChanged()
2220 emit SignalVisibilityChanged();
2223 //=============================================================================
2227 //=============================================================================
2228 void SMESHGUI::EmitSignalCloseView()
2230 emit SignalCloseView();
2233 //=============================================================================
2237 //=============================================================================
2238 void SMESHGUI::EmitSignalActivatedViewManager()
2240 emit SignalActivatedViewManager();
2243 //=============================================================================
2247 //=============================================================================
2248 QDialog *SMESHGUI::GetActiveDialogBox()
2250 return myActiveDialogBox;
2253 //=============================================================================
2257 //=============================================================================
2258 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2260 myActiveDialogBox = (QDialog *) aDlg;
2264 //=============================================================================
2268 //=============================================================================
2269 SUIT_Desktop* SMESHGUI::desktop()
2271 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2273 return app->desktop();
2278 //=============================================================================
2282 //=============================================================================
2283 SalomeApp_Study* SMESHGUI::activeStudy()
2285 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2287 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2292 //=============================================================================
2296 //=============================================================================
2297 void SMESHGUI::Modified( bool theIsUpdateActions )
2299 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2300 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2301 appStudy->Modified();
2302 if( theIsUpdateActions )
2303 app->updateActions();
2308 //=============================================================================
2312 //=============================================================================
2313 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2315 /* Here the position is on the bottom right corner - 10 */
2316 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2318 SUIT_Desktop *PP = desktop();
2319 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2320 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2324 //=============================================================================
2328 //=============================================================================
2329 static int isStudyLocked(_PTR(Study) theStudy){
2330 return theStudy->GetProperties()->IsLocked();
2333 static bool checkLock(_PTR(Study) theStudy) {
2334 if (isStudyLocked(theStudy)) {
2335 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2336 QObject::tr("WRN_WARNING"),
2337 QObject::tr("WRN_STUDY_LOCKED") );
2343 //=======================================================================
2344 //function : CheckActiveStudyLocked
2346 //=======================================================================
2348 bool SMESHGUI::isActiveStudyLocked()
2350 _PTR(Study) aStudy = activeStudy()->studyDS();
2351 return checkLock( aStudy );
2354 //=============================================================================
2358 //=============================================================================
2359 bool SMESHGUI::OnGUIEvent( int theCommandID )
2361 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2365 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2366 SUIT_ResourceMgr* mgr = resourceMgr();
2370 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2371 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2374 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2375 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2377 //QAction* act = action( theCommandID );
2379 switch (theCommandID) {
2380 case SMESHOp::OpDelete:
2381 if(checkLock(aStudy)) break;
2384 case SMESHOp::OpImportDAT:
2385 case SMESHOp::OpImportUNV:
2386 case SMESHOp::OpImportMED:
2387 case SMESHOp::OpImportSTL:
2389 case SMESHOp::OpImportCGNS:
2391 case SMESHOp::OpImportSAUV:
2392 case SMESHOp::OpImportGMF:
2394 if(checkLock(aStudy)) break;
2395 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2399 case SMESHOp::OpFileInformation:
2401 SALOME_ListIO selected;
2402 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2404 aSel->selectedObjects( selected );
2405 if( selected.Extent() )
2407 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2408 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2409 if ( !aMesh->_is_nil() )
2411 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2417 case SMESHOp::OpExportDAT:
2418 case SMESHOp::OpExportMED:
2419 case SMESHOp::OpExportUNV:
2420 case SMESHOp::OpExportSTL:
2422 case SMESHOp::OpExportCGNS:
2424 case SMESHOp::OpExportSAUV:
2425 case SMESHOp::OpExportGMF:
2426 case SMESHOp::OpPopupExportDAT:
2427 case SMESHOp::OpPopupExportMED:
2428 case SMESHOp::OpPopupExportUNV:
2429 case SMESHOp::OpPopupExportSTL:
2431 case SMESHOp::OpPopupExportCGNS:
2433 case SMESHOp::OpPopupExportSAUV:
2434 case SMESHOp::OpPopupExportGMF:
2436 ::ExportMeshToFile(theCommandID);
2440 case SMESHOp::OpReset: // SCALAR BAR
2442 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2443 SALOME_ListIO selected;
2445 aSel->selectedObjects( selected );
2447 SALOME_ListIteratorOfListIO it(selected);
2448 for( ; it.More(); it.Next()) {
2449 Handle(SALOME_InteractiveObject) anIO = it.Value();
2450 if( anIO->hasEntry() ) {
2451 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2452 anActor->SetControlMode( SMESH_Actor::eNone );
2453 #ifndef DISABLE_PLOT2DVIEWER
2454 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2459 SMESH::UpdateView();
2462 case SMESHOp::OpScalarBarProperties:
2464 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2467 case SMESHOp::OpShowScalarBar:
2469 // show/hide scalar bar
2470 ::ShowElement(theCommandID);
2473 case SMESHOp::OpSaveDistribution:
2475 // dump control distribution data to the text file
2476 ::SaveDistribution();
2480 case SMESHOp::OpShowDistribution:
2482 // show/hide distribution
2483 ::ShowElement(theCommandID);
2487 #ifndef DISABLE_PLOT2DVIEWER
2488 case SMESHOp::OpPlotDistribution:
2490 // plot distribution
2491 ::PlotDistribution();
2497 case SMESHOp::OpAutoColor:
2501 case SMESHOp::OpDisableAutoColor:
2502 ::DisableAutoColor();
2505 case SMESHOp::OpClipping:
2506 case SMESHOp::OpTransparency:
2507 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2510 case SMESHOp::OpDMWireframe:
2511 case SMESHOp::OpDMShading:
2512 case SMESHOp::OpDMNodes:
2513 case SMESHOp::OpDMShrink:
2514 ::SetDisplayMode(theCommandID, myMarkerMap);
2517 //2D quadratic representation
2518 case SMESHOp::OpRepresentationLines:
2519 case SMESHOp::OpRepresentationArcs:
2520 ::SetDisplayMode(theCommandID, myMarkerMap);
2524 case SMESHOp::OpDE0DElements:
2525 case SMESHOp::OpDEEdges:
2526 case SMESHOp::OpDEFaces:
2527 case SMESHOp::OpDEVolumes:
2528 case SMESHOp::OpDEBalls:
2529 case SMESHOp::OpDEAllEntity:
2530 ::SetDisplayEntity(theCommandID);
2533 // Choose entities to be displayed
2534 case SMESHOp::OpDEChoose:
2536 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2540 case SMESHOp::OpOrientationOnFaces:
2542 LightApp_SelectionMgr* mgr = selectionMgr();
2543 SALOME_ListIO selected; mgr->selectedObjects( selected );
2545 SALOME_ListIteratorOfListIO it(selected);
2546 for( ; it.More(); it.Next()) {
2547 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2548 if(anIObject->hasEntry()) {
2549 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2550 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2557 case SMESHOp::OpUpdate:
2559 if(checkLock(aStudy)) break;
2560 SUIT_OverrideCursor wc;
2562 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2565 SMESH::UpdateView();
2567 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2568 SMESH::OnVisuException();
2570 catch (...) { // PAL16774 (Crash after display of many groups)
2571 SMESH::OnVisuException();
2575 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2576 aSel->selectedObjects( l );
2577 aSel->setSelectedObjects( l );
2581 case SMESHOp::OpHide:
2582 case SMESHOp::OpShow:
2583 case SMESHOp::OpShowOnly:
2585 SMESH::EDisplaing anAction;
2586 switch (theCommandID) {
2587 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2588 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2589 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2592 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2593 SALOME_ListIO sel_objects, to_process;
2595 aSel->selectedObjects( sel_objects );
2597 if ( theCommandID==SMESHOp::OpShowOnly )
2599 MESSAGE("anAction = SMESH::eDisplayOnly");
2600 startOperation( myEraseAll );
2603 extractContainers( sel_objects, to_process );
2606 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2610 SALOME_ListIteratorOfListIO It( to_process );
2611 for ( ; It.More(); It.Next())
2613 Handle(SALOME_InteractiveObject) IOS = It.Value();
2614 if ( IOS->hasEntry() )
2616 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2617 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2618 break; // PAL16774 (Crash after display of many groups)
2620 if (anAction == SMESH::eDisplayOnly)
2621 anAction = SMESH::eDisplay;
2626 // PAL13338 + PAL15161 -->
2627 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2628 MESSAGE("anAction = SMESH::eDisplayOnly");
2629 SMESH::UpdateView();
2630 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2632 // PAL13338 + PAL15161 <--
2634 catch (...) { // PAL16774 (Crash after display of many groups)
2635 SMESH::OnVisuException();
2638 if (anAction == SMESH::eErase) {
2639 MESSAGE("anAction == SMESH::eErase");
2641 aSel->setSelectedObjects( l1 );
2644 aSel->setSelectedObjects( to_process );
2649 case SMESHOp::OpNode:
2651 if(checkLock(aStudy)) break;
2654 EmitSignalDeactivateDialog();
2656 ( new SMESHGUI_NodesDlg( this ) )->show();
2659 SUIT_MessageBox::warning(desktop(),
2660 tr("SMESH_WRN_WARNING"),
2661 tr("SMESH_WRN_VIEWER_VTK"));
2666 case SMESHOp::OpCreateMesh:
2667 case SMESHOp::OpCreateSubMesh:
2668 case SMESHOp::OpEditMeshOrSubMesh:
2669 case SMESHOp::OpCompute:
2670 case SMESHOp::OpPreCompute:
2671 case SMESHOp::OpEvaluate:
2672 case SMESHOp::OpMeshOrder:
2673 startOperation( theCommandID );
2675 case SMESHOp::OpCopyMesh:
2677 if (checkLock(aStudy)) break;
2678 EmitSignalDeactivateDialog();
2679 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2682 case SMESHOp::OpBuildCompoundMesh:
2684 if (checkLock(aStudy)) break;
2685 EmitSignalDeactivateDialog();
2686 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2690 case SMESHOp::OpDiagonalInversion:
2691 case SMESHOp::OpUnionOfTwoTriangle:
2695 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2696 tr( "NOT_A_VTK_VIEWER" ) );
2700 if ( checkLock( aStudy ) )
2703 /*Standard_Boolean aRes;
2704 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2705 if ( aMesh->_is_nil() )
2707 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2708 tr( "SMESH_BAD_SELECTION" ) );
2712 EmitSignalDeactivateDialog();
2713 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2714 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2716 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2719 case SMESHOp::OpOrientation:
2720 case SMESHOp::OpUnionOfTriangles:
2721 case SMESHOp::OpCuttingOfQuadrangles:
2722 case SMESHOp::OpSplitVolumes:
2726 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2727 tr( "NOT_A_VTK_VIEWER" ) );
2731 if ( checkLock( aStudy ) )
2734 EmitSignalDeactivateDialog();
2735 SMESHGUI_MultiEditDlg* aDlg = NULL;
2736 if ( theCommandID == SMESHOp::OpOrientation )
2737 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2738 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2739 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2740 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2741 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2743 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2748 case SMESHOp::OpSmoothing:
2750 if(checkLock(aStudy)) break;
2752 EmitSignalDeactivateDialog();
2753 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2756 SUIT_MessageBox::warning(desktop(),
2757 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2761 case SMESHOp::OpExtrusion:
2763 if (checkLock(aStudy)) break;
2765 EmitSignalDeactivateDialog();
2766 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2768 SUIT_MessageBox::warning(desktop(),
2769 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2773 case SMESHOp::OpExtrusionAlongAPath:
2775 if (checkLock(aStudy)) break;
2777 EmitSignalDeactivateDialog();
2778 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2780 SUIT_MessageBox::warning(desktop(),
2781 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2785 case SMESHOp::OpRevolution:
2787 if(checkLock(aStudy)) break;
2789 EmitSignalDeactivateDialog();
2790 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2793 SUIT_MessageBox::warning(desktop(),
2794 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2798 case SMESHOp::OpPatternMapping:
2800 if ( checkLock( aStudy ) )
2804 EmitSignalDeactivateDialog();
2805 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2808 SUIT_MessageBox::warning(desktop(),
2809 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2813 case SMESHOp::OpSplitBiQuadratic:
2814 case SMESHOp::OpConvertMeshToQuadratic:
2815 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2816 case SMESHOp::OpReorientFaces:
2817 case SMESHOp::OpCreateGeometryGroup:
2819 startOperation( theCommandID );
2822 case SMESHOp::OpCreateGroup:
2826 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2827 tr( "NOT_A_VTK_VIEWER" ) );
2831 if(checkLock(aStudy)) break;
2832 EmitSignalDeactivateDialog();
2833 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2835 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2836 SALOME_ListIO selected;
2838 aSel->selectedObjects( selected );
2840 int nbSel = selected.Extent();
2842 // check if mesh is selected
2843 aMesh = SMESH::GetMeshByIO( selected.First() );
2845 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2850 case SMESHOp::OpConstructGroup:
2854 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2855 tr( "NOT_A_VTK_VIEWER" ) );
2859 if(checkLock(aStudy)) break;
2860 EmitSignalDeactivateDialog();
2862 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2863 SALOME_ListIO selected;
2865 aSel->selectedObjects( selected );
2867 int nbSel = selected.Extent();
2869 // check if submesh is selected
2870 Handle(SALOME_InteractiveObject) IObject = selected.First();
2871 if (IObject->hasEntry()) {
2872 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2874 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2875 if (!aSubMesh->_is_nil()) {
2877 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2878 // get submesh elements list by types
2879 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2880 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2881 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2882 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2883 // create group for each type o elements
2884 QString aName = IObject->getName();
2885 QStringList anEntryList;
2886 if (aNodes->length() > 0) {
2887 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2888 aGroup->Add(aNodes.inout());
2889 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2890 anEntryList.append( aSObject->GetID().c_str() );
2892 if (aEdges->length() > 0) {
2893 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2894 aGroup->Add(aEdges.inout());
2895 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2896 anEntryList.append( aSObject->GetID().c_str() );
2898 if (aFaces->length() > 0) {
2899 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2900 aGroup->Add(aFaces.inout());
2901 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2902 anEntryList.append( aSObject->GetID().c_str() );
2904 if (aVolumes->length() > 0) {
2905 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2906 aGroup->Add(aVolumes.inout());
2907 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2908 anEntryList.append( aSObject->GetID().c_str() );
2911 anApp->browseObjects( anEntryList );
2913 catch(const SALOME::SALOME_Exception & S_ex){
2914 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2921 SUIT_MessageBox::warning(desktop(),
2922 tr("SMESH_WRN_WARNING"),
2923 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2928 case SMESHOp::OpEditGroup:
2932 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2933 tr( "NOT_A_VTK_VIEWER" ) );
2937 if(checkLock(aStudy)) break;
2938 EmitSignalDeactivateDialog();
2940 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2941 SALOME_ListIO selected;
2943 aSel->selectedObjects( selected );
2945 SALOME_ListIteratorOfListIO It (selected);
2946 int nbSelectedGroups = 0;
2947 for ( ; It.More(); It.Next() )
2949 SMESH::SMESH_GroupBase_var aGroup =
2950 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2951 if (!aGroup->_is_nil()) {
2953 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2957 if (nbSelectedGroups == 0)
2959 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2965 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
2967 if(checkLock(aStudy)) break;
2968 if (myState == 800) {
2969 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2970 if (aDlg) aDlg->onAdd();
2975 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
2977 if(checkLock(aStudy)) break;
2978 if (myState == 800) {
2979 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2980 if (aDlg) aDlg->onRemove();
2985 case SMESHOp::OpEditGeomGroupAsGroup:
2989 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2990 tr( "NOT_A_VTK_VIEWER" ) );
2994 if(checkLock(aStudy)) break;
2995 EmitSignalDeactivateDialog();
2997 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2998 SALOME_ListIO selected;
3000 aSel->selectedObjects( selected );
3002 SALOME_ListIteratorOfListIO It (selected);
3003 for ( ; It.More(); It.Next() )
3005 SMESH::SMESH_GroupOnGeom_var aGroup =
3006 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3007 if (!aGroup->_is_nil()) {
3008 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3013 SMESH::SMESH_GroupOnFilter_var aGroup =
3014 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3015 if (!aGroup->_is_nil()) {
3016 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3024 case SMESHOp::OpUnionGroups:
3025 case SMESHOp::OpIntersectGroups:
3026 case SMESHOp::OpCutGroups:
3030 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3031 tr( "NOT_A_VTK_VIEWER" ) );
3035 if ( checkLock( aStudy ) )
3038 EmitSignalDeactivateDialog();
3040 SMESHGUI_GroupOpDlg* aDlg = 0;
3041 if ( theCommandID == SMESHOp::OpUnionGroups )
3042 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3043 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3044 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3046 aDlg = new SMESHGUI_CutGroupsDlg( this );
3053 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3055 if ( checkLock( aStudy ) )
3058 EmitSignalDeactivateDialog();
3059 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3065 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3069 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3070 tr( "NOT_A_VTK_VIEWER" ) );
3074 if ( checkLock( aStudy ) )
3077 EmitSignalDeactivateDialog();
3079 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3083 case SMESHOp::OpMeshInformation:
3084 case SMESHOp::OpWhatIs:
3086 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3087 EmitSignalDeactivateDialog();
3088 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3089 SALOME_ListIO selected;
3091 aSel->selectedObjects( selected );
3093 if ( selected.Extent() > 1 ) { // a dlg for each IO
3094 SALOME_ListIteratorOfListIO It( selected );
3095 for ( ; It.More(); It.Next() ) {
3096 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3097 dlg->showInfo( It.Value() );
3102 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3108 case SMESHOp::OpFindElementByPoint:
3110 startOperation( theCommandID );
3114 case SMESHOp::OpEditHypothesis:
3116 if(checkLock(aStudy)) break;
3118 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3119 SALOME_ListIO selected;
3121 aSel->selectedObjects( selected );
3123 int nbSel = selected.Extent();
3126 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3127 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3129 if ( !aHypothesis->_is_nil() )
3131 SMESHGUI_GenericHypothesisCreator* aCreator =
3132 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3135 // set geometry of mesh and sub-mesh to aCreator
3136 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3137 if ( selected.Extent() == 1 )
3139 QString subGeomID, meshGeomID;
3140 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3141 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3143 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3144 aCreator->setShapeEntry( subGeomID );
3145 aCreator->setMainShapeEntry( meshGeomID );
3149 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3159 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3161 if(checkLock(aStudy)) break;
3162 SUIT_OverrideCursor wc;
3164 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3165 SALOME_ListIO selected;
3167 aSel->selectedObjects( selected, QString::null, false );
3169 SALOME_ListIteratorOfListIO It(selected);
3170 for (int i = 0; It.More(); It.Next(), i++) {
3171 Handle(SALOME_InteractiveObject) IObject = It.Value();
3172 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3175 aSel->setSelectedObjects( l1 );
3180 case SMESHOp::OpElem0D:
3181 case SMESHOp::OpBall:
3182 case SMESHOp::OpEdge:
3183 case SMESHOp::OpTriangle:
3184 case SMESHOp::OpQuadrangle:
3185 case SMESHOp::OpPolygon:
3186 case SMESHOp::OpTetrahedron:
3187 case SMESHOp::OpHexahedron:
3188 case SMESHOp::OpPentahedron:
3189 case SMESHOp::OpPyramid:
3190 case SMESHOp::OpHexagonalPrism:
3192 if(checkLock(aStudy)) break;
3194 EmitSignalDeactivateDialog();
3195 SMDSAbs_EntityType type = SMDSEntity_Edge;
3196 switch (theCommandID) {
3197 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3198 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3199 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3200 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3201 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3202 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3203 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3204 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3205 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3206 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3209 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3212 SUIT_MessageBox::warning(desktop(),
3213 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3217 case SMESHOp::OpPolyhedron:
3219 if(checkLock(aStudy)) break;
3221 EmitSignalDeactivateDialog();
3222 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3225 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3226 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3230 case SMESHOp::OpQuadraticEdge:
3231 case SMESHOp::OpQuadraticTriangle:
3232 case SMESHOp::OpBiQuadraticTriangle:
3233 case SMESHOp::OpQuadraticQuadrangle:
3234 case SMESHOp::OpBiQuadraticQuadrangle:
3235 case SMESHOp::OpQuadraticPolygon:
3236 case SMESHOp::OpQuadraticTetrahedron:
3237 case SMESHOp::OpQuadraticPyramid:
3238 case SMESHOp::OpQuadraticPentahedron:
3239 case SMESHOp::OpQuadraticHexahedron:
3240 case SMESHOp::OpTriQuadraticHexahedron:
3242 if(checkLock(aStudy)) break;
3244 EmitSignalDeactivateDialog();
3245 SMDSAbs_EntityType type = SMDSEntity_Last;
3247 switch (theCommandID) {
3248 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3249 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3250 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3251 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3252 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3253 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3254 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3255 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3256 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3257 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3258 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3261 if ( type != SMDSEntity_Last )
3262 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3265 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3266 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3270 case SMESHOp::OpRemoveNodes:
3272 if(checkLock(aStudy)) break;
3274 EmitSignalDeactivateDialog();
3275 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3278 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3279 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3283 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3285 if(checkLock(aStudy)) break;
3287 EmitSignalDeactivateDialog();
3288 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3292 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3293 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3297 case SMESHOp::OpClearMesh: {
3299 if(checkLock(aStudy)) break;
3301 SALOME_ListIO selected;
3302 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3303 aSel->selectedObjects( selected );
3305 SUIT_OverrideCursor wc;
3306 SALOME_ListIteratorOfListIO It (selected);
3307 for ( ; It.More(); It.Next() )
3309 Handle(SALOME_InteractiveObject) IOS = It.Value();
3310 SMESH::SMESH_Mesh_var aMesh =
3311 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3312 if ( aMesh->_is_nil()) continue;
3314 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3316 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3317 SMESH::ModifiedMesh( aMeshSObj, false, true);
3318 // hide groups and submeshes
3319 _PTR(ChildIterator) anIter =
3320 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3321 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3323 _PTR(SObject) so = anIter->Value();
3324 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3327 catch (const SALOME::SALOME_Exception& S_ex){
3329 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3333 SMESH::UpdateView();
3337 case SMESHOp::OpRemoveOrphanNodes:
3339 if(checkLock(aStudy)) break;
3340 SALOME_ListIO selected;
3341 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3342 aSel->selectedObjects( selected );
3343 if ( selected.Extent() == 1 ) {
3344 Handle(SALOME_InteractiveObject) anIO = selected.First();
3345 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3346 if ( !aMesh->_is_nil() ) {
3347 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3348 tr( "SMESH_WARNING" ),
3349 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3350 SUIT_MessageBox::Yes |
3351 SUIT_MessageBox::No,
3352 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3355 SUIT_OverrideCursor wc;
3356 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3357 int removed = aMeshEditor->RemoveOrphanNodes();
3358 SUIT_MessageBox::information(SMESHGUI::desktop(),
3359 tr("SMESH_INFORMATION"),
3360 tr("NB_NODES_REMOVED").arg(removed));
3361 if ( removed > 0 ) {
3362 SMESH::UpdateView();
3363 SMESHGUI::Modified();
3366 catch (const SALOME::SALOME_Exception& S_ex) {
3367 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3376 case SMESHOp::OpRenumberingNodes:
3378 if(checkLock(aStudy)) break;
3380 EmitSignalDeactivateDialog();
3381 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3385 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3386 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3390 case SMESHOp::OpRenumberingElements:
3392 if(checkLock(aStudy)) break;
3394 EmitSignalDeactivateDialog();
3395 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3399 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3400 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3404 case SMESHOp::OpTranslation:
3406 if(checkLock(aStudy)) break;
3408 EmitSignalDeactivateDialog();
3409 ( new SMESHGUI_TranslationDlg( this ) )->show();
3412 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3413 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3417 case SMESHOp::OpRotation:
3419 if(checkLock(aStudy)) break;
3421 EmitSignalDeactivateDialog();
3422 ( new SMESHGUI_RotationDlg( this ) )->show();
3425 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3426 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3430 case SMESHOp::OpSymmetry:
3432 if(checkLock(aStudy)) break;
3434 EmitSignalDeactivateDialog();
3435 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3438 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3439 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3443 case SMESHOp::OpScale:
3445 if(checkLock(aStudy)) break;
3447 EmitSignalDeactivateDialog();
3448 ( new SMESHGUI_ScaleDlg( this ) )->show();
3451 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3452 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3457 case SMESHOp::OpSewing:
3459 if(checkLock(aStudy)) break;
3461 EmitSignalDeactivateDialog();
3462 ( new SMESHGUI_SewingDlg( this ) )->show();
3465 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3466 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3470 case SMESHOp::OpMergeNodes:
3472 if(checkLock(aStudy)) break;
3474 EmitSignalDeactivateDialog();
3475 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3478 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3479 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3483 case SMESHOp::OpMergeElements:
3485 if (checkLock(aStudy)) break;
3487 EmitSignalDeactivateDialog();
3488 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3490 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3491 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3496 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3497 startOperation( SMESHOp::OpMoveNode );
3500 case SMESHOp::OpDuplicateNodes:
3502 if(checkLock(aStudy)) break;
3504 EmitSignalDeactivateDialog();
3505 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3508 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3509 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3514 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3515 startOperation( SMESHOp::OpElem0DOnElemNodes );
3518 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3520 static QList<int> aTypes;
3521 if ( aTypes.isEmpty() )
3523 aTypes.append( SMESH::NODE );
3524 aTypes.append( SMESH::EDGE );
3525 aTypes.append( SMESH::FACE );
3526 aTypes.append( SMESH::VOLUME );
3528 if (!myFilterLibraryDlg)
3529 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3530 else if (myFilterLibraryDlg->isHidden())
3531 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3532 myFilterLibraryDlg->raise();
3536 case SMESHOp::OpFreeNode:
3537 case SMESHOp::OpEqualNode:
3538 case SMESHOp::OpFreeEdge:
3539 case SMESHOp::OpFreeBorder:
3540 case SMESHOp::OpLength:
3541 case SMESHOp::OpConnection:
3542 case SMESHOp::OpEqualEdge:
3543 case SMESHOp::OpFreeFace:
3544 case SMESHOp::OpBareBorderFace:
3545 case SMESHOp::OpOverConstrainedFace:
3546 case SMESHOp::OpLength2D:
3547 case SMESHOp::OpConnection2D:
3548 case SMESHOp::OpArea:
3549 case SMESHOp::OpTaper:
3550 case SMESHOp::OpAspectRatio:
3551 case SMESHOp::OpMinimumAngle:
3552 case SMESHOp::OpWarpingAngle:
3553 case SMESHOp::OpSkew:
3554 case SMESHOp::OpMaxElementLength2D:
3555 case SMESHOp::OpEqualFace:
3556 case SMESHOp::OpAspectRatio3D:
3557 case SMESHOp::OpVolume:
3558 case SMESHOp::OpMaxElementLength3D:
3559 case SMESHOp::OpBareBorderVolume:
3560 case SMESHOp::OpOverConstrainedVolume:
3561 case SMESHOp::OpEqualVolume:
3564 LightApp_SelectionMgr* mgr = selectionMgr();
3565 SALOME_ListIO selected; mgr->selectedObjects( selected );
3567 if( !selected.IsEmpty() ) {
3568 SUIT_OverrideCursor wc;
3569 ::Control( theCommandID );
3572 SUIT_MessageBox::warning(desktop(),
3573 tr( "SMESH_WRN_WARNING" ),
3574 tr( "SMESH_BAD_SELECTION" ) );
3578 SUIT_MessageBox::warning(desktop(),
3579 tr( "SMESH_WRN_WARNING" ),
3580 tr( "NOT_A_VTK_VIEWER" ) );
3583 case SMESHOp::OpOverallMeshQuality:
3584 OverallMeshQuality();
3586 case SMESHOp::OpNumberingNodes:
3588 SUIT_OverrideCursor wc;
3589 LightApp_SelectionMgr* mgr = selectionMgr();
3590 SALOME_ListIO selected; mgr->selectedObjects( selected );
3592 SALOME_ListIteratorOfListIO it(selected);
3593 for( ; it.More(); it.Next()) {
3594 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3595 if(anIObject->hasEntry()) {
3596 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3597 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3603 case SMESHOp::OpNumberingElements:
3605 SUIT_OverrideCursor wc;
3606 LightApp_SelectionMgr* mgr = selectionMgr();
3607 SALOME_ListIO selected; mgr->selectedObjects( selected );
3609 SALOME_ListIteratorOfListIO it(selected);
3610 for( ; it.More(); it.Next()) {
3611 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3612 if(anIObject->hasEntry())
3613 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3614 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3619 case SMESHOp::OpPropertiesLength:
3620 case SMESHOp::OpPropertiesArea:
3621 case SMESHOp::OpPropertiesVolume:
3622 case SMESHOp::OpMinimumDistance:
3623 case SMESHOp::OpBoundingBox:
3625 int page = SMESHGUI_MeasureDlg::MinDistance;
3626 if ( theCommandID == SMESHOp::OpBoundingBox )
3627 page = SMESHGUI_MeasureDlg::BoundingBox;
3628 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3629 page = SMESHGUI_MeasureDlg::Length;
3630 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3631 page = SMESHGUI_MeasureDlg::Area;
3632 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3633 page = SMESHGUI_MeasureDlg::Volume;
3635 EmitSignalDeactivateDialog();
3636 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3640 case SMESHOp::OpSortChild:
3646 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3647 //updateObjBrowser();
3651 //=============================================================================
3655 //=============================================================================
3656 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3661 //=============================================================================
3665 //=============================================================================
3666 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3671 //=============================================================================
3675 //=============================================================================
3676 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3681 //=============================================================================
3682 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3683 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3685 //=============================================================================
3686 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3687 SUIT_ViewWindow* wnd )
3689 if(theIO->hasEntry()){
3690 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3691 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3695 //=======================================================================
3696 // function : createSMESHAction
3698 //=======================================================================
3699 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3700 const int key, const bool toggle, const QString& shortcutAction )
3703 QWidget* parent = application()->desktop();
3704 SUIT_ResourceMgr* resMgr = resourceMgr();
3706 if ( !icon_id.isEmpty() )
3707 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3709 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3710 if ( !pix.isNull() )
3711 icon = QIcon( pix );
3713 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3714 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3715 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3717 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3718 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3721 //=======================================================================
3722 // function : createPopupItem
3724 //=======================================================================
3725 void SMESHGUI::createPopupItem( const int id,
3726 const QString& clients,
3727 const QString& types,
3728 const QString& theRule,
3731 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3732 popupMgr()->insert( action( id ), pId, 0 );
3734 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3735 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3736 QString rule = "(%1) and (%2) and (%3)";
3737 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3738 if( clients.isEmpty() )
3739 rule = rule.arg( QString( "true" ) );
3741 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3742 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3745 bool cont = myRules.contains( id );
3747 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3749 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3750 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3753 //=======================================================================
3754 // function : initialize
3756 //=======================================================================
3757 void SMESHGUI::initialize( CAM_Application* app )
3759 SalomeApp_Module::initialize( app );
3761 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3763 /* Automatic Update flag */
3764 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3766 // ----- create actions --------------
3768 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3769 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3770 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3771 //createSMESHAction( 114, "NUM" );
3772 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3774 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3776 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3777 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3778 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3779 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3780 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3781 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3783 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3785 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3786 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3787 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3788 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3789 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3790 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3792 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3794 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3795 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3796 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3797 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3798 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3799 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3800 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3801 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3802 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3803 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3804 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3805 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3806 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3807 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3808 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3809 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3810 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3811 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3812 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3813 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3814 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3815 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3816 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3817 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3818 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3819 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3820 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3821 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3822 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3823 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3825 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3826 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3827 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3828 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3829 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3830 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3831 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3832 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3833 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3834 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3835 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3836 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3837 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3838 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3839 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3840 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3841 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3842 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3843 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3844 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3845 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3846 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3847 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3848 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3849 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3850 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3851 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3853 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3854 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3855 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3856 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3857 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3858 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3859 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3860 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3861 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3862 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3863 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3864 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3865 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3866 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3867 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3868 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3869 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3870 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3871 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3872 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3873 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3874 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3875 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3876 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3877 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3879 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3880 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3881 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3882 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3884 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3885 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3887 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3888 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3889 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3890 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3891 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3892 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3893 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3894 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3895 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3896 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3897 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3898 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3899 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3900 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3901 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3902 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3903 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3904 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3905 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3906 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3907 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3908 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3909 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3910 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3912 createSMESHAction( SMESHOp::OpReset, "RESET" );
3913 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3914 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
3915 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3916 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3917 #ifndef DISABLE_PLOT2DVIEWER
3918 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3920 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3921 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3922 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3923 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3924 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3925 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3926 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3927 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3928 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3929 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3930 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
3931 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
3932 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3934 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3935 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3937 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3938 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3939 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3940 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3941 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3942 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3943 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3944 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3945 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3947 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3948 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3949 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3950 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3951 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
3953 createSMESHAction( SMESHOp::OpHide, "HIDE" );
3954 createSMESHAction( SMESHOp::OpShow, "SHOW" );
3955 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
3957 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
3959 QList<int> aCtrlActions;
3960 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode // node controls
3961 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
3962 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
3963 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
3964 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
3965 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
3966 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
3967 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
3968 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
3969 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
3970 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
3971 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
3972 aCtrlGroup->setExclusive( true );
3973 for( int i = 0; i < aCtrlActions.size(); i++ )
3974 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
3976 // ----- create menu --------------
3977 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3978 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3979 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3980 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3981 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3982 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3983 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3984 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3986 createMenu( separator(), fileId );
3988 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
3989 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
3990 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3991 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3992 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
3993 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
3994 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
3995 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
3996 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3997 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3998 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3999 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4000 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4002 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4003 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4004 createMenu( SMESHOp::OpImportMED, importId, -1 );
4005 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4007 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4009 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4010 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4011 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4012 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4013 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4014 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4016 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4018 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4019 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4020 createMenu( separator(), fileId, 10 );
4022 createMenu( SMESHOp::OpDelete, editId, -1 );
4024 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4026 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4027 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4028 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4029 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4030 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4031 createMenu( separator(), meshId, -1 );
4032 createMenu( SMESHOp::OpCompute, meshId, -1 );
4033 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4034 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4035 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4036 createMenu( separator(), meshId, -1 );
4037 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4038 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4039 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4040 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4041 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4042 createMenu( separator(), meshId, -1 );
4043 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4044 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4045 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4046 createMenu( separator(), meshId, -1 );
4047 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4048 createMenu( separator(), meshId, -1 );
4049 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4050 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4051 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4052 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4053 createMenu( separator(), meshId, -1 );
4055 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4056 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4057 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4058 createMenu( SMESHOp::OpLength, edgeId, -1 );
4059 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4060 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4061 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4062 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4063 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4064 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4065 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4066 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4067 createMenu( SMESHOp::OpArea, faceId, -1 );
4068 createMenu( SMESHOp::OpTaper, faceId, -1 );
4069 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4070 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4071 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4072 createMenu( SMESHOp::OpSkew, faceId, -1 );
4073 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4074 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4075 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4076 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4077 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4078 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4079 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4080 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4081 createMenu( separator(), ctrlId, -1 );
4082 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4083 createMenu( separator(), ctrlId, -1 );
4084 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4086 createMenu( SMESHOp::OpNode, addId, -1 );
4087 createMenu( SMESHOp::OpElem0D, addId, -1 );
4088 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4089 createMenu( SMESHOp::OpBall, addId, -1 );
4090 createMenu( SMESHOp::OpEdge, addId, -1 );
4091 createMenu( SMESHOp::OpTriangle, addId, -1 );
4092 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4093 createMenu( SMESHOp::OpPolygon, addId, -1 );
4094 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4095 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4096 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4097 createMenu( SMESHOp::OpPyramid, addId, -1 );
4098 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4099 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4100 createMenu( separator(), addId, -1 );
4101 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4102 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4103 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4104 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4105 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4106 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4107 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4108 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4109 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4110 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4111 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4113 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4114 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4115 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4116 createMenu( separator(), removeId, -1 );
4117 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4118 createMenu( separator(), removeId, -1 );
4119 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4121 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4122 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4124 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4125 createMenu( SMESHOp::OpRotation, transfId, -1 );
4126 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4127 createMenu( SMESHOp::OpScale, transfId, -1 );
4128 createMenu( SMESHOp::OpSewing, transfId, -1 );
4129 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4130 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4131 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4133 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4134 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4135 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4136 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4137 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4138 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4139 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4140 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4141 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4142 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4143 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4144 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4145 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4146 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4147 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4148 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4150 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4151 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4152 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4153 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4154 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4155 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4157 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4158 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4159 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4160 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4162 // ----- create toolbars --------------
4163 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4164 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4165 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4166 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4167 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4168 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4169 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4170 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4171 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4172 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4173 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4174 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4175 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4176 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4177 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4179 createTool( SMESHOp::OpCreateMesh, meshTb );
4180 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4181 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4182 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4183 createTool( SMESHOp::OpCopyMesh, meshTb );
4184 createTool( separator(), meshTb );
4185 createTool( SMESHOp::OpCompute, meshTb );
4186 createTool( SMESHOp::OpPreCompute, meshTb );
4187 createTool( SMESHOp::OpEvaluate, meshTb );
4188 createTool( SMESHOp::OpMeshOrder, meshTb );
4190 createTool( SMESHOp::OpCreateGroup, groupTb );
4191 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4192 createTool( SMESHOp::OpConstructGroup, groupTb );
4193 createTool( SMESHOp::OpEditGroup, groupTb );
4195 createTool( SMESHOp::OpMeshInformation, info );
4196 //createTool( SMESHOp::OpStdInfo, meshTb );
4197 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4198 createTool( SMESHOp::OpFindElementByPoint, info );
4200 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4201 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4203 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4204 createTool( SMESHOp::OpLength, ctrl1dTb );
4205 createTool( SMESHOp::OpConnection, ctrl1dTb );
4206 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4208 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4209 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4210 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4211 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4212 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4213 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4214 createTool( SMESHOp::OpArea, ctrl2dTb );
4215 createTool( SMESHOp::OpTaper, ctrl2dTb );
4216 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4217 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4218 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4219 createTool( SMESHOp::OpSkew, ctrl2dTb );
4220 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4221 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4223 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4224 createTool( SMESHOp::OpVolume, ctrl3dTb );
4225 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4226 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4227 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4228 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4230 createTool( SMESHOp::OpNode, addElemTb );
4231 createTool( SMESHOp::OpElem0D, addElemTb );
4232 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4233 createTool( SMESHOp::OpBall, addElemTb );
4234 createTool( SMESHOp::OpEdge, addElemTb );
4235 createTool( SMESHOp::OpTriangle, addElemTb );
4236 createTool( SMESHOp::OpQuadrangle, addElemTb );
4237 createTool( SMESHOp::OpPolygon, addElemTb );
4238 createTool( SMESHOp::OpTetrahedron, addElemTb );
4239 createTool( SMESHOp::OpHexahedron, addElemTb );
4240 createTool( SMESHOp::OpPentahedron, addElemTb );
4241 createTool( SMESHOp::OpPyramid, addElemTb );
4242 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4243 createTool( SMESHOp::OpPolyhedron, addElemTb );
4245 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4246 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4247 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4248 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4249 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4250 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4251 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4252 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4253 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4254 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4255 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4257 createTool( SMESHOp::OpRemoveNodes, remTb );
4258 createTool( SMESHOp::OpRemoveElements, remTb );
4259 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4260 createTool( SMESHOp::OpClearMesh, remTb );
4262 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4263 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4265 createTool( SMESHOp::OpTranslation, transformTb );
4266 createTool( SMESHOp::OpRotation, transformTb );
4267 createTool( SMESHOp::OpSymmetry, transformTb );
4268 createTool( SMESHOp::OpScale, transformTb );
4269 createTool( SMESHOp::OpSewing, transformTb );
4270 createTool( SMESHOp::OpMergeNodes, transformTb );
4271 createTool( SMESHOp::OpMergeElements, transformTb );
4272 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4274 createTool( SMESHOp::OpMoveNode, modifyTb );
4275 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4276 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4277 createTool( SMESHOp::OpOrientation, modifyTb );
4278 createTool( SMESHOp::OpReorientFaces, modifyTb );
4279 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4280 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4281 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4282 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4283 createTool( SMESHOp::OpSmoothing, modifyTb );
4284 createTool( SMESHOp::OpExtrusion, modifyTb );
4285 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4286 createTool( SMESHOp::OpRevolution, modifyTb );
4287 createTool( SMESHOp::OpPatternMapping, modifyTb );
4288 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4289 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4291 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4293 createTool( SMESHOp::OpUpdate, dispModeTb );
4295 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4296 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4299 QString OB = "'ObjectBrowser'",
4300 View = "'" + SVTK_Viewer::Type() + "'",
4302 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4303 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4304 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4305 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4306 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4307 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4308 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4309 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4310 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4311 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4312 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4314 mesh_part = mesh + " " + subMesh + " " + group,
4315 mesh_group = mesh + " " + group,
4316 hyp_alg = hypo + " " + algo;
4318 // popup for object browser
4320 isInvisible("not( isVisible )"),
4321 isEmpty("numberOfNodes = 0"),
4322 isNotEmpty("numberOfNodes <> 0"),
4324 // has nodes, edges, etc in VISIBLE! actor
4325 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4326 hasElems("(count( elemTypes ) > 0)"),
4327 hasDifferentElems("(count( elemTypes ) > 1)"),
4328 hasBalls("({'BallElem'} in elemTypes)"),
4329 hasElems0d("({'Elem0d'} in elemTypes)"),
4330 hasEdges("({'Edge'} in elemTypes)"),
4331 hasFaces("({'Face'} in elemTypes)"),
4332 hasVolumes("({'Volume'} in elemTypes)"),
4333 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4335 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4336 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4337 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, mesh );
4338 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, subMesh, "&& hasGeomReference" );
4339 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4340 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4342 popupMgr()->insert( separator(), -1, 0 );
4343 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& isComputable" );
4344 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& isPreComputable" );
4345 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& isComputable" );
4346 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& isComputable && hasGeomReference" );
4347 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4348 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4349 createPopupItem( SMESHOp::OpFindElementByPoint, OB, mesh_group );
4350 createPopupItem( SMESHOp::OpOverallMeshQuality, OB, mesh_part );
4351 popupMgr()->insert( separator(), -1, 0 );
4352 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh );
4353 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& hasGeomReference" );
4354 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4355 popupMgr()->insert( separator(), -1, 0 );
4356 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4357 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4358 popupMgr()->insert( separator(), -1, 0 );
4359 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh + " " + subMesh ); // convert to quadratic
4360 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh + " " + group, // create 2D mesh from 3D
4362 popupMgr()->insert( separator(), -1, 0 );
4363 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4364 popupMgr()->insert( separator(), -1, 0 );
4366 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4367 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4368 QString only_one_2D = only_one_non_empty + " && dim>1";
4370 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4371 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4372 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4373 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4375 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4377 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4378 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4379 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4380 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4381 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4382 popupMgr()->insert( separator(), -1, 0 );
4385 createPopupItem( SMESHOp::OpEditGroup, View, group );
4386 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4387 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4389 popupMgr()->insert( separator(), -1, 0 );
4390 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4391 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4392 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4393 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4394 popupMgr()->insert( separator(), -1, 0 );
4396 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4397 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4398 popupMgr()->insert( separator(), -1, 0 );
4400 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4401 QString aType = QString( "%1type in {%2}" ).arg( lc );
4402 aType = aType.arg( mesh_part );
4403 QString aMeshInVTK = aClient + "&&" + aType;
4405 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4406 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4407 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4409 //-------------------------------------------------
4411 //-------------------------------------------------
4412 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4414 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4415 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4416 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4418 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4419 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4420 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4422 popupMgr()->insert( separator(), -1, -1 );
4424 //-------------------------------------------------
4426 //-------------------------------------------------
4427 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4429 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4430 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4431 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4433 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4434 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4435 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4437 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4438 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4439 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4441 popupMgr()->insert( separator(), anId, -1 );
4443 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4444 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4445 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4447 //-------------------------------------------------
4449 //-------------------------------------------------
4450 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4452 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4454 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4455 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4456 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4458 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4459 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4460 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4462 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4463 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4464 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4466 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4467 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4468 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4470 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4471 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4472 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4474 popupMgr()->insert( separator(), anId, -1 );
4476 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4477 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4479 popupMgr()->insert( separator(), anId, -1 );
4481 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4482 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4485 //-------------------------------------------------
4486 // Representation of the 2D Quadratic elements
4487 //-------------------------------------------------
4488 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4489 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4490 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4491 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4493 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4494 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4495 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4497 //-------------------------------------------------
4498 // Orientation of faces
4499 //-------------------------------------------------
4500 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4501 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4502 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4504 //-------------------------------------------------
4506 //-------------------------------------------------
4507 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4508 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4510 //-------------------------------------------------
4512 //-------------------------------------------------
4513 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4514 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4516 //-------------------------------------------------
4518 //-------------------------------------------------
4520 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4521 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4522 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4523 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4525 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4527 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4528 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4530 popupMgr()->insert( separator(), anId, -1 );
4532 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4534 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4535 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4536 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4538 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4539 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4540 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4542 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4544 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4545 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4546 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4548 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4549 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4550 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4552 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4553 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4554 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4555 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4556 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4557 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4559 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4561 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4562 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4563 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4565 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4566 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4567 QtxPopupMgr::VisibleRule );
4568 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4570 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4571 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4572 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4574 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4575 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4576 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4578 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4579 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4580 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4582 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4583 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4584 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4586 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4587 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4588 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4590 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4591 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4592 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4594 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4595 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4596 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4598 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4599 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4600 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4602 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4603 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4604 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4606 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4607 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4608 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4610 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4611 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4612 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4613 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4614 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4615 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4617 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4619 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4620 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4621 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4623 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4624 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4625 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4627 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4628 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4629 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4631 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4632 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4633 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4635 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4636 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4637 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4639 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4640 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4641 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4643 popupMgr()->insert( separator(), anId, -1 );
4645 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4646 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4647 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4648 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4649 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4651 popupMgr()->insert( separator(), anId, -1 );
4653 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4655 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4656 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4658 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4659 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4660 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4662 #ifndef DISABLE_PLOT2DVIEWER
4663 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4664 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4667 //-------------------------------------------------
4669 //-------------------------------------------------
4670 popupMgr()->insert( separator(), -1, -1 );
4671 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4672 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4673 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4674 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4676 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4677 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4679 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4680 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4682 popupMgr()->insert( separator(), -1, -1 );
4684 //-------------------------------------------------
4686 //-------------------------------------------------
4687 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4688 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4690 popupMgr()->insert( separator(), -1, -1 );
4692 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4693 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4694 popupMgr()->insert( separator(), -1, -1 );
4696 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4697 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4699 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4700 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4703 //================================================================================
4705 * \brief Return true if SMESH or GEOM objects are selected.
4706 * Is called form LightApp_Module::activateModule() which clear selection if
4707 * not isSelectionCompatible()
4709 //================================================================================
4711 bool SMESHGUI::isSelectionCompatible()
4713 bool isCompatible = true;
4714 SALOME_ListIO selected;
4715 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4716 Sel->selectedObjects( selected );
4718 SALOME_ListIteratorOfListIO It( selected );
4719 for ( ; isCompatible && It.More(); It.Next())
4721 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4722 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4724 return isCompatible;
4728 bool SMESHGUI::reusableOperation( const int id )
4730 // compute, evaluate and precompute are not reusable operations
4731 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4734 bool SMESHGUI::activateModule( SUIT_Study* study )
4736 bool res = SalomeApp_Module::activateModule( study );
4738 setMenuShown( true );
4739 setToolShown( true );
4741 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4742 PyGILState_STATE gstate = PyGILState_Ensure();
4743 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4744 if ( !pluginsmanager ) {
4748 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4753 PyGILState_Release(gstate);
4754 // end of SMESH plugins loading
4756 // Reset actions accelerator keys
4757 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4759 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4760 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4761 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4762 if ( _PTR(Study) aStudy = s->studyDS() )
4763 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4766 // get all view currently opened in the study and connect their signals to
4767 // the corresponding slots of the class.
4768 SUIT_Desktop* aDesk = study->application()->desktop();
4770 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4771 SUIT_ViewWindow* wnd;
4772 foreach ( wnd, wndList )
4776 Py_XDECREF(pluginsmanager);
4780 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4782 setMenuShown( false );
4783 setToolShown( false );
4785 EmitSignalCloseAllDialogs();
4787 // Unset actions accelerator keys
4788 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4790 return SalomeApp_Module::deactivateModule( study );
4793 void SMESHGUI::studyClosed( SUIT_Study* s )
4797 SMESH::RemoveVisuData( s->id() );
4798 SalomeApp_Module::studyClosed( s );
4801 void SMESHGUI::OnGUIEvent()
4803 const QObject* obj = sender();
4804 if ( !obj || !obj->inherits( "QAction" ) )
4806 int id = actionId((QAction*)obj);
4811 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4813 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4814 if ( CORBA::is_nil( myComponentSMESH ) )
4816 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4818 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4819 return aGUI.myComponentSMESH;
4822 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4823 return myComponentSMESH;
4826 QString SMESHGUI::engineIOR() const
4828 CORBA::ORB_var anORB = getApp()->orb();
4829 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4830 return QString( anIOR.in() );
4833 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4835 SalomeApp_Module::contextMenuPopup( client, menu, title );
4837 selectionMgr()->selectedObjects( lst );
4838 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4839 Handle(SALOME_InteractiveObject) io = lst.First();
4840 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4841 _PTR(Study) study = appStudy->studyDS();
4842 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4844 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4845 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4846 aName.remove( (aName.length() - 1), 1 );
4852 LightApp_Selection* SMESHGUI::createSelection() const
4854 return new SMESHGUI_Selection();
4857 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4859 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4860 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4861 #ifndef DISABLE_PYCONSOLE
4862 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4866 void SMESHGUI::viewManagers( QStringList& list ) const
4868 list.append( SVTK_Viewer::Type() );
4871 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4873 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4874 SMESH::UpdateSelectionProp( this );
4876 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4877 for(int i = 0; i < aViews.count() ; i++){
4878 SUIT_ViewWindow *sf = aViews[i];
4881 EmitSignalActivatedViewManager();
4885 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4887 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4888 myClippingPlaneInfoMap.erase( theViewManager );
4891 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4893 theActor->AddObserver( SMESH::DeleteActorEvent,
4894 myEventCallbackCommand.GetPointer(),
4898 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4899 unsigned long theEvent,
4900 void* theClientData,
4903 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4904 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
4905 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4906 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4907 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4908 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4909 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4910 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4911 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4912 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4913 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4914 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4915 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4916 if( anActor == *anIter3 ) {
4917 anActorList.erase( anIter3 );
4928 void SMESHGUI::createPreferences()
4930 // General tab ------------------------------------------------------------------------
4931 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4933 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4934 setPreferenceProperty( autoUpdate, "columns", 2 );
4935 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4936 setPreferenceProperty( lim, "min", 0 );
4937 setPreferenceProperty( lim, "max", 100000000 );
4938 setPreferenceProperty( lim, "step", 1000 );
4939 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4940 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4942 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4943 setPreferenceProperty( qaGroup, "columns", 2 );
4944 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4945 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4946 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4947 setPreferenceProperty( prec, "min", 0 );
4948 setPreferenceProperty( prec, "max", 100 );
4949 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4950 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4951 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4952 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4953 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4955 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
4956 setPreferenceProperty( dispgroup, "columns", 2 );
4957 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4959 modes.append( tr("MEN_WIRE") );
4960 modes.append( tr("MEN_SHADE") );
4961 modes.append( tr("MEN_NODES") );
4962 modes.append( tr("MEN_SHRINK") );
4963 QList<QVariant> indices;
4964 indices.append( 0 );
4965 indices.append( 1 );
4966 indices.append( 2 );
4967 indices.append( 3 );
4968 setPreferenceProperty( dispmode, "strings", modes );
4969 setPreferenceProperty( dispmode, "indexes", indices );
4971 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
4972 setPreferenceProperty( arcgroup, "columns", 2 );
4973 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4974 QStringList quadraticModes;
4975 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4976 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4978 indices.append( 0 );
4979 indices.append( 1 );
4980 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4981 setPreferenceProperty( quadraticmode, "indexes", indices );
4983 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4984 "SMESH", "max_angle" );
4985 setPreferenceProperty( maxAngle, "min", 1 );
4986 setPreferenceProperty( maxAngle, "max", 90 );
4990 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4991 setPreferenceProperty( exportgroup, "columns", 2 );
4992 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4993 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4995 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4996 setPreferenceProperty( computeGroup, "columns", 2 );
4997 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4999 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5000 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5001 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5003 indices.append( 0 );
5004 indices.append( 1 );
5005 indices.append( 2 );
5006 setPreferenceProperty( notifyMode, "strings", modes );
5007 setPreferenceProperty( notifyMode, "indexes", indices );
5009 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5010 setPreferenceProperty( infoGroup, "columns", 2 );
5011 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5013 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5014 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5016 indices.append( 0 );
5017 indices.append( 1 );
5018 setPreferenceProperty( elemInfo, "strings", modes );
5019 setPreferenceProperty( elemInfo, "indexes", indices );
5020 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5021 setPreferenceProperty( nodesLim, "min", 0 );
5022 setPreferenceProperty( nodesLim, "max", 10000000 );
5023 setPreferenceProperty( nodesLim, "step", 10000 );
5024 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5025 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5026 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5027 setPreferenceProperty( ctrlLim, "min", 0 );
5028 setPreferenceProperty( ctrlLim, "max", 10000000 );
5029 setPreferenceProperty( ctrlLim, "step", 1000 );
5030 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5031 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5032 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5033 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5034 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5036 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5037 setPreferenceProperty( segGroup, "columns", 2 );
5038 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5039 "SMESH", "segmentation" );
5040 setPreferenceProperty( segLen, "min", 1 );
5041 setPreferenceProperty( segLen, "max", 10000000 );
5042 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5043 "SMESH", "nb_segments_per_edge" );
5044 setPreferenceProperty( nbSeg, "min", 1 );
5045 setPreferenceProperty( nbSeg, "max", 10000000 );
5047 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5048 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5049 "SMESH", "forget_mesh_on_hyp_modif" );
5052 // Quantities with individual precision settings
5053 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5054 setPreferenceProperty( precGroup, "columns", 2 );
5056 const int nbQuantities = 6;
5057 int precs[nbQuantities], ii = 0;
5058 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5059 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5060 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5061 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5062 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5063 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5064 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5065 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5066 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5067 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5068 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5069 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5071 // Set property for precision value for spinboxes
5072 for ( ii = 0; ii < nbQuantities; ii++ ){
5073 setPreferenceProperty( precs[ii], "min", -14 );
5074 setPreferenceProperty( precs[ii], "max", 14 );
5075 setPreferenceProperty( precs[ii], "precision", 2 );
5078 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5079 setPreferenceProperty( previewGroup, "columns", 2 );
5080 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5081 setPreferenceProperty( chunkSize, "min", 1 );
5082 setPreferenceProperty( chunkSize, "max", 1000 );
5083 setPreferenceProperty( chunkSize, "step", 50 );
5085 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5086 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5088 // Mesh tab ------------------------------------------------------------------------
5089 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5090 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5091 setPreferenceProperty( nodeGroup, "columns", 3 );
5093 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5095 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5097 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5098 QList<QVariant> aMarkerTypeIndicesList;
5099 QList<QVariant> aMarkerTypeIconsList;
5100 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5101 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5102 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5103 aMarkerTypeIndicesList << i;
5104 aMarkerTypeIconsList << pixmap;
5106 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5107 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5109 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5111 QList<QVariant> aMarkerScaleIndicesList;
5112 QStringList aMarkerScaleValuesList;
5113 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5114 aMarkerScaleIndicesList << i;
5115 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5117 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5118 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5120 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5121 //setPreferenceProperty( elemGroup, "columns", 2 );
5123 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5124 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5125 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5126 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5127 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5128 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5129 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5130 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5131 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5134 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5135 setPreferenceProperty( grpGroup, "columns", 2 );
5137 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5138 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5140 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5141 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5142 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5143 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5144 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5145 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5146 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5147 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5148 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5149 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5150 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5151 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5152 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5153 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5155 setPreferenceProperty( size0d, "min", 1 );
5156 setPreferenceProperty( size0d, "max", 10 );
5158 // setPreferenceProperty( ballSize, "min", 1 );
5159 // setPreferenceProperty( ballSize, "max", 10 );
5161 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5162 setPreferenceProperty( ballDiameter, "max", 1e9 );
5163 setPreferenceProperty( ballDiameter, "step", 0.1 );
5165 setPreferenceProperty( ballScale, "min", 1e-2 );
5166 setPreferenceProperty( ballScale, "max", 1e7 );
5167 setPreferenceProperty( ballScale, "step", 0.5 );
5169 setPreferenceProperty( elemW, "min", 1 );
5170 setPreferenceProperty( elemW, "max", 5 );
5172 setPreferenceProperty( outW, "min", 1 );
5173 setPreferenceProperty( outW, "max", 5 );
5175 setPreferenceProperty( shrink, "min", 0 );
5176 setPreferenceProperty( shrink, "max", 100 );
5178 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5179 setPreferenceProperty( numGroup, "columns", 2 );
5181 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5182 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5184 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5185 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5187 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5188 setPreferenceProperty( orientGroup, "columns", 1 );
5190 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5191 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5193 setPreferenceProperty( orientScale, "min", 0.05 );
5194 setPreferenceProperty( orientScale, "max", 0.5 );
5195 setPreferenceProperty( orientScale, "step", 0.05 );
5197 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5199 // Selection tab ------------------------------------------------------------------------
5200 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5202 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5203 setPreferenceProperty( selGroup, "columns", 2 );
5205 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5206 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5208 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5209 setPreferenceProperty( preGroup, "columns", 2 );
5211 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5213 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5214 setPreferenceProperty( precSelGroup, "columns", 2 );
5216 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5217 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5218 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5220 // Scalar Bar tab ------------------------------------------------------------------------
5221 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5222 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5223 setPreferenceProperty( fontGr, "columns", 2 );
5225 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5226 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5228 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5229 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5231 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5232 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5234 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5235 setPreferenceProperty( numcol, "min", 2 );
5236 setPreferenceProperty( numcol, "max", 256 );
5238 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5239 setPreferenceProperty( numlab, "min", 2 );
5240 setPreferenceProperty( numlab, "max", 65 );
5242 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5243 setPreferenceProperty( orientGr, "columns", 2 );
5244 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5245 QStringList orients;
5246 orients.append( tr( "SMESH_VERTICAL" ) );
5247 orients.append( tr( "SMESH_HORIZONTAL" ) );
5248 indices.clear(); indices.append( 0 ); indices.append( 1 );
5249 setPreferenceProperty( orient, "strings", orients );
5250 setPreferenceProperty( orient, "indexes", indices );
5252 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5253 setPreferenceProperty( posVSizeGr, "columns", 2 );
5254 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5255 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5256 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5257 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5258 setPreferenceProperty( xv, "step", 0.1 );
5259 setPreferenceProperty( xv, "min", 0.0 );
5260 setPreferenceProperty( xv, "max", 1.0 );
5261 setPreferenceProperty( yv, "step", 0.1 );
5262 setPreferenceProperty( yv, "min", 0.0 );
5263 setPreferenceProperty( yv, "max", 1.0 );
5264 setPreferenceProperty( wv, "step", 0.1 );
5265 setPreferenceProperty( wv, "min", 0.0 );
5266 setPreferenceProperty( wv, "max", 1.0 );
5267 setPreferenceProperty( hv, "min", 0.0 );
5268 setPreferenceProperty( hv, "max", 1.0 );
5269 setPreferenceProperty( hv, "step", 0.1 );
5271 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5272 setPreferenceProperty( posHSizeGr, "columns", 2 );
5273 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5274 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5275 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5276 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5277 setPreferenceProperty( xv, "min", 0.0 );
5278 setPreferenceProperty( xv, "max", 1.0 );
5279 setPreferenceProperty( xv, "step", 0.1 );
5280 setPreferenceProperty( xh, "min", 0.0 );
5281 setPreferenceProperty( xh, "max", 1.0 );
5282 setPreferenceProperty( xh, "step", 0.1 );
5283 setPreferenceProperty( yh, "min", 0.0 );
5284 setPreferenceProperty( yh, "max", 1.0 );
5285 setPreferenceProperty( yh, "step", 0.1 );
5286 setPreferenceProperty( wh, "min", 0.0 );
5287 setPreferenceProperty( wh, "max", 1.0 );
5288 setPreferenceProperty( wh, "step", 0.1 );
5289 setPreferenceProperty( hh, "min", 0.0 );
5290 setPreferenceProperty( hh, "max", 1.0 );
5291 setPreferenceProperty( hh, "step", 0.1 );
5293 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5294 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5295 setPreferenceProperty( distributionGr, "columns", 3 );
5297 types.append( tr( "SMESH_MONOCOLOR" ) );
5298 types.append( tr( "SMESH_MULTICOLOR" ) );
5299 indices.clear(); indices.append( 0 ); indices.append( 1 );
5300 setPreferenceProperty( coloringType, "strings", types );
5301 setPreferenceProperty( coloringType, "indexes", indices );
5302 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5306 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5308 if ( sect=="SMESH" ) {
5309 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5310 float aTol = 1.00000009999999;
5311 std::string aWarning;
5312 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5314 if ( name== "selection_object_color" ||
5315 name=="selection_element_color" ||
5316 name== "highlight_color" ||
5317 name=="selection_precision_node" ||
5318 name=="selection_precision_element" ||
5319 name=="selection_precision_object" )
5321 SMESH::UpdateSelectionProp( this );
5323 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5325 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5326 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5327 if ( sbX1+sbW > aTol ) {
5328 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5331 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5332 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5335 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5337 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5338 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5339 if ( sbY1 + sbH > aTol ) {
5340 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5341 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5342 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5345 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5347 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5348 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5349 if ( sbX1 + sbW > aTol ) {
5350 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5353 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5354 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5357 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5359 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5360 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5361 if ( sbY1 + sbH > aTol ) {
5362 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5365 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5366 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5369 else if ( name == "segmentation" )
5371 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5372 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5374 else if ( name == "nb_segments_per_edge" )
5376 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5377 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5379 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5381 QString val = aResourceMgr->stringValue( "SMESH", name );
5382 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5384 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5386 SMESH::UpdateFontProp( this );
5388 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5390 SMESH::UpdateFontProp( this );
5393 if ( aWarning.size() != 0 ) {
5394 aWarning += "The default values are applied instead.";
5395 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5396 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5397 QObject::tr(aWarning.c_str()));
5402 //================================================================================
5404 * \brief Update something in accordance with update flags
5405 * \param theFlags - update flags
5407 * Update viewer or/and object browser etc. in accordance with update flags ( see
5408 * LightApp_UpdateFlags enumeration ).
5410 //================================================================================
5411 void SMESHGUI::update( const int flags )
5413 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5414 SMESH::UpdateView();
5416 SalomeApp_Module::update( flags );
5419 //================================================================================
5421 * \brief Set default selection mode
5423 * SLOT called when operation commited. Sets default selection mode
5425 //================================================================================
5426 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5428 SVTK_ViewWindow* vtkWnd =
5429 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5431 vtkWnd->SetSelectionMode( ActorSelection );
5434 //================================================================================
5436 * \brief Set default selection mode
5438 * SLOT called when operation aborted. Sets default selection mode
5440 //================================================================================
5441 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5443 SVTK_ViewWindow* vtkWnd =
5444 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5446 vtkWnd->SetSelectionMode( ActorSelection );
5449 //================================================================================
5451 * \brief Creates operation with given identifier
5452 * \param id - identifier of operation to be started
5453 * \return Pointer on created operation or NULL if operation is not created
5455 * Virtual method redefined from the base class creates operation with given id.
5456 * It is called called automatically from startOperation method of base class.
5458 //================================================================================
5459 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5461 LightApp_Operation* op = 0;
5462 // to do : create operation here
5465 case SMESHOp::OpSplitBiQuadratic:
5466 op = new SMESHGUI_SplitBiQuadOp();
5468 case SMESHOp::OpConvertMeshToQuadratic:
5469 op = new SMESHGUI_ConvToQuadOp();
5471 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5472 op = new SMESHGUI_Make2DFrom3DOp();
5474 case SMESHOp::OpReorientFaces:
5475 op = new SMESHGUI_ReorientFacesOp();
5477 case SMESHOp::OpCreateMesh:
5478 op = new SMESHGUI_MeshOp( true, true );
5480 case SMESHOp::OpCreateSubMesh:
5481 op = new SMESHGUI_MeshOp( true, false );
5483 case SMESHOp::OpEditMeshOrSubMesh:
5484 op = new SMESHGUI_MeshOp( false );
5486 case SMESHOp::OpCompute:
5487 op = new SMESHGUI_ComputeOp();
5489 case SMESHOp::OpPreCompute:
5490 op = new SMESHGUI_PrecomputeOp();
5492 case SMESHOp::OpEvaluate:
5493 op = new SMESHGUI_EvaluateOp();
5495 case SMESHOp::OpMeshOrder:
5496 op = new SMESHGUI_MeshOrderOp();
5498 case SMESHOp::OpCreateGeometryGroup:
5499 op = new SMESHGUI_GroupOnShapeOp();
5501 case SMESHOp::OpFindElementByPoint:
5502 op = new SMESHGUI_FindElemByPointOp();
5504 case SMESHOp::OpMoveNode: // Make mesh pass through point
5505 op = new SMESHGUI_MakeNodeAtPointOp();
5507 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5508 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5515 op = SalomeApp_Module::createOperation( id );
5519 //================================================================================
5521 * \brief Stops current operations and starts a given one
5522 * \param id - The id of the operation to start
5524 //================================================================================
5526 void SMESHGUI::switchToOperation(int id)
5528 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5529 activeStudy()->abortAllOperations();
5530 startOperation( id );
5533 LightApp_Displayer* SMESHGUI::displayer()
5536 myDisplayer = new SMESHGUI_Displayer( getApp() );
5540 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5543 int aTolerance = 64;
5544 int anIterations = 0;
5550 if( anIterations % aPeriod == 0 )
5553 if( aTolerance < 1 )
5557 aHue = (int)( 360.0 * rand() / RAND_MAX );
5560 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5561 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5562 for( ; it != itEnd; ++it )
5564 SALOMEDS::Color anAutoColor = *it;
5565 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5568 aQColor.getHsv( &h, &s, &v );
5569 if( abs( h - aHue ) < aTolerance )
5581 aColor.setHsv( aHue, 255, 255 );
5583 SALOMEDS::Color aSColor;
5584 aSColor.R = aColor.redF();
5585 aSColor.G = aColor.greenF();
5586 aSColor.B = aColor.blueF();
5591 const char* gSeparator = "_"; // character used to separate parameter names
5592 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5593 const char* gPathSep = "|"; // character used to separate paths
5596 * \brief Store visual parameters
5598 * This method is called just before the study document is saved.
5599 * Store visual parameters in AttributeParameter attribue(s)
5601 void SMESHGUI::storeVisualParameters (int savePoint)
5604 Kernel_Utils::Localizer loc;
5606 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5607 if (!appStudy || !appStudy->studyDS())
5609 _PTR(Study) studyDS = appStudy->studyDS();
5611 // componentName is used for encoding of entries when storing them in IParameters
5612 std::string componentName = myComponentSMESH->ComponentDataType();
5613 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5614 //if (!aSComponent) return;
5617 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5618 componentName.c_str(),
5620 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5622 // store map of custom markers
5623 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5624 if( !aMarkerMap.empty() )
5626 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5627 for( ; anIter != aMarkerMap.end(); anIter++ )
5629 int anId = anIter->first;
5630 VTK::MarkerData aMarkerData = anIter->second;
5631 std::string aMarkerFileName = aMarkerData.first;
5632 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5633 if( aMarkerTexture.size() < 3 )
5634 continue; // should contain at least width, height and the first value
5636 QString aPropertyName( "texture" );
5637 aPropertyName += gSeparator;
5638 aPropertyName += QString::number( anId );
5640 QString aPropertyValue = aMarkerFileName.c_str();
5641 aPropertyValue += gPathSep;
5643 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5644 ushort aWidth = *aTextureIter++;
5645 ushort aHeight = *aTextureIter++;
5646 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5647 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5648 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5649 aPropertyValue += QString::number( *aTextureIter );
5651 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5655 // viewers counters are used for storing view_numbers in IParameters
5658 // main cycle to store parameters of displayed objects
5659 QList<SUIT_ViewManager*> lst;
5660 QList<SUIT_ViewManager*>::Iterator it;
5661 getApp()->viewManagers(lst);
5662 for (it = lst.begin(); it != lst.end(); it++)
5664 SUIT_ViewManager* vman = *it;
5665 QString vType = vman->getType();
5667 // saving VTK actors properties
5668 if (vType == SVTK_Viewer::Type())
5670 // store the clipping planes attached to the view manager
5671 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5672 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5673 if( anIter != myClippingPlaneInfoMap.end() )
5674 aClippingPlaneInfoList = anIter->second;
5676 if( !aClippingPlaneInfoList.empty() ) {
5677 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5678 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5680 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5681 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5683 QString aPropertyName( "ClippingPlane" );
5684 aPropertyName += gSeparator;
5685 aPropertyName += QString::number( vtkViewers );
5686 aPropertyName += gSeparator;
5687 aPropertyName += QString::number( anId );
5689 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5690 aPropertyValue += gDigitsSep;
5691 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5692 aPropertyValue += gDigitsSep;
5693 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5694 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5695 aPropertyValue += gDigitsSep;
5696 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5697 aPropertyValue += gDigitsSep;
5698 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5699 aPropertyValue += gDigitsSep;
5700 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5701 aPropertyValue += gDigitsSep;
5702 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5703 aPropertyValue += gDigitsSep;
5704 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5705 aPropertyValue += gDigitsSep;
5706 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5708 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5709 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5710 aPropertyValue += gDigitsSep;
5711 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5712 aPropertyValue += gDigitsSep;
5713 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5714 aPropertyValue += gDigitsSep;
5715 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5718 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5722 QVector<SUIT_ViewWindow*> views = vman->getViews();
5723 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5725 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5727 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5728 vtkActorCollection* allActors = aCopy.GetActors();
5729 allActors->InitTraversal();
5730 while (vtkActor* actor = allActors->GetNextActor())
5732 if (actor->GetVisibility()) // store only visible actors
5734 SMESH_Actor* aSmeshActor = 0;
5735 if (actor->IsA("SMESH_Actor"))
5736 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5737 if (aSmeshActor && aSmeshActor->hasIO())
5739 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5742 // entry is "encoded" = it does NOT contain component adress,
5743 // since it is a subject to change on next component loading
5744 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5746 std::string param, vtkParam = vType.toLatin1().data();
5747 vtkParam += gSeparator;
5748 vtkParam += QString::number(vtkViewers).toLatin1().data();
5749 vtkParam += gSeparator;
5752 param = vtkParam + "Visibility";
5753 ip->setParameter(entry, param, "On");
5756 param = vtkParam + "Representation";
5757 ip->setParameter(entry, param, QString::number
5758 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5761 param = vtkParam + "IsShrunk";
5762 ip->setParameter(entry, param, QString::number
5763 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5765 // Displayed entities
5766 unsigned int aMode = aSmeshActor->GetEntityMode();
5767 bool isE = aMode & SMESH_Actor::eEdges;
5768 bool isF = aMode & SMESH_Actor::eFaces;
5769 bool isV = aMode & SMESH_Actor::eVolumes;
5770 bool is0d = aMode & SMESH_Actor::e0DElements;
5771 bool isB = aMode & SMESH_Actor::eBallElem;
5773 QString modeStr ("e");
5774 modeStr += gDigitsSep; modeStr += QString::number(isE);
5775 modeStr += gDigitsSep; modeStr += "f";
5776 modeStr += gDigitsSep; modeStr += QString::number(isF);
5777 modeStr += gDigitsSep; modeStr += "v";
5778 modeStr += gDigitsSep; modeStr += QString::number(isV);
5779 modeStr += gDigitsSep; modeStr += "0d";
5780 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5781 modeStr += gDigitsSep; modeStr += "b";
5782 modeStr += gDigitsSep; modeStr += QString::number(isB);
5784 param = vtkParam + "Entities";
5785 ip->setParameter(entry, param, modeStr.toLatin1().data());
5791 aSmeshActor->GetSufaceColor(r, g, b, delta);
5792 QStringList colorStr;
5793 colorStr << "surface";
5794 colorStr << QString::number(r);
5795 colorStr << QString::number(g);
5796 colorStr << QString::number(b);
5798 colorStr << "backsurface";
5799 colorStr << QString::number(delta);
5801 aSmeshActor->GetVolumeColor(r, g, b, delta);
5802 colorStr << "volume";
5803 colorStr << QString::number(r);
5804 colorStr << QString::number(g);
5805 colorStr << QString::number(b);
5806 colorStr << QString::number(delta);
5808 aSmeshActor->GetEdgeColor(r, g, b);
5810 colorStr << QString::number(r);
5811 colorStr << QString::number(g);
5812 colorStr << QString::number(b);
5814 aSmeshActor->GetNodeColor(r, g, b);
5816 colorStr << QString::number(r);
5817 colorStr << QString::number(g);
5818 colorStr << QString::number(b);
5820 aSmeshActor->GetOutlineColor(r, g, b);
5821 colorStr << "outline";
5822 colorStr << QString::number(r);
5823 colorStr << QString::number(g);
5824 colorStr << QString::number(b);
5826 aSmeshActor->Get0DColor(r, g, b);
5827 colorStr << "elem0d";
5828 colorStr << QString::number(r);
5829 colorStr << QString::number(g);
5830 colorStr << QString::number(b);
5832 aSmeshActor->GetBallColor(r, g, b);
5834 colorStr << QString::number(r);
5835 colorStr << QString::number(g);
5836 colorStr << QString::number(b);
5838 aSmeshActor->GetFacesOrientationColor(r, g, b);
5839 colorStr << "orientation";
5840 colorStr << QString::number(r);
5841 colorStr << QString::number(g);
5842 colorStr << QString::number(b);
5844 param = vtkParam + "Colors";
5845 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5848 QStringList sizeStr;
5850 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5851 sizeStr << "outline";
5852 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5853 sizeStr << "elem0d";
5854 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5856 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5857 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5858 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5859 sizeStr << "shrink";
5860 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5861 sizeStr << "orientation";
5862 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5863 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5865 param = vtkParam + "Sizes";
5866 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5871 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5872 if( aMarkerType == VTK::MT_USER ) {
5873 markerStr += "custom";
5874 markerStr += gDigitsSep;
5875 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5879 markerStr += gDigitsSep;
5880 markerStr += QString::number( (int)aMarkerType );
5881 markerStr += gDigitsSep;
5882 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5885 param = vtkParam + "PointMarker";
5886 ip->setParameter(entry, param, markerStr.toLatin1().data());
5889 param = vtkParam + "Opacity";
5890 ip->setParameter(entry, param,
5891 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5894 param = vtkParam + "ClippingPlane";
5896 if( !aClippingPlaneInfoList.empty() ) {
5897 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5898 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5900 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5901 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5902 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5903 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5904 if( aSmeshActor == *anIter2 ) {
5905 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5906 QString::number( anId ).toLatin1().constData() );
5913 ip->setParameter( entry, param, "Off" );
5914 } // if (io->hasEntry())
5915 } // SMESH_Actor && hasIO
5917 } // while.. actors traversal
5921 } // if (SVTK view model)
5922 } // for (viewManagers)
5925 // data structures for clipping planes processing
5929 bool isOpenGLClipping;
5930 vtkIdType RelativeOrientation;
5933 int AbsoluteOrientation;
5934 double X, Y, Z, Dx, Dy, Dz;
5936 typedef std::list<TPlaneData> TPlaneDataList;
5937 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5939 typedef std::list<vtkActor*> TActorList;
5942 TActorList ActorList;
5943 SUIT_ViewManager* ViewManager;
5945 typedef std::list<TPlaneInfo> TPlaneInfoList;
5946 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5949 * \brief Restore visual parameters
5951 * This method is called after the study document is opened.
5952 * Restore visual parameters from AttributeParameter attribue(s)
5954 void SMESHGUI::restoreVisualParameters (int savePoint)
5957 Kernel_Utils::Localizer loc;
5959 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5960 if (!appStudy || !appStudy->studyDS())
5962 _PTR(Study) studyDS = appStudy->studyDS();
5964 // componentName is used for encoding of entries when storing them in IParameters
5965 std::string componentName = myComponentSMESH->ComponentDataType();
5966 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5967 //if (!aSComponent) return;
5970 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5971 componentName.c_str(),
5973 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5975 // restore map of custom markers and map of clipping planes
5976 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5977 TPlaneDataMap aPlaneDataMap;
5979 std::vector<std::string> properties = ip->getProperties();
5980 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5982 std::string property = *propIt;
5983 QString aPropertyName( property.c_str() );
5984 QString aPropertyValue( ip->getProperty( property ).c_str() );
5986 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5987 if( aPropertyNameList.isEmpty() )
5990 QString aPropertyType = aPropertyNameList[0];
5991 if( aPropertyType == "texture" )
5993 if( aPropertyNameList.size() != 2 )
5997 int anId = aPropertyNameList[1].toInt( &ok );
5998 if( !ok || anId < 1 )
6001 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6002 if( aPropertyValueList.size() != 2 )
6005 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6006 QString aMarkerTextureString = aPropertyValueList[1];
6007 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6008 if( aMarkerTextureStringList.size() != 3 )
6012 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6017 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6021 VTK::MarkerTexture aMarkerTexture;
6022 aMarkerTexture.push_back( aWidth );
6023 aMarkerTexture.push_back( aHeight );
6025 QString aMarkerTextureData = aMarkerTextureStringList[2];
6026 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6028 QChar aChar = aMarkerTextureData.at( i );
6029 if( aChar.isDigit() )
6030 aMarkerTexture.push_back( aChar.digitValue() );
6033 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6035 else if( aPropertyType == "ClippingPlane" )
6037 if( aPropertyNameList.size() != 3 )
6041 int aViewId = aPropertyNameList[1].toInt( &ok );
6042 if( !ok || aViewId < 0 )
6046 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6047 if( !ok || aClippingPlaneId < 0 )
6050 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6051 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6054 TPlaneData aPlaneData;
6055 aPlaneData.Id = aClippingPlaneId;
6058 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6063 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6067 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6070 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6075 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6080 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6085 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6090 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6095 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6100 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6104 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6106 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6111 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6116 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6121 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6126 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6127 aPlaneDataList.push_back( aPlaneData );
6131 TPlaneInfoMap aPlaneInfoMap;
6133 std::vector<std::string> entries = ip->getEntries();
6135 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6137 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6138 QString entry (ip->decodeEntry(*entIt).c_str());
6140 // Check that the entry corresponds to a real object in the Study
6141 // as the object may be deleted or modified after the visual state is saved.
6142 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6143 if (!so) continue; //Skip the not existent entry
6145 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6146 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6148 std::vector<std::string>::iterator namesIt = paramNames.begin();
6149 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6151 // actors are stored in a map after displaying of them for
6152 // quicker access in the future: map < viewID to actor >
6153 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6155 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6157 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6158 // '_' is used as separator and should not be used in viewer type or parameter names.
6159 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6160 if (lst.size() != 3)
6163 QString viewerTypStr = lst[0];
6164 QString viewIndexStr = lst[1];
6165 QString paramNameStr = lst[2];
6168 int viewIndex = viewIndexStr.toUInt(&ok);
6169 if (!ok) // bad conversion of view index to integer
6173 if (viewerTypStr == SVTK_Viewer::Type())
6175 SMESH_Actor* aSmeshActor = 0;
6176 if (vtkActors.IsBound(viewIndex))
6177 aSmeshActor = vtkActors.Find(viewIndex);
6179 QList<SUIT_ViewManager*> lst;
6180 getApp()->viewManagers(viewerTypStr, lst);
6182 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6183 SUIT_ViewManager* vman = NULL;
6184 if (viewIndex >= 0 && viewIndex < lst.count())
6185 vman = lst.at(viewIndex);
6187 if (paramNameStr == "Visibility")
6189 if (!aSmeshActor && displayer() && vman)
6191 SUIT_ViewModel* vmodel = vman->getViewModel();
6192 // SVTK view model can be casted to SALOME_View
6193 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6195 // store displayed actor in a temporary map for quicker
6196 // access later when restoring other parameters
6197 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6198 vtkRenderer* Renderer = vtkView->getRenderer();
6199 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6200 vtkActorCollection* theActors = aCopy.GetActors();
6201 theActors->InitTraversal();
6202 bool isFound = false;
6203 vtkActor *ac = theActors->GetNextActor();
6204 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6205 if (ac->IsA("SMESH_Actor")) {
6206 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6207 if (aGeomAc->hasIO()) {
6208 Handle(SALOME_InteractiveObject) io =
6209 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6210 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6212 vtkActors.Bind(viewIndex, aGeomAc);
6218 } // if (paramNameStr == "Visibility")
6221 // the rest properties "work" with SMESH_Actor
6224 QString val ((*valuesIt).c_str());
6227 if (paramNameStr == "Representation") {
6228 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6231 else if (paramNameStr == "IsShrunk") {
6233 if (!aSmeshActor->IsShrunk())
6234 aSmeshActor->SetShrink();
6237 if (aSmeshActor->IsShrunk())
6238 aSmeshActor->UnShrink();
6241 // Displayed entities
6242 else if (paramNameStr == "Entities") {
6243 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6244 int aEntityMode = SMESH_Actor::eAllEntity;
6245 for ( int i = 0; i < mode.count(); i+=2 ) {
6246 if ( i < mode.count()-1 ) {
6247 QString type = mode[i];
6248 bool val = mode[i+1].toInt();
6249 if ( type == "e" && !val )
6250 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6251 else if ( type == "f" && !val )
6252 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6253 else if ( type == "v" && !val )
6254 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6255 else if ( type == "0d" && !val )
6256 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6257 else if ( type == "b" && !val )
6258 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6261 aSmeshActor->SetEntityMode( aEntityMode );
6264 else if (paramNameStr == "Colors") {
6265 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6272 QColor outlineColor;
6273 QColor orientationColor;
6279 // below lines are required to get default values for delta coefficients
6280 // of backface color for faces and color of reversed volumes
6281 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6282 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6283 for ( int i = 0; i < colors.count(); i++ ) {
6284 QString type = colors[i];
6285 if ( type == "surface" ) {
6286 // face color is set by 3 values r:g:b, where
6287 // - r,g,b - is rgb color components
6288 if ( i+1 >= colors.count() ) break; // format error
6289 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6290 if ( i+2 >= colors.count() ) break; // format error
6291 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6292 if ( i+3 >= colors.count() ) break; // format error
6293 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6294 faceColor.setRgbF( r, g, b );
6297 else if ( type == "backsurface" ) {
6298 // backface color can be defined in several ways
6299 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6300 // - in latest versions, it is set as delta coefficient
6301 bool rgbOk = false, deltaOk;
6302 if ( i+1 >= colors.count() ) break; // format error
6303 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6304 int delta = colors[i+1].toInt( &deltaOk );
6306 if ( i+1 < colors.count() ) // index is shifted to 1
6307 g = colors[i+1].toDouble( &rgbOk );
6308 if ( rgbOk ) i++; // shift index
6309 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6310 b = colors[i+1].toDouble( &rgbOk );
6312 // - as currently there's no way to set directly backsurface color as it was before,
6313 // we ignore old dump where r,g,b triple was set
6314 // - also we check that delta parameter is set properly
6315 if ( !rgbOk && deltaOk )
6318 else if ( type == "volume" ) {
6319 // volume color is set by 4 values r:g:b:delta, where
6320 // - r,g,b - is a normal volume rgb color components
6321 // - delta - is a reversed volume color delta coefficient
6322 if ( i+1 >= colors.count() ) break; // format error
6323 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6324 if ( i+2 >= colors.count() ) break; // format error
6325 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6326 if ( i+3 >= colors.count() ) break; // format error
6327 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6328 if ( i+4 >= colors.count() ) break; // format error
6329 int delta = colors[i+4].toInt( &bOk );
6330 if ( !bOk ) break; // format error
6331 volumeColor.setRgbF( r, g, b );
6335 else if ( type == "edge" ) {
6336 // edge color is set by 3 values r:g:b, where
6337 // - r,g,b - is rgb color components
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 edgeColor.setRgbF( r, g, b );
6347 else if ( type == "node" ) {
6348 // node color is set by 3 values r:g:b, where
6349 // - r,g,b - is rgb color components
6350 if ( i+1 >= colors.count() ) break; // format error
6351 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6352 if ( i+2 >= colors.count() ) break; // format error
6353 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6354 if ( i+3 >= colors.count() ) break; // format error
6355 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6356 nodeColor.setRgbF( r, g, b );
6359 else if ( type == "elem0d" ) {
6360 // 0d element color is set by 3 values r:g:b, where
6361 // - r,g,b - is rgb color components
6362 if ( i+1 >= colors.count() ) break; // format error
6363 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6364 if ( i+2 >= colors.count() ) break; // format error
6365 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6366 if ( i+3 >= colors.count() ) break; // format error
6367 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6368 elem0dColor.setRgbF( r, g, b );
6371 else if ( type == "ball" ) {
6372 // ball color is set by 3 values r:g:b, where
6373 // - r,g,b - is rgb color components
6374 if ( i+1 >= colors.count() ) break; // format error
6375 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6376 if ( i+2 >= colors.count() ) break; // format error
6377 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6378 if ( i+3 >= colors.count() ) break; // format error
6379 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6380 ballColor.setRgbF( r, g, b );
6383 else if ( type == "outline" ) {
6384 // outline color is set by 3 values r:g:b, where
6385 // - r,g,b - is rgb color components
6386 if ( i+1 >= colors.count() ) break; // format error
6387 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6388 if ( i+2 >= colors.count() ) break; // format error
6389 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6390 if ( i+3 >= colors.count() ) break; // format error
6391 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6392 outlineColor.setRgbF( r, g, b );
6395 else if ( type == "orientation" ) {
6396 // orientation color is set by 3 values r:g:b, where
6397 // - r,g,b - is rgb color components
6398 if ( i+1 >= colors.count() ) break; // format error
6399 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6400 if ( i+2 >= colors.count() ) break; // format error
6401 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6402 if ( i+3 >= colors.count() ) break; // format error
6403 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6404 orientationColor.setRgbF( r, g, b );
6409 if ( nodeColor.isValid() )
6410 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6412 if ( edgeColor.isValid() )
6413 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6415 if ( faceColor.isValid() )
6416 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6418 if ( volumeColor.isValid() )
6419 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6420 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6421 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6423 if ( elem0dColor.isValid() )
6424 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6426 if ( ballColor.isValid() )
6427 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6429 if ( outlineColor.isValid() )
6430 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6431 // orientation color
6432 if ( orientationColor.isValid() )
6433 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6436 else if (paramNameStr == "Sizes") {
6437 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6440 int outlineWidth = -1;
6441 int elem0dSize = -1;
6442 //int ballSize = -1;
6443 double ballDiameter = -1.0;
6444 double ballScale = -1.0;
6445 double shrinkSize = -1;
6446 double orientationSize = -1;
6447 bool orientation3d = false;
6448 for ( int i = 0; i < sizes.count(); i++ ) {
6449 QString type = sizes[i];
6450 if ( type == "line" ) {
6451 // line (wireframe) width is given as single integer value
6452 if ( i+1 >= sizes.count() ) break; // format error
6453 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6457 if ( type == "outline" ) {
6458 // outline width is given as single integer value
6459 if ( i+1 >= sizes.count() ) break; // format error
6460 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6464 else if ( type == "elem0d" ) {
6465 // 0d element size is given as single integer value
6466 if ( i+1 >= sizes.count() ) break; // format error
6467 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6471 else if ( type == "ball" ) {
6472 // balls are specified by two values: size:scale, where
6473 // - size - is a integer value specifying size
6474 // - scale - is a double value specifying scale factor
6475 if ( i+1 >= sizes.count() ) break; // format error
6476 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6477 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6478 if ( i+2 >= sizes.count() ) break; // format error
6479 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6485 else if ( type == "shrink" ) {
6486 // shrink factor is given as single floating point value
6487 if ( i+1 >= sizes.count() ) break; // format error
6488 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6492 else if ( type == "orientation" ) {
6493 // orientation vectors are specified by two values size:3d, where
6494 // - size - is a floating point value specifying scale factor
6495 // - 3d - is a boolean
6496 if ( i+1 >= sizes.count() ) break; // format error
6497 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6498 if ( i+2 >= sizes.count() ) break; // format error
6499 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6500 orientationSize = v1;
6501 orientation3d = (bool)v2;
6505 // line (wireframe) width
6506 if ( lineWidth > 0 )
6507 aSmeshActor->SetLineWidth( lineWidth );
6509 if ( outlineWidth > 0 )
6510 aSmeshActor->SetOutlineWidth( outlineWidth );
6511 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6512 aSmeshActor->SetOutlineWidth( lineWidth );
6514 if ( elem0dSize > 0 )
6515 aSmeshActor->Set0DSize( elem0dSize );
6517 /*if ( ballSize > 0 )
6518 aSmeshActor->SetBallSize( ballSize );*/
6520 if ( ballDiameter > 0 )
6521 aSmeshActor->SetBallSize( ballDiameter );
6523 if ( ballScale > 0.0 )
6524 aSmeshActor->SetBallScale( ballScale );
6526 if ( shrinkSize > 0 )
6527 aSmeshActor->SetShrinkFactor( shrinkSize );
6528 // orientation vectors
6529 if ( orientationSize > 0 ) {
6530 aSmeshActor->SetFacesOrientationScale( orientationSize );
6531 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6535 else if (paramNameStr == "PointMarker") {
6536 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6537 if( data.count() >= 2 ) {
6539 int aParam1 = data[1].toInt( &ok );
6541 if( data[0] == "std" && data.count() == 3 ) {
6542 int aParam2 = data[2].toInt( &ok );
6543 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6545 else if( data[0] == "custom" ) {
6546 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6547 if( markerIt != aMarkerMap.end() ) {
6548 VTK::MarkerData aMarkerData = markerIt->second;
6549 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6556 else if (paramNameStr == "Opacity") {
6557 aSmeshActor->SetOpacity(val.toFloat());
6560 else if (paramNameStr.startsWith("ClippingPlane")) {
6561 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6562 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6563 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6564 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6565 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6566 // new format - val looks like "Off" or "0" (plane id)
6567 // (note: in new format "Off" value is used only for consistency,
6568 // so it is processed together with values in old format)
6569 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6570 if( anIsOldFormat ) {
6571 if (paramNameStr == "ClippingPlane1" || val == "Off")
6572 aSmeshActor->RemoveAllClippingPlanes();
6574 QList<SUIT_ViewManager*> lst;
6575 getApp()->viewManagers(viewerTypStr, lst);
6576 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6577 if (viewIndex >= 0 && viewIndex < lst.count()) {
6578 SUIT_ViewManager* vman = lst.at(viewIndex);
6579 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6581 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6583 SMESH::TActorList anActorList;
6584 anActorList.push_back( aSmeshActor );
6585 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6586 aPlane->myViewWindow = vtkView;
6587 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6588 aPlane->PlaneMode = aMode;
6589 bool isOpenGLClipping = ( bool )vals[1].toInt();
6590 aPlane->IsOpenGLClipping = isOpenGLClipping;
6591 if ( aMode == SMESH::Absolute ) {
6592 aPlane->myAbsoluteOrientation = vals[2].toInt();
6593 aPlane->X = vals[3].toFloat();
6594 aPlane->Y = vals[4].toFloat();
6595 aPlane->Z = vals[5].toFloat();
6596 aPlane->Dx = vals[6].toFloat();
6597 aPlane->Dy = vals[7].toFloat();
6598 aPlane->Dz = vals[8].toFloat();
6600 else if ( aMode == SMESH::Relative ) {
6601 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6602 aPlane->myDistance = vals[3].toFloat();
6603 aPlane->myAngle[0] = vals[4].toFloat();
6604 aPlane->myAngle[1] = vals[5].toFloat();
6608 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6609 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6610 aClippingPlaneInfo.Plane = aPlane;
6611 aClippingPlaneInfo.ActorList = anActorList;
6612 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6620 int aPlaneId = val.toInt( &ok );
6621 if( ok && aPlaneId >= 0 ) {
6622 bool anIsDefinedPlane = false;
6623 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6624 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6625 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6626 TPlaneInfo& aPlaneInfo = *anIter;
6627 if( aPlaneInfo.PlaneId == aPlaneId ) {
6628 aPlaneInfo.ActorList.push_back( aSmeshActor );
6629 anIsDefinedPlane = true;
6633 if( !anIsDefinedPlane ) {
6634 TPlaneInfo aPlaneInfo;
6635 aPlaneInfo.PlaneId = aPlaneId;
6636 aPlaneInfo.ActorList.push_back( aSmeshActor );
6637 aPlaneInfo.ViewManager = vman;
6639 // to make the list sorted by plane id
6640 anIter = aPlaneInfoList.begin();
6641 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6642 const TPlaneInfo& aPlaneInfoRef = *anIter;
6643 if( aPlaneInfoRef.PlaneId > aPlaneId )
6646 aPlaneInfoList.insert( anIter, aPlaneInfo );
6651 } // if (aSmeshActor)
6652 } // other parameters than Visibility
6654 } // for names/parameters iterator
6655 } // for entries iterator
6657 // take into account planes with empty list of actors referred to them
6658 QList<SUIT_ViewManager*> aVMList;
6659 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6661 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6662 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6663 int aViewId = aPlaneDataIter->first;
6664 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6665 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6667 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6669 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6670 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6671 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6672 const TPlaneData& aPlaneData = *anIter2;
6673 int aPlaneId = aPlaneData.Id;
6675 bool anIsFound = false;
6676 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6677 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6678 const TPlaneInfo& aPlaneInfo = *anIter3;
6679 if( aPlaneInfo.PlaneId == aPlaneId ) {
6686 TPlaneInfo aPlaneInfo; // ActorList field is empty
6687 aPlaneInfo.PlaneId = aPlaneId;
6688 aPlaneInfo.ViewManager = aViewManager;
6690 // to make the list sorted by plane id
6691 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6692 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6693 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6694 if( aPlaneInfoRef.PlaneId > aPlaneId )
6697 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6703 // add clipping planes to actors according to the restored parameters
6704 // and update the clipping plane map
6705 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6706 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6707 int aViewId = anIter1->first;
6708 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6710 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6711 if( anIter2 == aPlaneDataMap.end() )
6713 const TPlaneDataList& aPlaneDataList = anIter2->second;
6715 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6716 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6717 const TPlaneInfo& aPlaneInfo = *anIter3;
6718 int aPlaneId = aPlaneInfo.PlaneId;
6719 const TActorList& anActorList = aPlaneInfo.ActorList;
6720 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6724 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6728 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6730 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6731 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6732 const TPlaneData& aPlaneData = *anIter4;
6733 if( aPlaneData.Id == aPlaneId ) {
6734 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6735 aPlane->myViewWindow = aViewWindow;
6736 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6737 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6738 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6739 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6740 aPlane->X = aPlaneData.X;
6741 aPlane->Y = aPlaneData.Y;
6742 aPlane->Z = aPlaneData.Z;
6743 aPlane->Dx = aPlaneData.Dx;
6744 aPlane->Dy = aPlaneData.Dy;
6745 aPlane->Dz = aPlaneData.Dz;
6747 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6748 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6749 aPlane->myDistance = aPlaneData.Distance;
6750 aPlane->myAngle[0] = aPlaneData.Angle[0];
6751 aPlane->myAngle[1] = aPlaneData.Angle[1];
6754 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6755 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6756 aClippingPlaneInfo.Plane = aPlane;
6757 aClippingPlaneInfo.ActorList = anActorList;
6758 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6769 // update all VTK views
6770 QList<SUIT_ViewManager*> lst;
6771 getApp()->viewManagers(lst);
6772 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6773 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6774 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6775 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6776 // set OpenGL clipping planes
6777 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6778 vtkActorCollection* anAllActors = aCopy.GetActors();
6779 anAllActors->InitTraversal();
6780 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6781 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6782 anActor->SetOpenGLClippingPlane();
6784 vtkView->getRenderer()->ResetCameraClippingRange();
6791 \brief Adds preferences for dfont of VTK viewer
6793 \param pIf group identifier
6794 \param param parameter
6795 \return identifier of preferences
6797 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6799 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6801 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6804 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6805 fam.append( tr( "SMESH_FONT_COURIER" ) );
6806 fam.append( tr( "SMESH_FONT_TIMES" ) );
6808 setPreferenceProperty( tfont, "fonts", fam );
6810 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6811 if ( needSize ) f = f | QtxFontEdit::Size;
6812 setPreferenceProperty( tfont, "features", f );
6818 \brief Actions after hypothesis edition
6819 Updates object browser after hypothesis edition
6821 void SMESHGUI::onHypothesisEdit( int result )
6824 SMESHGUI::Modified();
6825 updateObjBrowser( true );
6829 \brief Actions after choosing menu of control modes
6830 Updates control mode actions according to current selection
6832 void SMESHGUI::onUpdateControlActions()
6834 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
6835 SALOME_ListIO selected;
6837 aSel->selectedObjects( selected );
6839 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6840 if ( selected.Extent() ) {
6841 if ( selected.First()->hasEntry() ) {
6842 aControl = SMESH::FindActorByEntry( selected.First()->getEntry() )->GetControlMode();
6843 SALOME_ListIteratorOfListIO it(selected);
6844 for ( ; it.More(); it.Next() ) {
6845 Handle(SALOME_InteractiveObject) anIO = it.Value();
6846 if ( anIO->hasEntry() ) {
6847 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6848 if ( aControl != anActor->GetControlMode() ) {
6849 aControl = SMESH_Actor::eNone;
6858 int anAction = ActionToControl( aControl, true );
6860 action( anAction )->setChecked( true );
6862 QMenu* send = (QMenu*)sender();
6863 QList<QAction*> actions = send->actions();
6864 for ( int i = 0; i < actions.size(); i++ )
6865 actions[i]->setChecked( false );
6871 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6872 \param pview view being closed
6874 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6875 #ifndef DISABLE_PLOT2DVIEWER
6876 //Crear all Plot2d Viewers if need.
6877 SMESH::ClearPlot2Viewers(pview);
6879 EmitSignalCloseView();
6882 void SMESHGUI::message( const QString& msg )
6885 QStringList data = msg.split("/");
6886 if ( data.count() > 0 ) {
6887 if ( data.first() == "mesh_loading" ) {
6889 QString entry = data.count() > 1 ? data[1] : QString();
6890 if ( entry.isEmpty() )
6893 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6895 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6898 name = SMESH::fromUtf8(obj->GetName());
6899 if ( name.isEmpty() )
6902 if ( data.last() == "stop" )
6903 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6905 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6906 QApplication::processEvents();
6912 \brief Connects or disconnects signals about activating and cloning view on the module slots
6913 \param pview view which is connected/disconnected
6915 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6919 SUIT_ViewManager* viewMgr = pview->getViewManager();
6921 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6922 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6924 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6925 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6930 \brief Return \c true if object can be renamed
6932 bool SMESHGUI::renameAllowed( const QString& entry) const {
6933 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6937 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6941 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6946 if(appStudy->isComponent(entry) || obj->isReference())
6949 // check type to prevent renaming of inappropriate objects
6950 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6951 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6952 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6953 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6954 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6955 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6962 Rename object by entry.
6963 \param entry entry of the object
6964 \param name new name of the object
6965 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6967 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6969 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6973 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6978 _PTR(Study) aStudy = appStudy->studyDS();
6983 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6985 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6990 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6991 _PTR(GenericAttribute) anAttr;
6992 _PTR(AttributeName) aName;
6994 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6996 // check type to prevent renaming of inappropriate objects
6997 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6998 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6999 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7000 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7001 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7002 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7003 if ( !name.isEmpty() ) {
7004 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
7006 // update name of group object and its actor
7007 Handle(SALOME_InteractiveObject) IObject =
7008 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7010 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7011 if( !aGroupObject->_is_nil() ) {
7012 aGroupObject->SetName( qPrintable(name) );
7013 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7014 anActor->setName( qPrintable(name) );
7024 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7026 static QList<QColor> colors;
7028 if ( colors.isEmpty() ) {
7030 for (int s = 0; s < 2 ; s++)
7032 for (int v = 100; v >= 40; v = v - 20)
7034 for (int h = 0; h < 359 ; h = h + 60)
7036 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7041 static int currentColor = randomize( colors.size() );
7043 SALOMEDS::Color color;
7044 color.R = (double)colors[currentColor].red() / 255.0;
7045 color.G = (double)colors[currentColor].green() / 255.0;
7046 color.B = (double)colors[currentColor].blue() / 255.0;
7048 currentColor = (currentColor+1) % colors.count();