1 // Copyright (C) 2007-2012 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.
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
32 #include "SMESHGUI_AddMeshElementDlg.h"
33 #include "SMESHGUI_AddQuadraticElementDlg.h"
34 #include "SMESHGUI_BuildCompoundDlg.h"
35 #include "SMESHGUI_ClippingDlg.h"
36 #include "SMESHGUI_ComputeDlg.h"
37 #include "SMESHGUI_ConvToQuadOp.h"
38 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
39 #include "SMESHGUI_DeleteGroupDlg.h"
40 #include "SMESHGUI_Displayer.h"
41 #include "SMESHGUI_MergeDlg.h"
42 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
43 #include "SMESHGUI_ExtrusionDlg.h"
44 #include "SMESHGUI_FileInfoDlg.h"
45 #include "SMESHGUI_FileValidator.h"
46 #include "SMESHGUI_FilterDlg.h"
47 #include "SMESHGUI_FilterLibraryDlg.h"
48 #include "SMESHGUI_FindElemByPointDlg.h"
49 #include "SMESHGUI_GroupDlg.h"
50 #include "SMESHGUI_GroupOnShapeDlg.h"
51 #include "SMESHGUI_GroupOpDlg.h"
52 #include "SMESHGUI_Hypotheses.h"
53 #include "SMESHGUI_Make2DFrom3DOp.h"
54 #include "SMESHGUI_MakeNodeAtPointDlg.h"
55 #include "SMESHGUI_Measurements.h"
56 #include "SMESHGUI_MeshInfo.h"
57 #include "SMESHGUI_MeshOp.h"
58 #include "SMESHGUI_MeshOrderOp.h"
59 #include "SMESHGUI_MeshPatternDlg.h"
60 #include "SMESHGUI_MultiEditDlg.h"
61 #include "SMESHGUI_NodesDlg.h"
62 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
63 #include "SMESHGUI_PropertiesDlg.h"
64 #include "SMESHGUI_RemoveElementsDlg.h"
65 #include "SMESHGUI_RemoveNodesDlg.h"
66 #include "SMESHGUI_RenumberingDlg.h"
67 #include "SMESHGUI_RevolutionDlg.h"
68 #include "SMESHGUI_RotationDlg.h"
69 #include "SMESHGUI_Selection.h"
70 #include "SMESHGUI_SewingDlg.h"
71 #include "SMESHGUI_SingleEditDlg.h"
72 #include "SMESHGUI_SmoothingDlg.h"
73 #include "SMESHGUI_SymmetryDlg.h"
74 #include "SMESHGUI_TranslationDlg.h"
75 #include "SMESHGUI_ScaleDlg.h"
76 #include "SMESHGUI_TransparencyDlg.h"
77 #include "SMESHGUI_DuplicateNodesDlg.h"
78 #include "SMESHGUI_CopyMeshDlg.h"
79 #include "SMESHGUI_ReorientFacesDlg.h"
81 #include "SMESHGUI_Utils.h"
82 #include "SMESHGUI_MeshUtils.h"
83 #include "SMESHGUI_GroupUtils.h"
84 #include "SMESHGUI_FilterUtils.h"
85 #include "SMESHGUI_PatternUtils.h"
86 #include "SMESHGUI_VTKUtils.h"
87 #include "SMESHGUI_HypothesesUtils.h"
89 #include <SMESH_version.h>
91 #include <SMESH_Client.hxx>
92 #include <SMESH_Actor.h>
93 #include <SMESH_ScalarBarActor.h>
94 #include <SMESH_ActorUtils.h>
95 #include <SMESH_TypeFilter.hxx>
96 #include "SMESH_ControlsDef.hxx"
98 // SALOME GUI includes
99 #include <SalomeApp_Tools.h>
100 #include <SalomeApp_Study.h>
101 #include <SalomeApp_Application.h>
102 #include <SalomeApp_CheckFileDlg.h>
103 #include <SalomeApp_DataObject.h>
105 #include <LightApp_DataOwner.h>
106 #include <LightApp_Preferences.h>
107 #include <LightApp_SelectionMgr.h>
108 #include <LightApp_UpdateFlags.h>
109 #include <LightApp_NameDlg.h>
111 #include <SVTK_ViewWindow.h>
112 #include <SVTK_ViewModel.h>
113 #include <SVTK_ViewManager.h>
115 #include <VTKViewer_Algorithm.h>
117 #include <SUIT_MessageBox.h>
118 #include <SUIT_ResourceMgr.h>
119 #include <SUIT_FileDlg.h>
120 #include <SUIT_Desktop.h>
121 #include <SUIT_OverrideCursor.h>
122 #include <SUIT_Session.h>
124 #include <QtxPopupMgr.h>
125 #include <QtxFontEdit.h>
127 #include <SALOME_ListIO.hxx>
128 #include <SALOME_ListIteratorOfListIO.hxx>
130 #ifndef DISABLE_PLOT2DVIEWER
131 #include <SPlot2d_ViewModel.h>
132 #include <SPlot2d_Histogram.h>
136 #include <SALOMEconfig.h>
137 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
138 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
139 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
142 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
143 #include <QApplication>
145 #include <QTextStream>
148 #include <boost/shared_ptr.hpp>
151 #include <vtkCamera.h>
152 #include <vtkRenderer.h>
153 #include <vtkPlane.h>
154 #include <vtkCallbackCommand.h>
155 #include <vtkLookupTable.h>
157 // SALOME KERNEL includes
158 #include <SALOMEDS_Study.hxx>
159 #include <SALOMEDSClient_StudyBuilder.hxx>
160 #include <SALOMEDSClient_SComponent.hxx>
161 #include <SALOMEDSClient_ClientFactory.hxx>
162 #include <SALOMEDSClient_IParameters.hxx>
165 #include <Standard_ErrorHandler.hxx>
166 #include <NCollection_DataMap.hxx>
168 //To disable automatic genericobj management, the following line should be commented.
169 //Otherwise, it should be uncommented. Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
170 #define WITHGENERICOBJ
174 //=============================================================
175 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
178 void ExportMeshToFile(int theCommandID);
180 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
182 void SetDisplayEntity(int theCommandID);
184 void Control( int theCommandID );
188 //=============================================================
189 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
193 std::string myExtension;
195 if ( theCommandID == 113 ) {
196 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.med)" );
197 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
199 else if ( theCommandID == 112 ) {
200 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
202 else if ( theCommandID == 111 ) {
203 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
205 else if ( theCommandID == 115 ) {
206 filter.append( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
208 else if ( theCommandID == 116 ) {
209 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
211 else if ( theCommandID == 117 ) {
212 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
213 filter.append( QObject::tr( "All files (*)" ) );
215 else if ( theCommandID == 118 ) {
216 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
217 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
220 QString anInitialPath = "";
221 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
222 anInitialPath = QDir::currentPath();
224 QStringList filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
227 QObject::tr( "SMESH_IMPORT_MESH" ) );
228 if ( filenames.count() > 0 ) {
229 SUIT_OverrideCursor wc;
230 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
233 QStringList anEntryList;
234 bool isEmpty = false;
235 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
236 QString filename = *it;
237 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
239 switch ( theCommandID ) {
242 // DAT format (currently unsupported)
243 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
244 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
250 aMeshes->length( 1 );
251 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toLatin1().constData() );
252 if ( aMeshes[0]->_is_nil() )
253 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
254 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
260 SMESH::DriverMED_ReadStatus res;
261 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toLatin1().constData(), res );
262 if ( res != SMESH::DRS_OK ) {
263 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
264 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
271 aMeshes->length( 1 );
272 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toLatin1().constData() );
273 if ( aMeshes[0]->_is_nil() ) {
274 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
275 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
282 SMESH::DriverMED_ReadStatus res;
283 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toLatin1().constData(), res );
284 if ( res != SMESH::DRS_OK ) {
285 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
286 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
293 SMESH::DriverMED_ReadStatus res;
294 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toLatin1().constData(), res );
295 if ( res != SMESH::DRS_OK ) {
296 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
297 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
304 SMESH::ComputeError_var res;
305 aMeshes->length( 1 );
306 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toLatin1().constData(), res.out() );
307 if ( res->code != SMESH::DRS_OK ) {
308 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
309 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
310 if ( strlen( res->comment.in() ) > 0 ) {
311 errors.back() += ": ";
312 errors.back() += res->comment.in();
319 catch ( const SALOME::SALOME_Exception& S_ex ) {
320 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
321 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
324 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
325 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
327 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
328 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
329 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
330 if ( theCommandID == 112 ) // mesh names aren't taken from the file for UNV import
331 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
333 anEntryList.append( aMeshSO->GetID().c_str() );
335 #ifdef WITHGENERICOBJ
336 // obj has been published in study. Its refcount has been incremented.
337 // It is safe to decrement its refcount
338 // so that it will be destroyed when the entry in study will be removed
339 aMeshes[i]->UnRegister();
348 // update Object browser
349 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
351 // browse to the published meshes
352 if( LightApp_Application* anApp =
353 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
354 anApp->browseObjects( anEntryList );
356 // show Error message box if there were errors
357 if ( errors.count() > 0 ) {
358 SUIT_MessageBox::critical( SMESHGUI::desktop(),
359 QObject::tr( "SMESH_ERROR" ),
360 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
363 // show warning message box, if some imported mesh is empty
365 SUIT_MessageBox::warning( SMESHGUI::desktop(),
366 QObject::tr( "SMESH_WRN_WARNING" ),
367 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
372 //================================================================================
374 * \brief Export selected meshes or groups into a file
376 //================================================================================
378 void ExportMeshToFile( int theCommandID )
380 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
381 SALOME_ListIO selected;
383 aSel->selectedObjects( selected );
385 const bool isMED = ( theCommandID == 122 || theCommandID == 125 );
386 const bool isDAT = ( theCommandID == 121 || theCommandID == 124 );
387 const bool isUNV = ( theCommandID == 123 || theCommandID == 126 );
388 const bool isSTL = ( theCommandID == 140 || theCommandID == 141 );
389 const bool isCGNS= ( theCommandID == 142 || theCommandID == 143 );
390 const bool isSAUV= ( theCommandID == 144 || theCommandID == 145 );
391 const bool isGMF = ( theCommandID == 146 || theCommandID == 147 );
393 // actually, the following condition can't be met (added for insurance)
394 if( selected.Extent() == 0 ||
395 ( selected.Extent() > 1 && !isMED && !isSTL ))
398 // get mesh object from selection and check duplication of their names
399 bool hasDuplicatedMeshNames = false;
400 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
401 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
402 SALOME_ListIteratorOfListIO It( selected );
403 for( ; It.More(); It.Next() )
405 Handle(SALOME_InteractiveObject) anIObject = It.Value();
406 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
407 if ( aMeshItem->_is_nil() ) {
408 SUIT_MessageBox::warning( SMESHGUI::desktop(),
409 QObject::tr( "SMESH_WRN_WARNING" ),
410 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
414 QString aMeshName = anIObject->getName();
416 // check for name duplications
417 if ( !hasDuplicatedMeshNames )
418 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
419 if( aMeshName == (*aMeshIter).second ) {
420 hasDuplicatedMeshNames = true;
425 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
428 if( hasDuplicatedMeshNames && isMED ) {
429 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
430 QObject::tr("SMESH_WRN_WARNING"),
431 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
432 QObject::tr("SMESH_BUT_YES"),
433 QObject::tr("SMESH_BUT_NO"), 0, 1);
438 aMeshIter = aMeshList.begin();
439 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
440 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
441 QString aMeshName = (*aMeshIter).second;
443 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
445 // check for equal group names within each mesh
446 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
447 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
448 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
449 int aRet = SUIT_MessageBox::warning
450 (SMESHGUI::desktop(),
451 QObject::tr("SMESH_WRN_WARNING"),
452 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
453 QObject::tr("SMESH_BUT_YES"),
454 QObject::tr("SMESH_BUT_NO"), 0, 1);
461 // Warn the user about presence of not supported elements
463 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
467 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Quadrangle );
468 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
469 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
470 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
471 notSupportedElemTypes.push_back( SMESH::Entity_Tetra );
472 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Tetra );
473 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
474 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
475 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Hexa );
476 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
477 notSupportedElemTypes.push_back( SMESH::Entity_Penta );
478 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
479 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
480 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
481 notSupportedElemTypes.push_back( SMESH::Entity_0D );
482 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
487 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
488 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
489 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
490 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
491 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
492 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
493 notSupportedElemTypes.push_back( SMESH::Entity_0D );
494 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
499 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
500 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
501 notSupportedElemTypes.push_back( SMESH::Entity_0D );
502 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
507 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
512 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
513 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
514 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
515 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
516 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
517 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
522 notSupportedElemTypes.push_back( SMESH::Entity_0D );
523 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Quadrangle );
524 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
525 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
526 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
527 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Hexa );
528 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
529 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
530 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
531 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
532 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
534 if ( ! notSupportedElemTypes.empty() )
536 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
537 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
538 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
539 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
541 if ( !presentNotSupported.empty() )
544 const char* typeMsg[SMESH::Entity_Last] = { "SMESH_NODES",
545 "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES","SMESH_TRIANGLES",
546 "SMESH_QUADRATIC_TRIANGLES","SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES",
547 "SMESH_BIQUADRATIC_QUADRANGLES","SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
548 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
549 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
550 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
551 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
553 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
554 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
555 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
556 if ( iType != presentNotSupported.size() - 1 )
557 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
559 int aRet = SUIT_MessageBox::warning
560 (SMESHGUI::desktop(),
561 QObject::tr("SMESH_WRN_WARNING"),
562 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
563 QObject::tr("SMESH_BUT_YES"),
564 QObject::tr("SMESH_BUT_NO"), 0, 1);
569 // Get parameters of export operation
572 SMESH::MED_VERSION aFormat;
573 // Init the parameters with the default values
574 bool aIsASCII_STL = true;
575 bool toCreateGroups = false;
576 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
578 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
579 bool toOverwrite = true;
581 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
582 QString anInitialPath = "";
583 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
584 anInitialPath = QDir::currentPath();
586 // Get a file name to write in and additional otions
587 if ( isUNV || isDAT || isGMF ) // Export w/o options
590 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
592 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
594 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
595 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
596 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
597 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
598 anInitialPath + QString("/") + aMeshName,
599 aFilter, aTitle, false);
601 else if ( isCGNS )// Export to CGNS
603 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
604 fd->setWindowTitle( aTitle );
605 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
606 if ( !anInitialPath.isEmpty() )
607 fd->setDirectory( anInitialPath );
608 fd->selectFile(aMeshName);
609 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
610 fd->setValidator( fv );
613 aFilename = fd->selectedFile();
614 toOverwrite = fv->isOverwrite();
618 else if ( isSTL ) // Export to STL
620 QMap<QString, int> aFilterMap;
621 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
622 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
625 QMap<QString, int>::const_iterator it = aFilterMap.begin();
626 for ( ; it != aFilterMap.end(); ++it )
627 filters.push_back( it.key() );
629 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
630 fd->setWindowTitle( aTitle );
631 fd->setNameFilters( filters );
632 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
633 if ( !anInitialPath.isEmpty() )
634 fd->setDirectory( anInitialPath );
635 fd->selectFile(aMeshName);
639 aFilename = fd->selectedFile();
640 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
645 else if ( isMED || isSAUV ) // Export to MED or SAUV
647 QMap<QString, SMESH::MED_VERSION> aFilterMap;
648 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
650 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
651 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
652 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
655 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
656 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
657 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
661 QString aDefaultFilter;
662 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
663 for ( ; it != aFilterMap.end(); ++it ) {
664 filters.push_back( it.key() );
665 if (it.value() == SMESH::MED_V2_2)
666 aDefaultFilter = it.key();
669 SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
670 ( SMESHGUI::desktop(), false, QObject::tr("SMESH_AUTO_GROUPS"), true, true );
671 fd->setWindowTitle( aTitle );
672 fd->setNameFilters( filters );
673 fd->selectNameFilter(aDefaultFilter);
674 fd->SetChecked(toCreateGroups);
675 if ( !anInitialPath.isEmpty() )
676 fd->setDirectory( anInitialPath );
677 fd->selectFile(aMeshName);
679 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
680 fd->setValidator( fv );
685 aFilename = fd->selectedFile();
687 aFilename = QString::null;
690 aFormat = aFilterMap[fd->selectedNameFilter()];
691 toOverwrite = fv->isOverwrite();
693 if ( !aFilename.isEmpty() ) {
694 // med-2.1 does not support poly elements
695 if ( aFormat==SMESH::MED_V2_1 )
696 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
697 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
698 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
699 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
700 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
702 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
703 QObject::tr("SMESH_WRN_WARNING"),
704 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
705 QObject::tr("SMESH_BUT_YES"),
706 QObject::tr("SMESH_BUT_NO"), 0, 1);
714 // can't append to an existing using other format
715 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
716 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toLatin1().constData(), aVersion );
717 if( !isVersionOk || aVersion != aFormat ) {
718 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
719 QObject::tr("SMESH_WRN_WARNING"),
720 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
721 QObject::tr("SMESH_BUT_YES"),
722 QObject::tr("SMESH_BUT_NO"), 0, 1);
729 QStringList aMeshNamesCollisionList;
730 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toLatin1().constData() );
731 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
732 QString anExistingMeshName( aMeshNames[ i ] );
733 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
734 QString anExportMeshName = (*aMeshIter).second;
735 if( anExportMeshName == anExistingMeshName ) {
736 aMeshNamesCollisionList.append( anExportMeshName );
741 if( !aMeshNamesCollisionList.isEmpty() ) {
742 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
743 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
744 QObject::tr("SMESH_WRN_WARNING"),
745 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
746 QObject::tr("SMESH_BUT_YES"),
747 QObject::tr("SMESH_BUT_NO"),
748 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
757 toCreateGroups = fd->IsChecked();
767 if ( !aFilename.isEmpty() ) {
768 // Check whether the file already exists and delete it if yes
769 QFile aFile( aFilename );
770 if ( aFile.exists() && toOverwrite )
772 SUIT_OverrideCursor wc;
775 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
776 // bool Renumber = false;
777 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
779 // Renumber= resMgr->booleanValue("renumbering");
781 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
782 // aMeshEditor->RenumberNodes();
783 // aMeshEditor->RenumberElements();
784 // if ( SMESHGUI::automaticUpdate() )
785 // SMESH::UpdateView();
789 aMeshIter = aMeshList.begin();
790 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
792 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
793 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
794 if ( aMeshOrGroup->_is_equivalent( aMeshItem ))
795 aMeshItem->ExportToMEDX( aFilename.toLatin1().data(), toCreateGroups,
796 aFormat, toOverwrite && aMeshIndex == 0 );
798 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups,
799 aFormat, toOverwrite && aMeshIndex == 0 );
804 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
806 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
807 if( !aMeshItem->_is_nil() )
808 aMeshItem->ExportSAUV( aFilename.toLatin1().data(), toCreateGroups );
813 if ( aMeshOrGroup->_is_equivalent( aMesh ))
814 aMesh->ExportDAT( aFilename.toLatin1().data() );
816 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toLatin1().data() );
820 if ( aMeshOrGroup->_is_equivalent( aMesh ))
821 aMesh->ExportUNV( aFilename.toLatin1().data() );
823 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toLatin1().data() );
827 if ( aMeshOrGroup->_is_equivalent( aMesh ))
828 aMesh->ExportSTL( aFilename.toLatin1().data(), aIsASCII_STL );
830 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toLatin1().data(), aIsASCII_STL );
834 aMeshIter = aMeshList.begin();
835 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
837 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
838 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
839 aMeshItem->ExportCGNS( aMeshOrGroup,
840 aFilename.toLatin1().data(),
841 toOverwrite && aMeshIndex == 0 );
846 aMesh->ExportGMF( aMeshOrGroup, aFilename.toLatin1().data() );
849 catch (const SALOME::SALOME_Exception& S_ex){
851 SUIT_MessageBox::warning(SMESHGUI::desktop(),
852 QObject::tr("SMESH_WRN_WARNING"),
853 QObject::tr("SMESH_EXPORT_FAILED"));
859 inline void InverseEntityMode(unsigned int& theOutputMode,
860 unsigned int theMode)
862 bool anIsNotPresent = ~theOutputMode & theMode;
864 theOutputMode |= theMode;
866 theOutputMode &= ~theMode;
869 void SetDisplayEntity(int theCommandID){
870 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
871 SALOME_ListIO selected;
873 aSel->selectedObjects( selected );
875 if(selected.Extent() >= 1){
876 SALOME_ListIteratorOfListIO It( selected );
877 for( ; It.More(); It.Next()){
878 Handle(SALOME_InteractiveObject) IObject = It.Value();
879 if(IObject->hasEntry()){
880 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
881 unsigned int aMode = anActor->GetEntityMode();
882 switch(theCommandID){
884 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
887 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
890 InverseEntityMode(aMode,SMESH_Actor::eEdges);
893 InverseEntityMode(aMode,SMESH_Actor::eFaces);
896 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
899 aMode = SMESH_Actor::eAllEntity;
903 anActor->SetEntityMode(aMode);
911 SALOME_ListIO selected;
912 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
916 LightApp_SelectionMgr* aSel = app->selectionMgr();
917 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
918 if( !aSel || !appStudy )
921 aSel->selectedObjects( selected );
922 if( selected.IsEmpty() )
925 Handle(SALOME_InteractiveObject) anIObject = selected.First();
927 _PTR(Study) aStudy = appStudy->studyDS();
928 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
929 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
930 if( aMainObject->_is_nil() )
933 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
935 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
936 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
938 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
939 SALOMEDS::Color aColor = aGroupObject->GetColor();
940 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
944 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
945 switch ( aGroupObject->GetType ()) {
947 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
949 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
951 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
953 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
955 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
956 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
959 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
960 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
966 SMESH::RepaintCurrentView();
969 QString functorToString( SMESH::Controls::FunctorPtr f )
971 QString type = QObject::tr( "UNKNOWN_CONTROL" );
972 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
973 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
974 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
975 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
976 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
977 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
978 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
979 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
980 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
981 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
982 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
983 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
984 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
985 type = QObject::tr( "WARP_ELEMENTS" );
986 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
987 type = QObject::tr( "TAPER_ELEMENTS" );
988 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
989 type = QObject::tr( "SKEW_ELEMENTS" );
990 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
991 type = QObject::tr( "AREA_ELEMENTS" );
992 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
993 type = QObject::tr( "LENGTH_EDGES" );
994 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
995 type = QObject::tr( "LENGTH2D_EDGES" );
996 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
997 type = QObject::tr( "MULTI_BORDERS" );
998 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
999 type = QObject::tr( "MULTI2D_BORDERS" );
1000 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1001 type = QObject::tr( "FREE_NODES" );
1002 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1003 type = QObject::tr( "FREE_EDGES" );
1004 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1005 type = QObject::tr( "FREE_BORDERS" );
1006 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1007 type = QObject::tr( "FREE_FACES" );
1008 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1009 type = QObject::tr( "BARE_BORDER_VOLUME" );
1010 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1011 type = QObject::tr( "BARE_BORDER_FACE" );
1012 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1013 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1014 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1015 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1016 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1017 type = QObject::tr( "EQUAL_NODE" );
1018 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1019 type = QObject::tr( "EQUAL_EDGE" );
1020 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1021 type = QObject::tr( "EQUAL_FACE" );
1022 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1023 type = QObject::tr( "EQUAL_VOLUME" );
1027 void SaveDistribution()
1029 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1030 SALOME_ListIO selected;
1032 aSel->selectedObjects( selected );
1034 if ( selected.Extent() == 1 ) {
1035 Handle(SALOME_InteractiveObject) anIO = selected.First();
1036 if ( anIO->hasEntry() ) {
1037 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1038 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1039 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1040 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1041 if ( aScalarBarActor && aFunctor ) {
1042 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1044 std::vector<int> elements;
1045 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1046 if ( mesh->_is_nil() ) {
1047 SMESH::SMESH_IDSource_var idSource =
1048 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1049 if ( !idSource->_is_nil() )
1051 SMESH::long_array_var ids = idSource->GetIDs();
1052 elements.resize( ids->length() );
1053 for ( unsigned i = 0; i < elements.size(); ++i )
1054 elements[i] = ids[i];
1057 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1058 vtkLookupTable* lookupTable =
1059 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1060 double * minmax = lookupTable->GetRange();
1061 std::vector<int> nbEvents;
1062 std::vector<double> funValues;
1063 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax );
1064 QString anInitialPath = "";
1065 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1066 anInitialPath = QDir::currentPath();
1067 QString aMeshName = anIO->getName();
1069 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1070 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1071 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1072 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1073 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1076 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1078 if ( !aFilename.isEmpty() ) {
1079 QFile f( aFilename );
1080 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1081 QTextStream out( &f );
1082 out << "# Mesh: " << aMeshName << endl;
1083 out << "# Control: " << functorToString( aFunctor ) << endl;
1085 out.setFieldWidth( 10 );
1086 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1087 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1098 void ShowDistribution() {
1099 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1100 SALOME_ListIO selected;
1102 aSel->selectedObjects( selected );
1104 if ( selected.Extent() == 1 ) {
1105 Handle(SALOME_InteractiveObject) anIO = selected.First();
1106 if ( anIO->hasEntry() ) {
1107 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1108 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1109 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1110 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1116 #ifndef DISABLE_PLOT2DVIEWER
1117 void PlotDistribution() {
1118 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1122 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1123 SALOME_ListIO selected;
1125 aSel->selectedObjects( selected );
1127 if ( selected.Extent() == 1 ) {
1128 Handle(SALOME_InteractiveObject) anIO = selected.First();
1129 if ( anIO->hasEntry() ) {
1130 //Find Actor by entry before getting Plot2d viewer,
1131 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1132 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1134 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1139 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1143 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1147 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1148 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1149 QString functorName = functorToString( anActor->GetFunctor());
1150 QString aHistogramName("%1 : %2");
1151 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1152 aHistogram->setName(aHistogramName);
1153 aHistogram->setHorTitle(functorName);
1154 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1155 aPlot->displayObject(aHistogram, true);
1160 #endif //DISABLE_PLOT2DVIEWER
1162 void DisableAutoColor(){
1163 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1164 SALOME_ListIO selected;
1166 aSel->selectedObjects( selected );
1168 if(selected.Extent()){
1169 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1170 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1171 if ( !aMesh->_is_nil() ) {
1172 aMesh->SetAutoColor( false );
1177 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1179 SALOME_ListIO selected;
1180 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1184 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1185 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1186 if( !aSel || !appStudy )
1189 if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection
1190 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1191 aModule->EmitSignalDeactivateDialog();
1192 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1193 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1198 _PTR(Study) aStudy = appStudy->studyDS();
1200 aSel->selectedObjects( selected );
1202 if(selected.Extent() >= 1){
1203 switch(theCommandID){
1205 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1206 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1210 vtkFloatingPointType color[3];
1211 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1212 QColor orientationColor, outlineColor, volumeColor;
1213 int deltaF = 0, deltaV = 0;
1217 int outlineWidth = 1;
1218 vtkFloatingPointType shrinkCoef = 0.0;
1219 vtkFloatingPointType orientationScale = 0.0;
1220 bool orientation3d = false;
1221 VTK::MarkerType markerType = VTK::MT_NONE;
1222 VTK::MarkerScale markerScale = VTK::MS_NONE;
1224 bool hasNodes = false;
1225 int presentEntities = 0;
1226 bool firstTime = true;
1228 SALOME_ListIteratorOfListIO It( selected );
1229 for ( ; It.More(); It.Next() ) {
1230 Handle(SALOME_InteractiveObject) IObject = It.Value();
1231 if ( !IObject->hasEntry() ) continue;
1232 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1233 if ( !anActor || !anActor->GetObject() ) continue;
1236 // nodes: color, marker
1237 anActor->GetNodeColor( color[0], color[1], color[2] );
1238 nodeColor.setRgbF( color[0], color[1], color[2] );
1239 markerType = anActor->GetMarkerType();
1240 markerScale = anActor->GetMarkerScale();
1241 markerId = anActor->GetMarkerTexture();
1242 // edges: color, width
1243 anActor->GetEdgeColor( color[0], color[1], color[2] );
1244 edgeColor.setRgbF( color[0], color[1], color[2] );
1245 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1246 // faces: front color, back color (delta)
1247 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1248 faceColor.setRgbF( color[0], color[1], color[2] );
1249 // faces: front color, back color (delta)
1250 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1251 volumeColor.setRgbF( color[0], color[1], color[2] );
1252 // 0d elements: color, size
1253 anActor->Get0DColor( color[0], color[1], color[2] );
1254 elem0dColor.setRgbF( color[0], color[1], color[2] );
1255 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1256 // balls: color, size
1257 anActor->GetBallColor( color[0], color[1], color[2] );
1258 ballColor.setRgbF( color[0], color[1], color[2] );
1259 ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1261 anActor->GetOutlineColor( color[0], color[1], color[2] );
1262 outlineColor.setRgbF( color[0], color[1], color[2] );
1263 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1264 // orientation vectors: color, scale, 3d flag
1265 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1266 orientationColor.setRgbF( color[0], color[1], color[2] );
1267 orientationScale = anActor->GetFacesOrientationScale();
1268 orientation3d = anActor->GetFacesOrientation3DVectors();
1270 shrinkCoef = anActor->GetShrinkFactor();
1273 firstTime = false; // we only take properties from first object (for performance reasons)
1276 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1277 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1278 presentEntities = presentEntities | SMESH_Actor::eEdges;
1279 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1280 presentEntities = presentEntities | SMESH_Actor::eFaces;
1281 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1282 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1283 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1284 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1285 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1286 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1288 // as we know that all types of elements are present, we can exit the loop
1289 if ( presentEntities == SMESH_Actor::eAllEntity )
1293 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1294 // nodes: color, marker
1295 dlg.setNodeColor( nodeColor );
1296 if( markerType != VTK::MT_USER )
1297 dlg.setNodeMarker( markerType, markerScale );
1299 dlg.setNodeCustomMarker( markerId );
1300 // edges: color, line width
1301 dlg.setEdgeColor( edgeColor );
1302 dlg.setEdgeWidth( edgeWidth );
1303 // faces: front color, back color
1304 dlg.setFaceColor( faceColor, deltaF );
1305 // volumes: normal color, reversed color
1306 dlg.setVolumeColor( volumeColor, deltaV );
1307 // outlines: color, line width
1308 dlg.setOutlineColor( outlineColor );
1309 dlg.setOutlineWidth( outlineWidth );
1310 // 0d elements: color, size
1311 dlg.setElem0dColor( elem0dColor );
1312 dlg.setElem0dSize( elem0dSize );
1313 // balls: color, size
1314 dlg.setBallColor( ballColor );
1315 dlg.setBallSize( ballSize );
1316 // orientation: color, scale, 3d flag
1317 dlg.setOrientationColor( orientationColor );
1318 dlg.setOrientationSize( int( orientationScale * 100. ) );
1319 dlg.setOrientation3d( orientation3d );
1320 // shrink: scale factor
1321 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1322 // hide unused controls
1323 dlg.showControls( presentEntities, hasNodes );
1326 nodeColor = dlg.nodeColor();
1327 markerType = dlg.nodeMarkerType();
1328 markerScale = dlg.nodeMarkerScale();
1329 markerId = dlg.nodeMarkerId();
1330 edgeColor = dlg.edgeColor();
1331 edgeWidth = dlg.edgeWidth();
1332 faceColor = dlg.faceColor();
1333 deltaF = dlg.faceColorDelta();
1334 volumeColor = dlg.volumeColor();
1335 deltaV = dlg.volumeColorDelta();
1336 outlineColor = dlg.outlineColor();
1337 outlineWidth = dlg.outlineWidth();
1338 elem0dColor = dlg.elem0dColor();
1339 elem0dSize = dlg.elem0dSize();
1340 ballColor = dlg.ballColor();
1341 ballSize = dlg.ballSize();
1342 orientationColor = dlg.orientationColor();
1343 orientationScale = dlg.orientationSize() / 100.;
1344 orientation3d = dlg.orientation3d();
1345 shrinkCoef = dlg.shrinkCoef() / 100.;
1347 // store point markers map that might be changed by the user
1348 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1350 // set properties from dialog box to the presentations
1351 SALOME_ListIteratorOfListIO It( selected );
1352 for ( ; It.More(); It.Next() ) {
1353 Handle(SALOME_InteractiveObject) IObject = It.Value();
1354 if ( !IObject->hasEntry() ) continue;
1355 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1356 if ( !anActor ) continue;
1358 // nodes: color, marker
1359 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1360 if ( markerType != VTK::MT_USER ) {
1361 anActor->SetMarkerStd( markerType, markerScale );
1364 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1365 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1366 if ( iter != markerMap.end() )
1367 anActor->SetMarkerTexture( markerId, iter->second.second );
1369 // volumes: normal color, reversed color (delta)
1370 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1371 // faces: front color, back color (delta)
1372 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1373 // edges: color, width
1374 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1375 anActor->SetLineWidth( edgeWidth );
1377 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1378 anActor->SetOutlineWidth( outlineWidth );
1379 // 0D elements: color, size
1380 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1381 anActor->Set0DSize( elem0dSize );
1382 // balls: color, size
1383 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1384 anActor->SetBallSize( ballSize );
1385 // orientation: color, scale, 3d flag
1386 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1387 anActor->SetFacesOrientationScale( orientationScale );
1388 anActor->SetFacesOrientation3DVectors( orientation3d );
1390 anActor->SetShrinkFactor( shrinkCoef );
1392 // for groups, set also proper color
1393 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1394 if ( !aGroupObject->_is_nil() ) {
1395 SMESH::ElementType anElementType = aGroupObject->GetType();
1397 switch( anElementType ) {
1399 aColor = nodeColor; break;
1401 aColor = edgeColor; break;
1403 aColor = faceColor; break;
1405 aColor = volumeColor; break;
1407 aColor = elem0dColor; break;
1409 aColor = ballColor; break;
1413 if ( aColor.isValid() ) {
1414 SALOMEDS::Color aGroupColor;
1415 aGroupColor.R = aColor.redF();
1416 aGroupColor.G = aColor.greenF();
1417 aGroupColor.B = aColor.blueF();
1418 aGroupObject->SetColor( aGroupColor );
1420 } // if ( !aGroupObject->_is_nil() )
1421 } // for ( ; It.More(); It.Next() )
1422 SMESH::RepaintCurrentView();
1423 } // if ( dlg.exec() )
1426 } // switch(theCommandID)
1427 SALOME_ListIteratorOfListIO It( selected );
1428 for( ; It.More(); It.Next()){
1429 Handle(SALOME_InteractiveObject) IObject = It.Value();
1430 if(IObject->hasEntry()){
1431 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1432 switch(theCommandID){
1434 anActor->SetRepresentation(SMESH_Actor::eEdge);
1437 anActor->SetRepresentation(SMESH_Actor::eSurface);
1440 if(anActor->IsShrunk())
1441 anActor->UnShrink();
1443 anActor->SetShrink();
1446 anActor->SetRepresentation(SMESH_Actor::ePoint);
1449 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1450 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1453 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1454 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1460 SMESH::RepaintCurrentView();
1464 void Control( int theCommandID )
1466 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1467 SALOME_ListIO selected;
1469 aSel->selectedObjects( selected );
1471 if( !selected.IsEmpty() ){
1472 Handle(SALOME_InteractiveObject) anIO = selected.First();
1474 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1475 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1476 switch ( theCommandID ){
1478 aControl = SMESH_Actor::eLength;
1481 aControl = SMESH_Actor::eLength2D;
1484 aControl = SMESH_Actor::eFreeEdges;
1487 aControl = SMESH_Actor::eFreeBorders;
1490 aControl = SMESH_Actor::eMultiConnection;
1493 aControl = SMESH_Actor::eFreeNodes;
1496 aControl = SMESH_Actor::eMultiConnection2D;
1499 aControl = SMESH_Actor::eArea;
1502 aControl = SMESH_Actor::eTaper;
1505 aControl = SMESH_Actor::eAspectRatio;
1508 aControl = SMESH_Actor::eAspectRatio3D;
1511 aControl = SMESH_Actor::eMinimumAngle;
1514 aControl = SMESH_Actor::eWarping;
1517 aControl = SMESH_Actor::eSkew;
1520 aControl = SMESH_Actor::eVolume3D;
1523 aControl = SMESH_Actor::eFreeFaces;
1526 aControl = SMESH_Actor::eMaxElementLength2D;
1529 aControl = SMESH_Actor::eMaxElementLength3D;
1532 aControl = SMESH_Actor::eBareBorderVolume;
1535 aControl = SMESH_Actor::eBareBorderFace;
1538 aControl = SMESH_Actor::eOverConstrainedVolume;
1541 aControl = SMESH_Actor::eOverConstrainedFace;
1544 aControl = SMESH_Actor::eCoincidentNodes;
1547 aControl = SMESH_Actor::eCoincidentElems1D;
1550 aControl = SMESH_Actor:: eCoincidentElems2D;
1553 aControl = SMESH_Actor::eCoincidentElems3D;
1557 anActor->SetControlMode(aControl);
1558 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1559 SMESH::RepaintCurrentView();
1560 #ifndef DISABLE_PLOT2DVIEWER
1561 if(anActor->GetPlot2Histogram()) {
1562 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1563 QString functorName = functorToString( anActor->GetFunctor());
1564 QString aHistogramName("%1 : %2");
1565 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1566 aHistogram->setName(aHistogramName);
1567 aHistogram->setHorTitle(functorName);
1568 SMESH::ProcessIn2DViewers(anActor);
1577 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1578 MeshObjectType theType,
1579 const QString theInTypeName,
1580 QString & theOutTypeName)
1582 SMESH_TypeFilter aTypeFilter( theType );
1584 if( !theIO.IsNull() )
1586 entry = theIO->getEntry();
1587 LightApp_DataOwner owner( entry );
1588 if ( aTypeFilter.isOk( &owner )) {
1589 theOutTypeName = theInTypeName;
1597 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1599 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1600 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1602 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1603 CORBA::String_var anID = aSComp->GetID().c_str();
1604 if (!strcmp(anID.in(),theIO->getEntry()))
1610 CheckOIType ( theIO, HYPOTHESIS, "Hypothesis", aTypeName ) ||
1611 CheckOIType ( theIO, ALGORITHM, "Algorithm", aTypeName ) ||
1612 CheckOIType ( theIO, MESH, "Mesh", aTypeName ) ||
1613 CheckOIType ( theIO, SUBMESH, "SubMesh", aTypeName ) ||
1614 CheckOIType ( theIO, GROUP, "Group", aTypeName )
1622 QString CheckHomogeneousSelection()
1624 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1625 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1626 SALOME_ListIO selected;
1628 aSel->selectedObjects( selected );
1630 QString RefType = CheckTypeObject(selected.First());
1631 SALOME_ListIteratorOfListIO It(selected);
1632 for ( ; It.More(); It.Next())
1634 Handle(SALOME_InteractiveObject) IObject = It.Value();
1635 QString Type = CheckTypeObject(IObject);
1636 if (Type.compare(RefType) != 0)
1637 return "Heterogeneous Selection";
1644 void SMESHGUI::OnEditDelete()
1646 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1647 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1648 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1650 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1651 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1652 _PTR(GenericAttribute) anAttr;
1653 _PTR(AttributeIOR) anIOR;
1655 int objectCount = 0;
1657 QString aParentComponent = QString::null;
1658 Handle(SALOME_InteractiveObject) anIO;
1659 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1661 anIO = anIt.Value();
1662 QString cur = anIO->getComponentDataType();
1663 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1665 // check if object is reference
1666 _PTR(SObject) aRefSObj;
1667 aNameList.append("\n - ");
1668 if ( aSO->ReferencedObject( aRefSObj ) ) {
1669 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1670 aNameList.append( aRefName );
1671 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1674 aNameList.append(anIO->getName());
1678 if( aParentComponent.isNull() )
1679 aParentComponent = cur;
1680 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1681 aParentComponent = "";
1684 if ( objectCount == 0 )
1685 return; // No Valid Objects Selected
1687 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1688 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1689 QObject::tr("ERR_ERROR"),
1690 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1693 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1694 if (SUIT_MessageBox::warning
1695 (SMESHGUI::desktop(),
1696 QObject::tr("SMESH_WRN_WARNING"),
1697 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1698 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1699 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1702 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1704 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1705 // then treat them all starting from the deepest objects (at list back)
1706 std::list< _PTR(SObject) > listSO;
1707 SALOME_ListIteratorOfListIO It(selected);
1708 for( ; It.More(); It.Next()) // loop on selected IO's
1710 Handle(SALOME_InteractiveObject) IObject = It.Value();
1711 if(IObject->hasEntry()) {
1712 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1714 // disable removal of "SMESH" component object
1715 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1717 if ( engineIOR() == anIOR->Value().c_str() )
1720 //Check the referenced object
1721 _PTR(SObject) aRefSObject;
1722 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1723 aSO = aRefSObject; // Delete main Object instead of reference
1725 listSO.push_back( aSO );
1726 std::list< _PTR(SObject) >::iterator itSO = listSO.begin();
1727 for ( ; itSO != listSO.end(); ++itSO ) {
1728 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1729 for (it->InitEx(false); it->More(); it->Next())
1730 listSO.push_back( it->Value() );
1734 // Check if none of objects to delete is referred from outside
1735 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1736 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1738 _PTR(SObject) SO = *ritSO;
1739 if ( !SO ) continue;
1740 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1741 for (size_t i = 0; i < aReferences.size(); i++) {
1742 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1743 std::string type = aComponent->ComponentDataType();
1744 if ( type != "SMESH" )
1746 SUIT_MessageBox::warning( anApp->desktop(),
1747 QObject::tr("WRN_WARNING"),
1748 QObject::tr("DEP_OBJECT") );
1749 return; // outside SMESH, there is an object depending on a SMESH object
1754 // Treat SO's in the list starting from the back
1755 aStudyBuilder->NewCommand(); // There is a transaction
1756 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1758 _PTR(SObject) SO = *ritSO;
1759 if ( !SO ) continue;
1760 std::string anEntry = SO->GetID();
1762 /** Erase graphical object **/
1763 if(SO->FindAttribute(anAttr, "AttributeIOR")){
1764 ViewManagerList aViewMenegers = anApp->viewManagers();
1765 ViewManagerList::const_iterator it = aViewMenegers.begin();
1766 for( ; it != aViewMenegers.end(); it++) {
1767 SUIT_ViewManager* vm = *it;
1768 int nbSf = vm ? vm->getViewsCount() : 0;
1770 QVector<SUIT_ViewWindow*> aViews = vm->getViews();
1771 for(int i = 0; i < nbSf; i++){
1772 SUIT_ViewWindow *sf = aViews[i];
1773 if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
1774 SMESH::RemoveActor(sf,anActor);
1780 /** Remove an object from data structures **/
1781 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1782 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1783 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1784 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1785 aMesh->RemoveGroup( aGroup );
1787 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1788 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1789 aMesh->RemoveSubMesh( aSubMesh );
1791 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1793 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1796 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1797 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1798 QString objType = CheckTypeObject(IObject);
1799 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1800 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1801 aStudyBuilder->RemoveObjectWithChildren( SO );
1803 else {// default action: remove SObject from the study
1804 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1805 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1807 aStudyBuilder->RemoveObjectWithChildren( SO );
1811 } /* listSO back loop */
1813 aStudyBuilder->CommitCommand();
1815 /* Clear any previous selection */
1817 aSel->setSelectedObjects( l1 );
1819 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1824 SMESHGUI_EXPORT CAM_Module* createModule()
1826 return new SMESHGUI();
1829 SMESHGUI_EXPORT char* getModuleVersion() {
1830 return (char*)SMESH_VERSION_STR;
1834 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1836 //=============================================================================
1840 //=============================================================================
1841 SMESHGUI::SMESHGUI() :
1842 SalomeApp_Module( "SMESH" ),
1843 LightApp_Module( "SMESH" )
1845 if ( CORBA::is_nil( myComponentSMESH ) )
1847 CORBA::Boolean anIsEmbeddedMode;
1848 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1849 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1851 // 0019923: EDF 765 SMESH : default values of hypothesis
1852 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1853 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1854 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1855 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1856 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1858 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1859 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1860 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1862 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1863 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1867 myActiveDialogBox = 0;
1868 myFilterLibraryDlg = 0;
1872 myEventCallbackCommand = vtkCallbackCommand::New();
1873 myEventCallbackCommand->Delete();
1874 myEventCallbackCommand->SetClientData( this );
1875 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1878 SMESH::GetFilterManager();
1879 SMESH::GetPattern();
1880 SMESH::GetMeasurements();
1882 /* load resources for all available meshers */
1883 SMESH::InitAvailableHypotheses();
1886 //=============================================================================
1890 //=============================================================================
1891 SMESHGUI::~SMESHGUI()
1893 #ifdef WITHGENERICOBJ
1894 SMESH::GetFilterManager()->UnRegister();
1895 SMESH::GetMeasurements()->UnRegister();
1897 SMESH::GetFilterManager() = SMESH::FilterManager::_nil();
1898 SMESH::GetMeasurements() = SMESH::Measurements::_nil();
1901 //=============================================================================
1905 //=============================================================================
1906 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1908 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1910 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1915 //=============================================================================
1919 //=============================================================================
1920 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1922 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1926 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
1927 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1928 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
1929 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
1930 return autoUpdate && !exceeded;
1933 //=============================================================================
1937 //=============================================================================
1938 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
1940 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
1943 //=============================================================================
1947 //=============================================================================
1948 SMESHGUI* SMESHGUI::GetSMESHGUI()
1950 SMESHGUI* smeshMod = 0;
1951 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
1954 CAM_Module* module = app->module( "Mesh" );
1955 smeshMod = dynamic_cast<SMESHGUI*>( module );
1958 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
1960 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
1963 _PTR(Study) aStudy = study->studyDS();
1965 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
1974 Standard_EXPORT SMESHGUI* GetComponentGUI()
1976 return SMESHGUI::GetSMESHGUI();
1980 //=============================================================================
1984 //=============================================================================
1985 void SMESHGUI::SetState(int aState)
1990 //=============================================================================
1994 //=============================================================================
1995 void SMESHGUI::ResetState()
2000 //=============================================================================
2004 //=============================================================================
2005 void SMESHGUI::EmitSignalDeactivateDialog()
2007 emit SignalDeactivateActiveDialog();
2010 //=============================================================================
2014 //=============================================================================
2015 void SMESHGUI::EmitSignalStudyFrameChanged()
2017 emit SignalStudyFrameChanged();
2020 //=============================================================================
2024 //=============================================================================
2025 void SMESHGUI::EmitSignalCloseAllDialogs()
2027 emit SignalCloseAllDialogs();
2030 //=============================================================================
2034 //=============================================================================
2035 void SMESHGUI::EmitSignalVisibilityChanged()
2037 emit SignalVisibilityChanged();
2040 //=============================================================================
2044 //=============================================================================
2045 QDialog *SMESHGUI::GetActiveDialogBox()
2047 return myActiveDialogBox;
2050 //=============================================================================
2054 //=============================================================================
2055 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2057 myActiveDialogBox = (QDialog *) aDlg;
2061 //=============================================================================
2065 //=============================================================================
2066 SUIT_Desktop* SMESHGUI::desktop()
2068 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2070 return app->desktop();
2075 //=============================================================================
2079 //=============================================================================
2080 SalomeApp_Study* SMESHGUI::activeStudy()
2082 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2084 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2089 //=============================================================================
2093 //=============================================================================
2094 void SMESHGUI::Modified( bool theIsUpdateActions )
2096 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2097 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2098 appStudy->Modified();
2099 if( theIsUpdateActions )
2100 app->updateActions();
2105 //=============================================================================
2109 //=============================================================================
2110 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2112 /* Here the position is on the bottom right corner - 10 */
2113 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2115 SUIT_Desktop *PP = desktop();
2116 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2117 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2121 //=============================================================================
2125 //=============================================================================
2126 static int isStudyLocked(_PTR(Study) theStudy){
2127 return theStudy->GetProperties()->IsLocked();
2130 static bool checkLock(_PTR(Study) theStudy) {
2131 if (isStudyLocked(theStudy)) {
2132 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2133 QObject::tr("WRN_WARNING"),
2134 QObject::tr("WRN_STUDY_LOCKED") );
2140 //=======================================================================
2141 //function : CheckActiveStudyLocked
2143 //=======================================================================
2145 bool SMESHGUI::isActiveStudyLocked()
2147 _PTR(Study) aStudy = activeStudy()->studyDS();
2148 return checkLock( aStudy );
2151 //=============================================================================
2155 //=============================================================================
2156 bool SMESHGUI::OnGUIEvent( int theCommandID )
2158 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2162 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2163 SUIT_ResourceMgr* mgr = resourceMgr();
2167 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2168 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2171 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2172 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2174 //QAction* act = action( theCommandID );
2176 switch (theCommandID) {
2178 if(checkLock(aStudy)) break;
2190 if(checkLock(aStudy)) break;
2191 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2195 case 150: //MED FILE INFORMATION
2197 SALOME_ListIO selected;
2198 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2200 aSel->selectedObjects( selected );
2201 if( selected.Extent() )
2203 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2204 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2205 if ( !aMesh->_is_nil() )
2207 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2214 case 122: // EXPORT MED
2229 ::ExportMeshToFile(theCommandID);
2233 case 200: // SCALAR BAR
2235 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2236 SALOME_ListIO selected;
2238 aSel->selectedObjects( selected );
2240 if( selected.Extent() ) {
2241 Handle(SALOME_InteractiveObject) anIO = selected.First();
2242 if( anIO->hasEntry() ) {
2243 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2244 anActor->SetControlMode( SMESH_Actor::eNone );
2245 #ifndef DISABLE_PLOT2DVIEWER
2246 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2255 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2260 // dump control distribution data to the text file
2261 ::SaveDistribution();
2267 // show/ distribution
2268 ::ShowDistribution();
2272 #ifndef DISABLE_PLOT2DVIEWER
2275 // plot distribution
2276 ::PlotDistribution();
2287 ::DisableAutoColor();
2290 case 1134: // Clipping
2291 case 1133: // Tranparency
2292 case 1132: // Display preferences (colors, shrink size, line width, ...)
2299 ::SetDisplayMode(theCommandID, myMarkerMap);
2302 //2D quadratic representation
2305 ::SetDisplayMode(theCommandID, myMarkerMap);
2309 case 216: // 0D elements
2312 case 219: // Volumes
2313 case 220: // All Entity
2315 ::SetDisplayEntity(theCommandID);
2318 case 221: // Orientation of faces
2320 LightApp_SelectionMgr* mgr = selectionMgr();
2321 SALOME_ListIO selected; mgr->selectedObjects( selected );
2323 SALOME_ListIteratorOfListIO it(selected);
2324 for( ; it.More(); it.Next()) {
2325 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2326 if(anIObject->hasEntry()) {
2327 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2328 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2337 if(checkLock(aStudy)) break;
2339 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2342 SMESH::UpdateView();
2344 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2345 SMESH::OnVisuException();
2347 catch (...) { // PAL16774 (Crash after display of many groups)
2348 SMESH::OnVisuException();
2352 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2353 aSel->selectedObjects( l );
2354 aSel->setSelectedObjects( l );
2359 case 301: // DISPLAY
2360 case 302: // DISPLAY ONLY
2362 SMESH::EDisplaing anAction;
2363 switch (theCommandID) {
2364 case 300: anAction = SMESH::eErase; break;
2365 case 301: anAction = SMESH::eDisplay; break;
2366 case 302: anAction = SMESH::eDisplayOnly; break;
2369 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2370 SALOME_ListIO sel_objects, to_process;
2372 aSel->selectedObjects( sel_objects );
2374 if( theCommandID==302 )
2376 MESSAGE("anAction = SMESH::eDisplayOnly");
2377 startOperation( myEraseAll );
2380 extractContainers( sel_objects, to_process );
2383 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2387 SALOME_ListIteratorOfListIO It( to_process );
2388 for ( ; It.More(); It.Next()) {
2390 Handle(SALOME_InteractiveObject) IOS = It.Value();
2391 if (IOS->hasEntry()) {
2393 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2394 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2395 break; // PAL16774 (Crash after display of many groups)
2397 if (anAction == SMESH::eDisplayOnly)
2399 MESSAGE("anAction = SMESH::eDisplayOnly");
2400 anAction = SMESH::eDisplay;
2406 // PAL13338 + PAL15161 -->
2407 if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2408 MESSAGE("anAction = SMESH::eDisplayOnly");
2409 SMESH::UpdateView();
2410 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2412 // PAL13338 + PAL15161 <--
2414 catch (...) { // PAL16774 (Crash after display of many groups)
2415 SMESH::OnVisuException();
2418 if (anAction == SMESH::eErase) {
2419 MESSAGE("anAction == SMESH::eErase");
2421 aSel->setSelectedObjects( l1 );
2424 aSel->setSelectedObjects( to_process );
2431 if(checkLock(aStudy)) break;
2434 EmitSignalDeactivateDialog();
2436 ( new SMESHGUI_NodesDlg( this ) )->show();
2439 SUIT_MessageBox::warning(desktop(),
2440 tr("SMESH_WRN_WARNING"),
2441 tr("SMESH_WRN_VIEWER_VTK"));
2446 case 2151: // FILTER
2450 EmitSignalDeactivateDialog();
2451 ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2456 case 701: // COMPUTE MESH
2457 case 711: // PRECOMPUTE MESH
2458 case 712: // EVALUATE MESH
2459 case 713: // MESH ORDER
2460 case 702: // Create mesh
2461 case 703: // Create sub-mesh
2462 case 704: // Edit mesh/sub-mesh
2463 startOperation( theCommandID );
2465 case 705: // copy mesh
2467 if (checkLock(aStudy)) break;
2468 EmitSignalDeactivateDialog();
2469 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2472 case 710: // Build compound mesh
2474 if (checkLock(aStudy)) break;
2475 EmitSignalDeactivateDialog();
2476 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2480 case 407: // DIAGONAL INVERSION
2481 case 408: // Delete diagonal
2485 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2486 tr( "NOT_A_VTK_VIEWER" ) );
2490 if ( checkLock( aStudy ) )
2493 /*Standard_Boolean aRes;
2494 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2495 if ( aMesh->_is_nil() )
2497 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2498 tr( "SMESH_BAD_SELECTION" ) );
2502 EmitSignalDeactivateDialog();
2503 if ( theCommandID == 407 )
2504 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2506 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2509 case 409: // Change orientation
2510 case 410: // Union of triangles
2511 case 411: // Cutting of quadrangles
2512 case 419: // Splitting volumes into tetrahedra
2516 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2517 tr( "NOT_A_VTK_VIEWER" ) );
2521 if ( checkLock( aStudy ) )
2524 EmitSignalDeactivateDialog();
2525 SMESHGUI_MultiEditDlg* aDlg = NULL;
2526 if ( theCommandID == 409 )
2527 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2528 else if ( theCommandID == 410 )
2529 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2530 else if ( theCommandID == 419 )
2531 aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2533 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2538 case 412: // Smoothing
2540 if(checkLock(aStudy)) break;
2542 EmitSignalDeactivateDialog();
2543 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2546 SUIT_MessageBox::warning(desktop(),
2547 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2551 case 413: // Extrusion
2553 if (checkLock(aStudy)) break;
2555 EmitSignalDeactivateDialog();
2556 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2558 SUIT_MessageBox::warning(desktop(),
2559 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2563 case 414: // Revolution
2565 if(checkLock(aStudy)) break;
2567 EmitSignalDeactivateDialog();
2568 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2571 SUIT_MessageBox::warning(desktop(),
2572 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2576 case 415: // Pattern mapping
2578 if ( checkLock( aStudy ) )
2582 EmitSignalDeactivateDialog();
2583 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2586 SUIT_MessageBox::warning(desktop(),
2587 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2591 case 416: // Extrusion along a path
2593 if (checkLock(aStudy)) break;
2595 EmitSignalDeactivateDialog();
2596 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2598 SUIT_MessageBox::warning(desktop(),
2599 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2603 case 417: // Convert mesh to quadratic
2604 case 418: // create 2D mesh from 3D
2605 case 420: // Reorient faces
2606 case 806: // CREATE GEO GROUP
2608 startOperation( theCommandID );
2611 case 801: // CREATE GROUP
2615 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2616 tr( "NOT_A_VTK_VIEWER" ) );
2620 if(checkLock(aStudy)) break;
2621 EmitSignalDeactivateDialog();
2622 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2624 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2625 SALOME_ListIO selected;
2627 aSel->selectedObjects( selected );
2629 int nbSel = selected.Extent();
2631 // check if mesh is selected
2632 aMesh = SMESH::GetMeshByIO( selected.First() );
2634 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2639 case 802: // CONSTRUCT GROUP
2643 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2644 tr( "NOT_A_VTK_VIEWER" ) );
2648 if(checkLock(aStudy)) break;
2649 EmitSignalDeactivateDialog();
2651 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2652 SALOME_ListIO selected;
2654 aSel->selectedObjects( selected );
2656 int nbSel = selected.Extent();
2658 // check if submesh is selected
2659 Handle(SALOME_InteractiveObject) IObject = selected.First();
2660 if (IObject->hasEntry()) {
2661 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2663 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2664 if (!aSubMesh->_is_nil()) {
2666 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2667 // get submesh elements list by types
2668 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2669 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2670 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2671 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2672 // create group for each type o elements
2673 QString aName = IObject->getName();
2674 QStringList anEntryList;
2675 if (aNodes->length() > 0) {
2676 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2677 aGroup->Add(aNodes.inout());
2678 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2679 anEntryList.append( aSObject->GetID().c_str() );
2681 if (aEdges->length() > 0) {
2682 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2683 aGroup->Add(aEdges.inout());
2684 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2685 anEntryList.append( aSObject->GetID().c_str() );
2687 if (aFaces->length() > 0) {
2688 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2689 aGroup->Add(aFaces.inout());
2690 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2691 anEntryList.append( aSObject->GetID().c_str() );
2693 if (aVolumes->length() > 0) {
2694 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2695 aGroup->Add(aVolumes.inout());
2696 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2697 anEntryList.append( aSObject->GetID().c_str() );
2700 anApp->browseObjects( anEntryList );
2702 catch(const SALOME::SALOME_Exception & S_ex){
2703 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2710 SUIT_MessageBox::warning(desktop(),
2711 tr("SMESH_WRN_WARNING"),
2712 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2717 case 803: // EDIT GROUP
2721 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2722 tr( "NOT_A_VTK_VIEWER" ) );
2726 if(checkLock(aStudy)) break;
2727 EmitSignalDeactivateDialog();
2729 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2730 SALOME_ListIO selected;
2732 aSel->selectedObjects( selected );
2734 SALOME_ListIteratorOfListIO It (selected);
2735 int nbSelectedGroups = 0;
2736 for ( ; It.More(); It.Next() )
2738 SMESH::SMESH_GroupBase_var aGroup =
2739 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2740 if (!aGroup->_is_nil()) {
2742 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2746 if (nbSelectedGroups == 0)
2748 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2754 case 804: // Add elements to group
2756 if(checkLock(aStudy)) break;
2757 if (myState == 800) {
2758 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2759 if (aDlg) aDlg->onAdd();
2764 case 805: // Remove elements from group
2766 if(checkLock(aStudy)) break;
2767 if (myState == 800) {
2768 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2769 if (aDlg) aDlg->onRemove();
2774 case 815: // Edit GEOM GROUP as standalone
2778 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2779 tr( "NOT_A_VTK_VIEWER" ) );
2783 if(checkLock(aStudy)) break;
2784 EmitSignalDeactivateDialog();
2786 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2787 SALOME_ListIO selected;
2789 aSel->selectedObjects( selected );
2791 SALOME_ListIteratorOfListIO It (selected);
2792 for ( ; It.More(); It.Next() )
2794 SMESH::SMESH_GroupOnGeom_var aGroup =
2795 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2796 if (!aGroup->_is_nil()) {
2797 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2802 SMESH::SMESH_GroupOnFilter_var aGroup =
2803 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2804 if (!aGroup->_is_nil()) {
2805 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2813 case 810: // Union Groups
2814 case 811: // Intersect groups
2815 case 812: // Cut groups
2819 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2820 tr( "NOT_A_VTK_VIEWER" ) );
2824 if ( checkLock( aStudy ) )
2827 EmitSignalDeactivateDialog();
2829 SMESHGUI_GroupOpDlg* aDlg = 0;
2830 if ( theCommandID == 810 )
2831 aDlg = new SMESHGUI_UnionGroupsDlg( this );
2832 else if ( theCommandID == 811 )
2833 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2835 aDlg = new SMESHGUI_CutGroupsDlg( this );
2842 case 814: // Create groups of entities from existing groups of superior dimensions
2844 if ( checkLock( aStudy ) )
2847 EmitSignalDeactivateDialog();
2848 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2854 case 813: // Delete groups with their contents
2858 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2859 tr( "NOT_A_VTK_VIEWER" ) );
2863 if ( checkLock( aStudy ) )
2866 EmitSignalDeactivateDialog();
2868 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2872 case 900: // MESH INFOS
2873 case 903: // WHAT IS
2875 int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2876 EmitSignalDeactivateDialog();
2877 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2878 SALOME_ListIO selected;
2880 aSel->selectedObjects( selected );
2882 if ( selected.Extent() > 1 ) { // a dlg for each IO
2883 SALOME_ListIteratorOfListIO It( selected );
2884 for ( ; It.More(); It.Next() ) {
2885 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2886 dlg->showInfo( It.Value() );
2891 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2897 case 904: // FIND ELEM
2899 startOperation( theCommandID );
2903 case 1100: // EDIT HYPOTHESIS
2905 if(checkLock(aStudy)) break;
2907 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2908 SALOME_ListIO selected;
2910 aSel->selectedObjects( selected );
2912 int nbSel = selected.Extent();
2915 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2916 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
2918 /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
2919 /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects */
2920 /* Warning : however by internal mechanism all subMeshes icons are changed ! */
2921 if ( !aHypothesis->_is_nil() )
2924 //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2925 SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2927 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
2937 case 1102: // REMOVE HYPOTHESIS / ALGORITHMS
2939 if(checkLock(aStudy)) break;
2940 SUIT_OverrideCursor wc;
2942 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2943 SALOME_ListIO selected;
2945 aSel->selectedObjects( selected, QString::null, false );
2947 SALOME_ListIteratorOfListIO It(selected);
2948 for (int i = 0; It.More(); It.Next(), i++) {
2949 Handle(SALOME_InteractiveObject) IObject = It.Value();
2950 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2953 aSel->setSelectedObjects( l1 );
2959 case 4009: // ELEM0D
2961 case 4021: // TRIANGLE
2963 case 4023: // POLYGON
2967 case 4134: // PYRAMID
2968 case 4135: // OCTA12
2970 if(checkLock(aStudy)) break;
2972 EmitSignalDeactivateDialog();
2973 SMDSAbs_EntityType type = SMDSEntity_Edge;
2974 switch (theCommandID) {
2975 case 4008: type = SMDSEntity_Ball; break;
2976 case 4009: type = SMDSEntity_0D; break;
2977 case 4021: type = SMDSEntity_Triangle; break;
2978 case 4022: type = SMDSEntity_Quadrangle; break;
2979 case 4031: type = SMDSEntity_Tetra; break;
2980 case 4023: type = SMDSEntity_Polygon; break;
2981 case 4032: type = SMDSEntity_Hexa; break;
2982 case 4133: type = SMDSEntity_Penta; break;
2983 case 4134: type = SMDSEntity_Pyramid; break;
2984 case 4135: type = SMDSEntity_Hexagonal_Prism; break;
2987 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
2990 SUIT_MessageBox::warning(desktop(),
2991 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2995 case 4033: // POLYHEDRON
2997 if(checkLock(aStudy)) break;
2999 EmitSignalDeactivateDialog();
3000 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3003 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3004 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3008 case 4034: // QUADRATIC EDGE
3009 case 4035: // QUADRATIC TRIANGLE
3010 case 4036: // QUADRATIC QUADRANGLE
3011 case 4136: // BIQUADRATIC QUADRANGLE
3012 case 4037: // QUADRATIC TETRAHEDRON
3013 case 4038: // QUADRATIC PYRAMID
3014 case 4039: // QUADRATIC PENTAHEDRON
3015 case 4040: // QUADRATIC HEXAHEDRON
3016 case 4140: // TRIQUADRATIC HEXAHEDRON
3018 if(checkLock(aStudy)) break;
3020 EmitSignalDeactivateDialog();
3021 SMDSAbs_EntityType type;
3023 switch (theCommandID) {
3025 type = SMDSEntity_Quad_Edge; break;
3027 type = SMDSEntity_Quad_Triangle; break;
3029 type = SMDSEntity_Quad_Quadrangle; break;
3031 type = SMDSEntity_BiQuad_Quadrangle; break;
3033 type = SMDSEntity_Quad_Tetra; break;
3035 type = SMDSEntity_Quad_Pyramid; break;
3037 type = SMDSEntity_Quad_Penta; break;
3039 type = SMDSEntity_Quad_Hexa;
3041 type = SMDSEntity_TriQuad_Hexa;
3045 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3048 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3049 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3053 case 4041: // REMOVES NODES
3055 if(checkLock(aStudy)) break;
3057 EmitSignalDeactivateDialog();
3058 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3061 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3062 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3066 case 4042: // REMOVES ELEMENTS
3068 if(checkLock(aStudy)) break;
3070 EmitSignalDeactivateDialog();
3071 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3075 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3076 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3080 case 4043: { // CLEAR_MESH
3082 if(checkLock(aStudy)) break;
3084 SALOME_ListIO selected;
3085 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3086 aSel->selectedObjects( selected );
3088 SUIT_OverrideCursor wc;
3089 SALOME_ListIteratorOfListIO It (selected);
3090 for ( ; It.More(); It.Next() )
3092 Handle(SALOME_InteractiveObject) IOS = It.Value();
3093 SMESH::SMESH_Mesh_var aMesh =
3094 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3095 if ( aMesh->_is_nil()) continue;
3097 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3099 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3100 SMESH::ModifiedMesh( aMeshSObj, false, true);
3101 // hide groups and submeshes
3102 _PTR(ChildIterator) anIter =
3103 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3104 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3106 _PTR(SObject) so = anIter->Value();
3107 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3110 catch (const SALOME::SALOME_Exception& S_ex){
3112 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3116 SMESH::UpdateView();
3120 case 4044: // REMOVE ORPHAN NODES
3122 if(checkLock(aStudy)) break;
3123 SALOME_ListIO selected;
3124 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3125 aSel->selectedObjects( selected );
3126 if ( selected.Extent() == 1 ) {
3127 Handle(SALOME_InteractiveObject) anIO = selected.First();
3128 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3129 if ( !aMesh->_is_nil() ) {
3130 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3131 tr( "SMESH_WARNING" ),
3132 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3133 SUIT_MessageBox::Yes |
3134 SUIT_MessageBox::No,
3135 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3138 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3139 int removed = aMeshEditor->RemoveOrphanNodes();
3140 SUIT_MessageBox::information(SMESHGUI::desktop(),
3141 tr("SMESH_INFORMATION"),
3142 tr("NB_NODES_REMOVED").arg(removed));
3143 if ( removed > 0 ) {
3144 SMESH::UpdateView();
3145 SMESHGUI::Modified();
3148 catch (const SALOME::SALOME_Exception& S_ex) {
3149 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3158 case 4051: // RENUMBERING NODES
3160 if(checkLock(aStudy)) break;
3162 EmitSignalDeactivateDialog();
3163 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3167 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3168 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3172 case 4052: // RENUMBERING ELEMENTS
3174 if(checkLock(aStudy)) break;
3176 EmitSignalDeactivateDialog();
3177 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3181 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3182 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3186 case 4061: // TRANSLATION
3188 if(checkLock(aStudy)) break;
3190 EmitSignalDeactivateDialog();
3191 ( new SMESHGUI_TranslationDlg( this ) )->show();
3194 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3195 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3199 case 4062: // ROTATION
3201 if(checkLock(aStudy)) break;
3203 EmitSignalDeactivateDialog();
3204 ( new SMESHGUI_RotationDlg( this ) )->show();
3207 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3208 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3212 case 4063: // SYMMETRY
3214 if(checkLock(aStudy)) break;
3216 EmitSignalDeactivateDialog();
3217 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3220 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3221 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3225 case 4064: // SEWING
3227 if(checkLock(aStudy)) break;
3229 EmitSignalDeactivateDialog();
3230 ( new SMESHGUI_SewingDlg( this ) )->show();
3233 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3234 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3238 case 4065: // MERGE NODES
3240 if(checkLock(aStudy)) break;
3242 EmitSignalDeactivateDialog();
3243 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3246 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3247 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3251 case 4066: // MERGE EQUAL ELEMENTS
3253 if (checkLock(aStudy)) break;
3255 EmitSignalDeactivateDialog();
3256 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3258 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3259 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3264 case 4067: // MAKE MESH PASS THROUGH POINT
3265 startOperation( 4067 );
3270 if(checkLock(aStudy)) break;
3272 EmitSignalDeactivateDialog();
3273 ( new SMESHGUI_ScaleDlg( this ) )->show();
3276 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3277 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3282 case 4069: // DUPLICATE NODES
3284 if(checkLock(aStudy)) break;
3286 EmitSignalDeactivateDialog();
3287 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3290 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3291 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3296 case 5105: // Library of selection filters
3298 static QList<int> aTypes;
3299 if ( aTypes.isEmpty() )
3301 aTypes.append( SMESH::NODE );
3302 aTypes.append( SMESH::EDGE );
3303 aTypes.append( SMESH::FACE );
3304 aTypes.append( SMESH::VOLUME );
3306 if (!myFilterLibraryDlg)
3307 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3308 else if (myFilterLibraryDlg->isHidden())
3309 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3310 myFilterLibraryDlg->raise();
3314 case 6017: // CONTROLS
3342 LightApp_SelectionMgr* mgr = selectionMgr();
3343 SALOME_ListIO selected; mgr->selectedObjects( selected );
3345 if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3346 _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3348 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3349 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
3350 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3351 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
3352 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3353 ::Control( theCommandID );
3358 SUIT_MessageBox::warning(desktop(),
3359 tr( "SMESH_WRN_WARNING" ),
3360 tr( "SMESH_BAD_SELECTION" ) );
3364 SUIT_MessageBox::warning(desktop(),
3365 tr( "SMESH_WRN_WARNING" ),
3366 tr( "NOT_A_VTK_VIEWER" ) );
3371 LightApp_SelectionMgr* mgr = selectionMgr();
3372 SALOME_ListIO selected; mgr->selectedObjects( selected );
3374 SALOME_ListIteratorOfListIO it(selected);
3375 for( ; it.More(); it.Next()) {
3376 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3377 if(anIObject->hasEntry()) {
3378 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3379 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3387 LightApp_SelectionMgr* mgr = selectionMgr();
3388 SALOME_ListIO selected; mgr->selectedObjects( selected );
3390 SALOME_ListIteratorOfListIO it(selected);
3391 for( ; it.More(); it.Next()) {
3392 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3393 if(anIObject->hasEntry())
3394 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3395 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3403 int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3404 EmitSignalDeactivateDialog();
3405 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3411 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3412 //updateObjBrowser();
3416 //=============================================================================
3420 //=============================================================================
3421 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3426 //=============================================================================
3430 //=============================================================================
3431 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3436 //=============================================================================
3440 //=============================================================================
3441 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3446 //=============================================================================
3447 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3448 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3450 //=============================================================================
3451 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3452 SUIT_ViewWindow* wnd )
3454 if(theIO->hasEntry()){
3455 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3456 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3460 //=======================================================================
3461 // function : createSMESHAction
3463 //=======================================================================
3464 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3465 const int key, const bool toggle, const QString& shortcutAction )
3468 QWidget* parent = application()->desktop();
3469 SUIT_ResourceMgr* resMgr = resourceMgr();
3471 if ( !icon_id.isEmpty() )
3472 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3474 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3475 if ( !pix.isNull() )
3476 icon = QIcon( pix );
3478 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3479 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3480 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3482 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3483 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3486 //=======================================================================
3487 // function : createPopupItem
3489 //=======================================================================
3490 void SMESHGUI::createPopupItem( const int id,
3491 const QString& clients,
3492 const QString& types,
3493 const QString& theRule,
3498 parentId = popupMgr()->actionId( action( pId ) );
3500 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3501 popupMgr()->insert( action( id ), parentId, 0 );
3503 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3504 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3505 QString rule = "(%1) and (%2) and (%3)";
3506 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3507 if( clients.isEmpty() )
3508 rule = rule.arg( QString( "true" ) );
3510 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3511 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3514 bool cont = myRules.contains( id );
3516 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3518 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3519 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3522 //=======================================================================
3523 // function : initialize
3525 //=======================================================================
3526 void SMESHGUI::initialize( CAM_Application* app )
3528 SalomeApp_Module::initialize( app );
3530 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3532 /* Automatic Update flag */
3533 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3535 // ----- create actions --------------
3537 //createSMESHAction( 111, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3538 createSMESHAction( 112, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3539 createSMESHAction( 113, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3540 createSMESHAction( 114, "NUM" );
3541 createSMESHAction( 115, "IMPORT_STL" );
3542 createSMESHAction( 116, "IMPORT_CGNS" );
3543 createSMESHAction( 117, "IMPORT_SAUV" );
3544 createSMESHAction( 118, "IMPORT_GMF" );
3545 createSMESHAction( 121, "DAT" );
3546 createSMESHAction( 122, "MED" );
3547 createSMESHAction( 123, "UNV" );
3548 createSMESHAction( 140, "STL" );
3549 createSMESHAction( 142, "CGNS");
3550 createSMESHAction( 144, "SAUV");
3551 createSMESHAction( 146, "GMF" );
3552 createSMESHAction( 124, "EXPORT_DAT" );
3553 createSMESHAction( 125, "EXPORT_MED" );
3554 createSMESHAction( 126, "EXPORT_UNV" );
3555 createSMESHAction( 141, "EXPORT_STL" );
3556 createSMESHAction( 143, "EXPORT_CGNS");
3557 createSMESHAction( 145, "EXPORT_SAUV");
3558 createSMESHAction( 147, "EXPORT_GMF" );
3559 createSMESHAction( 150, "FILE_INFO" );
3560 createSMESHAction( 33, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3561 createSMESHAction( 5105, "SEL_FILTER_LIB" );
3562 createSMESHAction( 701, "COMPUTE", "ICON_COMPUTE" );
3563 createSMESHAction( 702, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3564 createSMESHAction( 703, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3565 createSMESHAction( 704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3566 createSMESHAction( 705, "COPY_MESH", "ICON_COPY_MESH" );
3567 createSMESHAction( 710, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3568 createSMESHAction( 711, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3569 createSMESHAction( 712, "EVALUATE", "ICON_COMPUTE" );
3570 createSMESHAction( 713, "MESH_ORDER", "ICON_COMPUTE" );
3571 createSMESHAction( 806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3572 createSMESHAction( 801, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3573 createSMESHAction( 802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3574 createSMESHAction( 803, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3575 createSMESHAction( 815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3576 createSMESHAction( 804, "ADD" );
3577 createSMESHAction( 805, "REMOVE" );
3578 createSMESHAction( 810, "UN_GROUP", "ICON_UNION" );
3579 createSMESHAction( 811, "INT_GROUP", "ICON_INTERSECT" );
3580 createSMESHAction( 812, "CUT_GROUP", "ICON_CUT" );
3581 createSMESHAction( 814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3582 createSMESHAction( 813, "DEL_GROUP", "ICON_DEL_GROUP" );
3583 createSMESHAction( 900, "ADV_INFO", "ICON_ADV_INFO" );
3584 //createSMESHAction( 902, "STD_INFO", "ICON_STD_INFO" );
3585 //createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3586 createSMESHAction( 904, "FIND_ELEM", "ICON_FIND_ELEM" );
3587 createSMESHAction( 6001, "LENGTH", "ICON_LENGTH", 0, true );
3588 createSMESHAction( 6002, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3589 createSMESHAction( 6021, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3590 createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3591 createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3592 createSMESHAction( 6024, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3593 createSMESHAction( 6025, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3594 createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3595 createSMESHAction( 6027, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3596 createSMESHAction( 6028, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3597 createSMESHAction( 6029, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3598 createSMESHAction( 6030, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3599 createSMESHAction( 6031, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3600 createSMESHAction( 6003, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3601 createSMESHAction( 6004, "CONNECTION", "ICON_CONNECTION", 0, true );
3602 createSMESHAction( 6005, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3603 createSMESHAction( 6011, "AREA", "ICON_AREA", 0, true );
3604 createSMESHAction( 6012, "TAPER", "ICON_TAPER", 0, true );
3605 createSMESHAction( 6013, "ASPECT", "ICON_ASPECT", 0, true );
3606 createSMESHAction( 6014, "MIN_ANG", "ICON_ANGLE", 0, true );
3607 createSMESHAction( 6015, "WARP", "ICON_WARP", 0, true );
3608 createSMESHAction( 6016, "SKEW", "ICON_SKEW", 0, true );
3609 createSMESHAction( 6017, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3610 createSMESHAction( 6018, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3611 createSMESHAction( 6019, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3612 createSMESHAction( 6009, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3613 createSMESHAction( 4000, "NODE", "ICON_DLG_NODE" );
3614 createSMESHAction( 4009, "ELEM0D", "ICON_DLG_ELEM0D" );
3615 createSMESHAction( 4008, "BALL", "ICON_DLG_BALL" );
3616 createSMESHAction( 4010, "EDGE", "ICON_DLG_EDGE" );
3617 createSMESHAction( 4021, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3618 createSMESHAction( 4022, "QUAD", "ICON_DLG_QUADRANGLE" );
3619 createSMESHAction( 4023, "POLYGON", "ICON_DLG_POLYGON" );
3620 createSMESHAction( 4031, "TETRA", "ICON_DLG_TETRAS" );
3621 createSMESHAction( 4032, "HEXA", "ICON_DLG_HEXAS" );
3622 createSMESHAction( 4133, "PENTA", "ICON_DLG_PENTA" );
3623 createSMESHAction( 4134, "PYRAMID", "ICON_DLG_PYRAMID" );
3624 createSMESHAction( 4135, "OCTA", "ICON_DLG_OCTA" );
3625 createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3626 createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3627 createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3628 createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3629 createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3630 createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3631 createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3632 createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3633 createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3634 createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3635 createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3636 createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3637 createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3638 createSMESHAction( 4043, "CLEAR_MESH" , "ICON_CLEAR_MESH" );
3639 createSMESHAction( 4051, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3640 createSMESHAction( 4052, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3641 createSMESHAction( 4061, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3642 createSMESHAction( 4062, "ROT", "ICON_DLG_MESH_ROTATION" );
3643 createSMESHAction( 4063, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3644 createSMESHAction( 4064, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3645 createSMESHAction( 4065, "MERGE", "ICON_SMESH_MERGE_NODES" );
3646 createSMESHAction( 4066, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3647 createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3648 createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" );
3649 createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3650 createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" );
3651 createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" );
3652 createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3653 createSMESHAction( 410, "UNION", "ICON_UNIONTRI" );
3654 createSMESHAction( 411, "CUT", "ICON_CUTQUAD" );
3655 createSMESHAction( 412, "SMOOTH", "ICON_DLG_SMOOTHING" );
3656 createSMESHAction( 413, "EXTRUSION", "ICON_EXTRUSION" );
3657 createSMESHAction( 414, "REVOLUTION", "ICON_REVOLUTION" );
3658 createSMESHAction( 415, "MAP", "ICON_MAP" );
3659 createSMESHAction( 416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3660 createSMESHAction( 417, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3661 createSMESHAction( 418, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3662 createSMESHAction( 419, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3663 createSMESHAction( 420, "REORIENT_2D", "ICON_REORIENT_2D" );
3664 createSMESHAction( 200, "RESET" );
3665 createSMESHAction( 201, "SCALAR_BAR_PROP" );
3666 createSMESHAction( 2021, "SAVE_DISTRIBUTION" );
3667 createSMESHAction( 2022, "SHOW_DISTRIBUTION","",0, true );
3668 #ifndef DISABLE_PLOT2DVIEWER
3669 createSMESHAction( 2023, "PLOT_DISTRIBUTION" );
3671 createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true );
3672 createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true );
3673 createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true );
3674 createSMESHAction( 214, "UPDATE", "ICON_UPDATE" );
3675 createSMESHAction( 215, "NODES", "ICON_POINTS", 0, true );
3676 createSMESHAction( 222, "BALLS", "ICON_DLG_BALL", 0, true );
3677 createSMESHAction( 216, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3678 createSMESHAction( 217, "EDGES", "ICON_DLG_EDGE", 0, true );
3679 createSMESHAction( 218, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3680 createSMESHAction( 219, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3681 createSMESHAction( 220, "ALL" );
3682 createSMESHAction( 221, "FACE_ORIENTATION", "", 0, true );
3684 createSMESHAction( 231, "LINE_REPRESENTATION", "", 0, true );
3685 createSMESHAction( 232, "ARC_REPRESENTATION", "", 0, true );
3687 createSMESHAction( 1100, "EDIT_HYPO" );
3688 createSMESHAction( 1102, "UNASSIGN" );
3689 createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3690 createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3691 createSMESHAction( 1131, "DISPMODE" );
3692 createSMESHAction( 1132, "COLORS" );
3693 createSMESHAction( 1133, "TRANSP" );
3694 createSMESHAction( 1134, "CLIP" );
3695 createSMESHAction( 1135, "DISP_ENT" );
3696 createSMESHAction( 1136, "AUTO_COLOR" );
3697 createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3698 createSMESHAction( 2000, "CTRL" );
3700 createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3701 createSMESHAction( 502, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3703 createSMESHAction( 300, "HIDE" );
3704 createSMESHAction( 301, "SHOW" );
3705 createSMESHAction( 302, "DISPLAY_ONLY" );
3707 // ----- create menu --------------
3708 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3709 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3710 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3711 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3712 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3713 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3714 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3715 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3717 createMenu( separator(), fileId );
3719 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3720 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3721 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3722 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3723 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3724 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3725 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3726 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3727 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3728 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3730 //createMenu( 111, importId, -1 );
3731 createMenu( 112, importId, -1 );
3732 createMenu( 113, importId, -1 );
3733 createMenu( 115, importId, -1 );
3735 createMenu( 116, importId, -1 );
3737 createMenu( 117, importId, -1 );
3738 createMenu( 118, importId, -1 );
3739 createMenu( 121, exportId, -1 );
3740 createMenu( 122, exportId, -1 );
3741 createMenu( 123, exportId, -1 );
3742 createMenu( 140, exportId, -1 ); // export to STL
3744 createMenu( 142, exportId, -1 ); // export to CGNS
3746 createMenu( 144, exportId, -1 ); // export to SAUV
3747 createMenu( 146, exportId, -1 ); // export to GMF
3748 createMenu( separator(), fileId, 10 );
3750 createMenu( 33, editId, -1 );
3752 createMenu( 5105, toolsId, -1 );
3754 createMenu( 702, meshId, -1 ); // "Mesh" menu
3755 createMenu( 703, meshId, -1 );
3756 createMenu( 704, meshId, -1 );
3757 createMenu( 710, meshId, -1 );
3758 createMenu( 705, meshId, -1 );
3759 createMenu( separator(), meshId, -1 );
3760 createMenu( 701, meshId, -1 );
3761 createMenu( 711, meshId, -1 );
3762 createMenu( 712, meshId, -1 );
3763 createMenu( 713, meshId, -1 );
3764 createMenu( separator(), meshId, -1 );
3765 createMenu( 801, meshId, -1 );
3766 createMenu( 806, meshId, -1 );
3767 createMenu( 802, meshId, -1 );
3768 createMenu( 803, meshId, -1 );
3769 createMenu( 815, meshId, -1 );
3770 createMenu( separator(), meshId, -1 );
3771 createMenu( 810, meshId, -1 );
3772 createMenu( 811, meshId, -1 );
3773 createMenu( 812, meshId, -1 );
3774 createMenu( separator(), meshId, -1 );
3775 createMenu( 814, meshId, -1 );
3776 createMenu( separator(), meshId, -1 );
3777 createMenu( 900, meshId, -1 );
3778 //createMenu( 902, meshId, -1 );
3779 //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3780 createMenu( 904, meshId, -1 );
3781 createMenu( separator(), meshId, -1 );
3783 createMenu( 6005, nodeId, -1 );
3784 createMenu( 6028, nodeId, -1 );
3785 createMenu( 6002, edgeId, -1 );
3786 createMenu( 6003, edgeId, -1 );
3787 createMenu( 6001, edgeId, -1 );
3788 createMenu( 6004, edgeId, -1 );
3789 createMenu( 6029, edgeId, -1 );
3790 createMenu( 6021, faceId, -1 );
3791 createMenu( 6025, faceId, -1 );
3792 createMenu( 6027, faceId, -1 );
3793 createMenu( 6018, faceId, -1 );
3794 createMenu( 6019, faceId, -1 );
3795 createMenu( 6011, faceId, -1 );
3796 createMenu( 6012, faceId, -1 );
3797 createMenu( 6013, faceId, -1 );
3798 createMenu( 6014, faceId, -1 );
3799 createMenu( 6015, faceId, -1 );
3800 createMenu( 6016, faceId, -1 );
3801 createMenu( 6022, faceId, -1 );
3802 createMenu( 6030, faceId, -1 );
3803 createMenu( 6017, volumeId, -1 );
3804 createMenu( 6009, volumeId, -1 );
3805 createMenu( 6023, volumeId, -1 );
3806 createMenu( 6024, volumeId, -1 );
3807 createMenu( 6026, volumeId, -1 );
3808 createMenu( 6031, volumeId, -1 );
3810 createMenu( 4000, addId, -1 );
3811 createMenu( 4009, addId, -1 );
3812 createMenu( 4008, addId, -1 );
3813 createMenu( 4010, addId, -1 );
3814 createMenu( 4021, addId, -1 );
3815 createMenu( 4022, addId, -1 );
3816 createMenu( 4023, addId, -1 );
3817 createMenu( 4031, addId, -1 );
3818 createMenu( 4032, addId, -1 );
3819 createMenu( 4133, addId, -1 );
3820 createMenu( 4134, addId, -1 );
3821 createMenu( 4135, addId, -1 );
3822 createMenu( 4033, addId, -1 );
3823 createMenu( separator(), addId, -1 );
3824 createMenu( 4034, addId, -1 );
3825 createMenu( 4035, addId, -1 );
3826 createMenu( 4036, addId, -1 );
3827 createMenu( 4136, addId, -1 );
3828 createMenu( 4037, addId, -1 );
3829 createMenu( 4038, addId, -1 );
3830 createMenu( 4039, addId, -1 );
3831 createMenu( 4040, addId, -1 );
3832 createMenu( 4140, addId, -1 );
3834 createMenu( 4041, removeId, -1 );
3835 createMenu( 4042, removeId, -1 );
3836 createMenu( 4044, removeId, -1 );
3837 createMenu( separator(), removeId, -1 );
3838 createMenu( 813, removeId, -1 );
3839 createMenu( separator(), removeId, -1 );
3840 createMenu( 4043, removeId, -1 );
3842 createMenu( 4051, renumId, -1 );
3843 createMenu( 4052, renumId, -1 );
3845 createMenu( 4061, transfId, -1 );
3846 createMenu( 4062, transfId, -1 );
3847 createMenu( 4063, transfId, -1 );
3848 createMenu( 4068, transfId, -1 );
3849 createMenu( 4064, transfId, -1 );
3850 createMenu( 4065, transfId, -1 );
3851 createMenu( 4066, transfId, -1 );
3852 createMenu( 4069, transfId, -1 );
3854 createMenu( 4067,modifyId, -1 );
3855 createMenu( 407, modifyId, -1 );
3856 createMenu( 408, modifyId, -1 );
3857 createMenu( 409, modifyId, -1 );
3858 createMenu( 420, modifyId, -1 );
3859 createMenu( 410, modifyId, -1 );
3860 createMenu( 411, modifyId, -1 );
3861 createMenu( 419, modifyId, -1 );
3862 createMenu( 412, modifyId, -1 );
3863 createMenu( 413, modifyId, -1 );
3864 createMenu( 416, modifyId, -1 );
3865 createMenu( 414, modifyId, -1 );
3866 createMenu( 415, modifyId, -1 );
3867 createMenu( 417, modifyId, -1 );
3868 createMenu( 418, modifyId, -1 );
3870 createMenu( 501, measureId, -1 );
3871 createMenu( 502, measureId, -1 );
3872 createMenu( 214, viewId, -1 );
3874 // ----- create toolbars --------------
3875 int meshTb = createTool( tr( "TB_MESH" ) ),
3876 ctrlTb = createTool( tr( "TB_CTRL" ) ),
3877 addRemTb = createTool( tr( "TB_ADD_REMOVE" ) ),
3878 modifyTb = createTool( tr( "TB_MODIFY" ) ),
3879 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
3881 createTool( 702, meshTb );
3882 createTool( 703, meshTb );
3883 createTool( 704, meshTb );
3884 createTool( 710, meshTb );
3885 createTool( 705, meshTb );
3886 createTool( separator(), meshTb );
3887 createTool( 701, meshTb );
3888 createTool( 711, meshTb );
3889 createTool( 712, meshTb );
3890 createTool( 713, meshTb );
3891 createTool( separator(), meshTb );
3892 createTool( 801, meshTb );
3893 createTool( 806, meshTb );
3894 createTool( 802, meshTb );
3895 createTool( 803, meshTb );
3896 //createTool( 815, meshTb );
3897 createTool( separator(), meshTb );
3898 createTool( 900, meshTb );
3899 //createTool( 902, meshTb );
3900 //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3901 createTool( 904, meshTb );
3902 createTool( separator(), meshTb );
3904 createTool( 6005, ctrlTb );
3905 createTool( 6028, ctrlTb );
3906 createTool( separator(), ctrlTb );
3907 createTool( 6002, ctrlTb );
3908 createTool( 6003, ctrlTb );
3909 createTool( 6001, ctrlTb );
3910 createTool( 6004, ctrlTb );
3911 createTool( 6029, ctrlTb );
3912 createTool( separator(), ctrlTb );
3913 createTool( 6021, ctrlTb );
3914 createTool( 6025, ctrlTb );
3915 createTool( 6027, ctrlTb );
3916 createTool( 6018, ctrlTb );
3917 createTool( 6019, ctrlTb );
3918 createTool( 6011, ctrlTb );
3919 createTool( 6012, ctrlTb );
3920 createTool( 6013, ctrlTb );
3921 createTool( 6014, ctrlTb );
3922 createTool( 6015, ctrlTb );
3923 createTool( 6016, ctrlTb );
3924 createTool( 6022, ctrlTb );
3925 createTool( 6030, ctrlTb );
3926 createTool( separator(), ctrlTb );
3927 createTool( 6017, ctrlTb );
3928 createTool( 6009, ctrlTb );
3929 createTool( 6023, ctrlTb );
3930 createTool( 6024, ctrlTb );
3931 createTool( 6026, ctrlTb );
3932 createTool( 6031, ctrlTb );
3933 createTool( separator(), ctrlTb );
3935 createTool( 4000, addRemTb );
3936 createTool( 4009, addRemTb );
3937 createTool( 4008, addRemTb );
3938 createTool( 4010, addRemTb );
3939 createTool( 4021, addRemTb );
3940 createTool( 4022, addRemTb );
3941 createTool( 4023, addRemTb );
3942 createTool( 4031, addRemTb );
3943 createTool( 4032, addRemTb );
3944 createTool( 4133, addRemTb );
3945 createTool( 4134, addRemTb );
3946 createTool( 4135, addRemTb );
3947 createTool( 4033, addRemTb );
3948 createTool( separator(), addRemTb );
3949 createTool( 4034, addRemTb );
3950 createTool( 4035, addRemTb );
3951 createTool( 4036, addRemTb );
3952 createTool( 4136, addRemTb );
3953 createTool( 4037, addRemTb );
3954 createTool( 4038, addRemTb );
3955 createTool( 4039, addRemTb );
3956 createTool( 4040, addRemTb );
3957 createTool( 4140, addRemTb );
3958 createTool( separator(), addRemTb );
3959 createTool( 4041, addRemTb );
3960 createTool( 4042, addRemTb );
3961 createTool( 4044, addRemTb );
3962 createTool( 4043, addRemTb );
3963 createTool( separator(), addRemTb );
3964 createTool( 4051, addRemTb );
3965 createTool( 4052, addRemTb );
3966 createTool( separator(), addRemTb );
3967 createTool( 4061, addRemTb );
3968 createTool( 4062, addRemTb );
3969 createTool( 4063, addRemTb );
3970 createTool( 4068, addRemTb );
3971 createTool( 4064, addRemTb );
3972 createTool( 4065, addRemTb );
3973 createTool( 4066, addRemTb );
3974 createTool( 4069, addRemTb );
3975 createTool( separator(), addRemTb );
3977 createTool( 4067,modifyTb );
3978 createTool( 407, modifyTb );
3979 createTool( 408, modifyTb );
3980 createTool( 409, modifyTb );
3981 createTool( 420, modifyTb );
3982 createTool( 410, modifyTb );
3983 createTool( 411, modifyTb );
3984 createTool( 419, modifyTb );
3985 createTool( 412, modifyTb );
3986 createTool( 413, modifyTb );
3987 createTool( 416, modifyTb );
3988 createTool( 414, modifyTb );
3989 createTool( 415, modifyTb );
3990 createTool( 417, modifyTb );
3991 createTool( 418, modifyTb );
3993 createTool( 214, dispModeTb );
3995 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3996 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3999 QString OB = "'ObjectBrowser'",
4000 View = "'" + SVTK_Viewer::Type() + "'",
4002 mesh = pat.arg( SMESHGUI_Selection::typeName( MESH ) ),
4003 group = pat.arg( SMESHGUI_Selection::typeName( GROUP ) ),
4004 hypo = pat.arg( SMESHGUI_Selection::typeName( HYPOTHESIS ) ),
4005 algo = pat.arg( SMESHGUI_Selection::typeName( ALGORITHM ) ),
4006 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4007 arg( SMESHGUI_Selection::typeName( SUBMESH_VERTEX ) ).
4008 arg( SMESHGUI_Selection::typeName( SUBMESH_EDGE ) ).
4009 arg( SMESHGUI_Selection::typeName( SUBMESH_FACE ) ).
4010 arg( SMESHGUI_Selection::typeName( SUBMESH_SOLID ) ).
4011 arg( SMESHGUI_Selection::typeName( SUBMESH_COMPOUND ) ).
4012 arg( SMESHGUI_Selection::typeName( SUBMESH ) ),
4014 mesh_part = mesh + " " + subMesh + " " + group,
4015 mesh_group = mesh + " " + group,
4016 hyp_alg = hypo + " " + algo;
4018 // popup for object browser
4020 isInvisible("not( isVisible )"),
4021 isEmpty("numberOfNodes = 0"),
4022 isNotEmpty("numberOfNodes <> 0"),
4024 // has nodes, edges, etc in VISIBLE! actor
4025 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4026 hasElems("(count( elemTypes ) > 0)"),
4027 hasDifferentElems("(count( elemTypes ) > 1)"),
4028 hasBalls("({'BallElem'} in elemTypes)"),
4029 hasElems0d("({'Elem0d'} in elemTypes)"),
4030 hasEdges("({'Edge'} in elemTypes)"),
4031 hasFaces("({'Face'} in elemTypes)"),
4032 hasVolumes("({'Volume'} in elemTypes)");
4034 createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
4035 createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
4036 createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
4037 createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
4038 createPopupItem( 803, OB, group ); // EDIT_GROUP
4039 createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
4041 popupMgr()->insert( separator(), -1, 0 );
4042 createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
4043 createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
4044 createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
4045 createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
4046 createPopupItem( 214, OB, mesh_part ); // UPDATE
4047 createPopupItem( 900, OB, mesh_part ); // ADV_INFO
4048 createPopupItem( 904, OB, mesh_group ); // FIND_ELEM
4049 popupMgr()->insert( separator(), -1, 0 );
4050 createPopupItem( 801, OB, mesh ); // CREATE_GROUP
4051 createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
4052 createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
4053 popupMgr()->insert( separator(), -1, 0 );
4054 createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
4055 createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4056 popupMgr()->insert( separator(), -1, 0 );
4057 createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
4058 popupMgr()->insert( separator(), -1, 0 );
4059 createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
4060 createPopupItem( 418, OB, mesh + " " + group, // create 2D mesh from 3D
4062 popupMgr()->insert( separator(), -1, 0 );
4064 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4065 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4066 QString only_one_2D = only_one_non_empty + " && dim>1";
4068 createPopupItem( 125, OB, mesh_group, multiple_non_empty ); // EXPORT_MED
4069 createPopupItem( 126, OB, mesh_group, only_one_non_empty ); // EXPORT_UNV
4070 createPopupItem( 141, OB, mesh_group, only_one_2D ); // EXPORT_STL
4072 createPopupItem( 143, OB, mesh_group, multiple_non_empty ); // EXPORT_CGNS
4074 createPopupItem( 145, OB, mesh_group, multiple_non_empty ); // EXPORT_SAUV
4075 createPopupItem( 147, OB, mesh_group, multiple_non_empty ); // EXPORT_GMF
4076 createPopupItem( 33, OB, mesh_part + " " + hyp_alg ); // DELETE
4077 createPopupItem( 813, OB, group ); // DEL_GROUP with contents
4078 popupMgr()->insert( separator(), -1, 0 );
4081 createPopupItem( 803, View, group ); // EDIT_GROUP
4082 createPopupItem( 804, View, elems ); // ADD
4083 createPopupItem( 805, View, elems ); // REMOVE
4085 popupMgr()->insert( separator(), -1, 0 );
4086 createPopupItem( 214, View, mesh_part ); // UPDATE
4087 createPopupItem( 900, View, mesh_part ); // ADV_INFO
4088 createPopupItem( 904, View, mesh ); // FIND_ELEM
4089 popupMgr()->insert( separator(), -1, 0 );
4091 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
4092 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
4093 popupMgr()->insert( separator(), -1, 0 );
4096 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4097 QString aType = QString( "%1type in {%2}" ).arg( lc );
4098 aType = aType.arg( mesh_part );
4099 QString aMeshInVTK = aClient + "&&" + aType;
4101 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4102 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4103 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4105 //-------------------------------------------------
4107 //-------------------------------------------------
4108 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4110 popupMgr()->insert( action( 9010 ), anId, -1 );
4111 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4112 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4114 popupMgr()->insert( action( 9011 ), anId, -1 );
4115 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4116 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4118 popupMgr()->insert( separator(), -1, -1 );
4120 //-------------------------------------------------
4122 //-------------------------------------------------
4123 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4125 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4126 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4127 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4129 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4130 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4131 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4133 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4134 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4135 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4137 popupMgr()->insert( separator(), anId, -1 );
4139 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4140 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4141 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4143 //-------------------------------------------------
4145 //-------------------------------------------------
4146 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4148 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4150 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4151 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4152 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4154 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4155 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4156 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4158 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4159 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4160 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4162 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4163 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4164 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4166 popupMgr()->insert( action( 222 ), anId, -1 ); // BALLS
4167 popupMgr()->setRule( action( 222 ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4168 popupMgr()->setRule( action( 222 ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4170 popupMgr()->insert( separator(), anId, -1 );
4172 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4173 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4176 //-------------------------------------------------
4177 // Representation of the 2D Quadratic elements
4178 //-------------------------------------------------
4179 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4180 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4181 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4182 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4184 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4185 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4186 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4188 //-------------------------------------------------
4189 // Orientation of faces
4190 //-------------------------------------------------
4191 popupMgr()->insert( action( 221 ), -1, -1 );
4192 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4193 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4195 //-------------------------------------------------
4197 //-------------------------------------------------
4198 popupMgr()->insert( action( 1132 ), -1, -1 );
4199 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4201 //-------------------------------------------------
4203 //-------------------------------------------------
4204 popupMgr()->insert( action( 1133 ), -1, -1 );
4205 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4207 //-------------------------------------------------
4209 //-------------------------------------------------
4211 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4212 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4213 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4214 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4216 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4218 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4219 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4221 popupMgr()->insert( separator(), anId, -1 );
4223 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4225 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4226 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4227 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4229 popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4230 popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4231 popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4233 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4235 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4236 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4237 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4239 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4240 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4241 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4243 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4244 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4245 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4247 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4248 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4249 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4250 popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4251 popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4252 popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4254 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4256 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4257 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4258 QtxPopupMgr::VisibleRule );
4259 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4261 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4262 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4263 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4265 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4266 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4267 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4269 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4270 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4271 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4273 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4274 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4275 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4277 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4278 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4279 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4281 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4282 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4283 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4285 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4286 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4287 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4289 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4290 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4291 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4293 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4294 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4295 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4297 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4298 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4299 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4301 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4302 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4303 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4304 popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4305 popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4306 popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4308 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4310 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4311 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4312 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4314 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4315 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4316 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4318 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4319 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4320 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4322 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4323 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4324 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4326 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4327 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4328 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4330 popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4331 popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4332 popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4334 popupMgr()->insert( separator(), anId, -1 );
4336 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4337 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4339 popupMgr()->insert( separator(), anId, -1 );
4341 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4343 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4344 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4346 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4347 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4348 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4350 #ifndef DISABLE_PLOT2DVIEWER
4351 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4352 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4355 //-------------------------------------------------
4357 //-------------------------------------------------
4358 popupMgr()->insert( separator(), -1, -1 );
4359 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4360 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4361 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4362 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4364 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4365 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4367 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4368 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4370 popupMgr()->insert( separator(), -1, -1 );
4372 //-------------------------------------------------
4374 //-------------------------------------------------
4375 popupMgr()->insert( action( 1134 ), -1, -1 );
4376 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4378 popupMgr()->insert( separator(), -1, -1 );
4380 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4381 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4383 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4384 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4387 //================================================================================
4389 * \brief Return true if SMESH or GEOM objects are selected.
4390 * Is called form LightApp_Module::activateModule() which clear selection if
4391 * not isSelectionCompatible()
4393 //================================================================================
4395 bool SMESHGUI::isSelectionCompatible()
4397 bool isCompatible = true;
4398 SALOME_ListIO selected;
4399 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4400 Sel->selectedObjects( selected );
4402 SALOME_ListIteratorOfListIO It( selected );
4403 for ( ; isCompatible && It.More(); It.Next())
4405 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4406 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4408 return isCompatible;
4412 bool SMESHGUI::reusableOperation( const int id )
4414 // compute, evaluate and precompute are not reusable operations
4415 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4418 bool SMESHGUI::activateModule( SUIT_Study* study )
4420 bool res = SalomeApp_Module::activateModule( study );
4422 setMenuShown( true );
4423 setToolShown( true );
4425 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4426 PyGILState_STATE gstate = PyGILState_Ensure();
4427 PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4428 if(pluginsmanager==NULL)
4432 PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4437 PyGILState_Release(gstate);
4438 // end of GEOM plugins loading
4440 // Reset actions accelerator keys
4441 //action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4442 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4443 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4445 action( 33)->setEnabled(true); // Delete: Key_Delete
4447 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4448 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4449 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4450 if ( _PTR(Study) aStudy = s->studyDS()) {
4451 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4452 updateObjBrowser(); // objects can be removed
4455 // get all view currently opened in the study and connect their signals to
4456 // the corresponding slots of the class.
4457 SUIT_Desktop* aDesk = study->application()->desktop();
4459 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4460 SUIT_ViewWindow* wnd;
4461 foreach ( wnd, wndList )
4468 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4470 setMenuShown( false );
4471 setToolShown( false );
4473 EmitSignalCloseAllDialogs();
4475 // Unset actions accelerator keys
4476 //action(111)->setShortcut(QKeySequence()); // Import DAT
4477 action(112)->setShortcut(QKeySequence()); // Import UNV
4478 action(113)->setShortcut(QKeySequence()); // Import MED
4480 action( 33)->setEnabled(false); // Delete: Key_Delete
4482 return SalomeApp_Module::deactivateModule( study );
4485 void SMESHGUI::studyClosed( SUIT_Study* s )
4487 SMESH::RemoveVisuData( s->id() );
4488 SalomeApp_Module::studyClosed( s );
4491 void SMESHGUI::OnGUIEvent()
4493 const QObject* obj = sender();
4494 if ( !obj || !obj->inherits( "QAction" ) )
4496 int id = actionId((QAction*)obj);
4501 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4503 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4504 if ( CORBA::is_nil( myComponentSMESH ) )
4506 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4508 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4509 return aGUI.myComponentSMESH;
4512 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4513 return myComponentSMESH;
4516 QString SMESHGUI::engineIOR() const
4518 CORBA::ORB_var anORB = getApp()->orb();
4519 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4520 return QString( anIOR.in() );
4523 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4525 SalomeApp_Module::contextMenuPopup( client, menu, title );
4527 selectionMgr()->selectedObjects( lst );
4528 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4529 Handle(SALOME_InteractiveObject) io = lst.First();
4530 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4531 _PTR(Study) study = appStudy->studyDS();
4532 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4534 QString aName = QString( obj->GetName().c_str() );
4535 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4536 aName.remove( (aName.length() - 1), 1 );
4542 LightApp_Selection* SMESHGUI::createSelection() const
4544 return new SMESHGUI_Selection();
4547 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4549 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4550 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4553 void SMESHGUI::viewManagers( QStringList& list ) const
4555 list.append( SVTK_Viewer::Type() );
4558 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4560 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4561 SMESH::UpdateSelectionProp( this );
4563 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4564 for(int i = 0; i < aViews.count() ; i++){
4565 SUIT_ViewWindow *sf = aViews[i];
4571 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4573 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4574 myClippingPlaneInfoMap.erase( theViewManager );
4577 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4579 theActor->AddObserver( SMESH::DeleteActorEvent,
4580 myEventCallbackCommand.GetPointer(),
4584 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4585 unsigned long theEvent,
4586 void* theClientData,
4589 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4590 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4591 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4592 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4593 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4594 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4595 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4596 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4597 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4598 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4599 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4600 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4601 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4602 if( anActor == *anIter3 ) {
4603 anActorList.erase( anIter3 );
4614 void SMESHGUI::createPreferences()
4616 // General tab ------------------------------------------------------------------------
4617 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4619 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4620 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4621 setPreferenceProperty( lim, "min", 0 );
4622 setPreferenceProperty( lim, "max", 100000000 );
4623 setPreferenceProperty( lim, "step", 1000 );
4624 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4626 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4627 setPreferenceProperty( qaGroup, "columns", 2 );
4628 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4629 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4630 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4631 setPreferenceProperty( prec, "min", 0 );
4632 setPreferenceProperty( prec, "max", 16 );
4633 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4634 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4635 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4636 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4637 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4639 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4640 setPreferenceProperty( dispgroup, "columns", 2 );
4641 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4643 modes.append( tr("MEN_WIRE") );
4644 modes.append( tr("MEN_SHADE") );
4645 modes.append( tr("MEN_NODES") );
4646 modes.append( tr("MEN_SHRINK") );
4647 QList<QVariant> indices;
4648 indices.append( 0 );
4649 indices.append( 1 );
4650 indices.append( 2 );
4651 indices.append( 3 );
4652 setPreferenceProperty( dispmode, "strings", modes );
4653 setPreferenceProperty( dispmode, "indexes", indices );
4655 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4656 setPreferenceProperty( arcgroup, "columns", 2 );
4657 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4658 QStringList quadraticModes;
4659 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4660 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4662 indices.append( 0 );
4663 indices.append( 1 );
4664 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4665 setPreferenceProperty( quadraticmode, "indexes", indices );
4667 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4668 "SMESH", "max_angle" );
4669 setPreferenceProperty( maxAngle, "min", 1 );
4670 setPreferenceProperty( maxAngle, "max", 90 );
4674 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4675 setPreferenceProperty( exportgroup, "columns", 2 );
4676 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4677 addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4679 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4680 setPreferenceProperty( computeGroup, "columns", 2 );
4681 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4683 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4684 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4685 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4687 indices.append( 0 );
4688 indices.append( 1 );
4689 indices.append( 2 );
4690 setPreferenceProperty( notifyMode, "strings", modes );
4691 setPreferenceProperty( notifyMode, "indexes", indices );
4693 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4694 setPreferenceProperty( infoGroup, "columns", 4 );
4695 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4697 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4698 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4700 indices.append( 0 );
4701 indices.append( 1 );
4702 setPreferenceProperty( elemInfo, "strings", modes );
4703 setPreferenceProperty( elemInfo, "indexes", indices );
4704 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4705 setPreferenceProperty( nodesLim, "min", 0 );
4706 setPreferenceProperty( nodesLim, "max", 10000000 );
4707 setPreferenceProperty( nodesLim, "step", 10000 );
4708 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4710 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4711 setPreferenceProperty( segGroup, "columns", 2 );
4712 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4713 "SMESH", "segmentation" );
4714 setPreferenceProperty( segLen, "min", 1 );
4715 setPreferenceProperty( segLen, "max", 10000000 );
4716 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4717 "SMESH", "nb_segments_per_edge" );
4718 setPreferenceProperty( nbSeg, "min", 1 );
4719 setPreferenceProperty( nbSeg, "max", 10000000 );
4721 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4722 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4723 "SMESH", "forget_mesh_on_hyp_modif" );
4726 // Quantities with individual precision settings
4727 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4728 setPreferenceProperty( precGroup, "columns", 2 );
4730 const int nbQuantities = 6;
4731 int precs[nbQuantities], ii = 0;
4732 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4733 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4734 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4735 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4736 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4737 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4738 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4739 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4740 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4741 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4742 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4743 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4745 // Set property for precision value for spinboxes
4746 for ( ii = 0; ii < nbQuantities; ii++ ){
4747 setPreferenceProperty( precs[ii], "min", -14 );
4748 setPreferenceProperty( precs[ii], "max", 14 );
4749 setPreferenceProperty( precs[ii], "precision", 2 );
4752 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4753 setPreferenceProperty( previewGroup, "columns", 2 );
4754 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4755 setPreferenceProperty( chunkSize, "min", 0 );
4756 setPreferenceProperty( chunkSize, "max", 1000 );
4757 setPreferenceProperty( chunkSize, "step", 50 );
4759 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4760 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4762 // Mesh tab ------------------------------------------------------------------------
4763 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4764 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4765 setPreferenceProperty( nodeGroup, "columns", 3 );
4767 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4769 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4771 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4772 QList<QVariant> aMarkerTypeIndicesList;
4773 QList<QVariant> aMarkerTypeIconsList;
4774 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4775 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4776 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4777 aMarkerTypeIndicesList << i;
4778 aMarkerTypeIconsList << pixmap;
4780 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4781 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4783 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4785 QList<QVariant> aMarkerScaleIndicesList;
4786 QStringList aMarkerScaleValuesList;
4787 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4788 aMarkerScaleIndicesList << i;
4789 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4791 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4792 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4794 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4795 //setPreferenceProperty( elemGroup, "columns", 2 );
4797 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4798 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4799 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
4800 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
4801 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4802 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
4803 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4804 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4807 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4808 setPreferenceProperty( grpGroup, "columns", 2 );
4810 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4811 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
4813 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4814 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4815 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
4816 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
4817 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4818 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4819 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
4820 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
4821 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4822 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4824 setPreferenceProperty( size0d, "min", 1 );
4825 setPreferenceProperty( size0d, "max", 10 );
4827 setPreferenceProperty( ballSize, "min", 1 );
4828 setPreferenceProperty( ballSize, "max", 10 );
4830 setPreferenceProperty( elemW, "min", 1 );
4831 setPreferenceProperty( elemW, "max", 5 );
4833 setPreferenceProperty( outW, "min", 1 );
4834 setPreferenceProperty( outW, "max", 5 );
4836 setPreferenceProperty( shrink, "min", 0 );
4837 setPreferenceProperty( shrink, "max", 100 );
4839 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4840 setPreferenceProperty( orientGroup, "columns", 1 );
4842 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4843 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4845 setPreferenceProperty( orientScale, "min", 0.05 );
4846 setPreferenceProperty( orientScale, "max", 0.5 );
4847 setPreferenceProperty( orientScale, "step", 0.05 );
4849 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4851 // Selection tab ------------------------------------------------------------------------
4852 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4854 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4855 setPreferenceProperty( selGroup, "columns", 2 );
4857 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4858 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4860 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4861 setPreferenceProperty( preGroup, "columns", 2 );
4863 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4865 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4866 setPreferenceProperty( precSelGroup, "columns", 2 );
4868 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4869 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4870 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4872 // Scalar Bar tab ------------------------------------------------------------------------
4873 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4874 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4875 setPreferenceProperty( fontGr, "columns", 2 );
4877 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4878 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4880 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4881 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4883 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4884 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4886 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4887 setPreferenceProperty( numcol, "min", 2 );
4888 setPreferenceProperty( numcol, "max", 256 );
4890 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4891 setPreferenceProperty( numlab, "min", 2 );
4892 setPreferenceProperty( numlab, "max", 65 );
4894 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4895 setPreferenceProperty( orientGr, "columns", 2 );
4896 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4897 QStringList orients;
4898 orients.append( tr( "SMESH_VERTICAL" ) );
4899 orients.append( tr( "SMESH_HORIZONTAL" ) );
4900 indices.clear(); indices.append( 0 ); indices.append( 1 );
4901 setPreferenceProperty( orient, "strings", orients );
4902 setPreferenceProperty( orient, "indexes", indices );
4904 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4905 setPreferenceProperty( posVSizeGr, "columns", 2 );
4906 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4907 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4908 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4909 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4910 setPreferenceProperty( xv, "step", 0.1 );
4911 setPreferenceProperty( xv, "min", 0.0 );
4912 setPreferenceProperty( xv, "max", 1.0 );
4913 setPreferenceProperty( yv, "step", 0.1 );
4914 setPreferenceProperty( yv, "min", 0.0 );
4915 setPreferenceProperty( yv, "max", 1.0 );
4916 setPreferenceProperty( wv, "step", 0.1 );
4917 setPreferenceProperty( wv, "min", 0.0 );
4918 setPreferenceProperty( wv, "max", 1.0 );
4919 setPreferenceProperty( hv, "min", 0.0 );
4920 setPreferenceProperty( hv, "max", 1.0 );
4921 setPreferenceProperty( hv, "step", 0.1 );
4923 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
4924 setPreferenceProperty( posHSizeGr, "columns", 2 );
4925 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
4926 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
4927 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
4928 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
4929 setPreferenceProperty( xv, "min", 0.0 );
4930 setPreferenceProperty( xv, "max", 1.0 );
4931 setPreferenceProperty( xv, "step", 0.1 );
4932 setPreferenceProperty( xh, "min", 0.0 );
4933 setPreferenceProperty( xh, "max", 1.0 );
4934 setPreferenceProperty( xh, "step", 0.1 );
4935 setPreferenceProperty( yh, "min", 0.0 );
4936 setPreferenceProperty( yh, "max", 1.0 );
4937 setPreferenceProperty( yh, "step", 0.1 );
4938 setPreferenceProperty( wh, "min", 0.0 );
4939 setPreferenceProperty( wh, "max", 1.0 );
4940 setPreferenceProperty( wh, "step", 0.1 );
4941 setPreferenceProperty( hh, "min", 0.0 );
4942 setPreferenceProperty( hh, "max", 1.0 );
4943 setPreferenceProperty( hh, "step", 0.1 );
4945 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
4946 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
4947 setPreferenceProperty( distributionGr, "columns", 3 );
4949 types.append( tr( "SMESH_MONOCOLOR" ) );
4950 types.append( tr( "SMESH_MULTICOLOR" ) );
4951 indices.clear(); indices.append( 0 ); indices.append( 1 );
4952 setPreferenceProperty( coloringType, "strings", types );
4953 setPreferenceProperty( coloringType, "indexes", indices );
4954 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
4958 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
4960 if( sect=="SMESH" ) {
4961 float sbX1,sbY1,sbW,sbH;
4962 float aTol = 1.00000009999999;
4963 std::string aWarning;
4964 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4965 if( name=="selection_object_color" || name=="selection_element_color" ||
4966 name=="highlight_color" ||
4967 name=="selection_precision_node" || name=="selection_precision_element" ||
4968 name=="selection_precision_object")
4969 SMESH::UpdateSelectionProp( this );
4970 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
4971 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
4972 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
4973 if(sbX1+sbW > aTol){
4974 aWarning = "Origin and Size Vertical: X+Width > 1\n";
4977 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
4978 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
4981 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
4982 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
4983 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
4984 if(sbY1+sbH > aTol){
4985 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
4986 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
4987 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
4990 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
4991 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4992 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
4993 if(sbX1+sbW > aTol){
4994 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
4997 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4998 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5001 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5002 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5003 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5004 if(sbY1+sbH > aTol){
5005 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5008 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5009 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5012 else if ( name == "segmentation" ) {
5013 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5014 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5016 else if ( name == "nb_segments_per_edge" ) {
5017 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5018 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5020 else if ( name == "historical_python_dump" ||
5021 name == "forget_mesh_on_hyp_modif") {
5022 QString val = aResourceMgr->stringValue( "SMESH", name );
5023 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5026 if(aWarning.size() != 0){
5027 aWarning += "The default values are applied instead.";
5028 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5029 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5030 QObject::tr(aWarning.c_str()));
5035 //================================================================================
5037 * \brief Update something in accordance with update flags
5038 * \param theFlags - update flags
5040 * Update viewer or/and object browser etc. in accordance with update flags ( see
5041 * LightApp_UpdateFlags enumeration ).
5043 //================================================================================
5044 void SMESHGUI::update( const int flags )
5046 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5047 SMESH::UpdateView();
5049 SalomeApp_Module::update( flags );
5052 //================================================================================
5054 * \brief Set default selection mode
5056 * SLOT called when operation commited. Sets default selection mode
5058 //================================================================================
5059 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5061 SVTK_ViewWindow* vtkWnd =
5062 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5064 vtkWnd->SetSelectionMode( ActorSelection );
5067 //================================================================================
5069 * \brief Set default selection mode
5071 * SLOT called when operation aborted. Sets default selection mode
5073 //================================================================================
5074 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5076 SVTK_ViewWindow* vtkWnd =
5077 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5079 vtkWnd->SetSelectionMode( ActorSelection );
5082 //================================================================================
5084 * \brief Creates operation with given identifier
5085 * \param id - identifier of operation to be started
5086 * \return Pointer on created operation or NULL if operation is not created
5088 * Virtual method redefined from the base class creates operation with given id.
5089 * It is called called automatically from startOperation method of base class.
5091 //================================================================================
5092 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5094 LightApp_Operation* op = 0;
5095 // to do : create operation here
5098 case 417: //convert to quadratic
5099 op = new SMESHGUI_ConvToQuadOp();
5101 case 418: // create 2D mesh as boundary on 3D
5102 op = new SMESHGUI_Make2DFrom3DOp();
5104 case 420: // Reorient faces
5105 op = new SMESHGUI_ReorientFacesOp();
5107 case 701: // Compute mesh
5108 op = new SMESHGUI_ComputeOp();
5110 case 702: // Create mesh
5111 op = new SMESHGUI_MeshOp( true, true );
5113 case 703: // Create sub-mesh
5114 op = new SMESHGUI_MeshOp( true, false );
5116 case 704: // Edit mesh/sub-mesh
5117 op = new SMESHGUI_MeshOp( false );
5119 case 711: // Precompute mesh
5120 op = new SMESHGUI_PrecomputeOp();
5122 case 712: // Evaluate mesh
5123 op = new SMESHGUI_EvaluateOp();
5125 case 713: // Evaluate mesh
5126 op = new SMESHGUI_MeshOrderOp();
5128 case 806: // Create group on geom
5129 op = new SMESHGUI_GroupOnShapeOp();
5131 case 904: // Find element
5132 op = new SMESHGUI_FindElemByPointOp();
5134 case 4067: // make mesh pass through point
5135 op = new SMESHGUI_MakeNodeAtPointOp();
5142 op = SalomeApp_Module::createOperation( id );
5146 //================================================================================
5148 * \brief Stops current operations and starts a given one
5149 * \param id - The id of the operation to start
5151 //================================================================================
5153 void SMESHGUI::switchToOperation(int id)
5155 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5156 activeStudy()->abortAllOperations();
5157 startOperation( id );
5160 LightApp_Displayer* SMESHGUI::displayer()
5163 myDisplayer = new SMESHGUI_Displayer( getApp() );
5167 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5170 int aTolerance = 64;
5171 int anIterations = 0;
5177 if( anIterations % aPeriod == 0 )
5180 if( aTolerance < 1 )
5184 aHue = (int)( 360.0 * rand() / RAND_MAX );
5187 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5188 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5189 for( ; it != itEnd; ++it )
5191 SALOMEDS::Color anAutoColor = *it;
5192 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5195 aQColor.getHsv( &h, &s, &v );
5196 if( abs( h - aHue ) < aTolerance )
5208 aColor.setHsv( aHue, 255, 255 );
5210 SALOMEDS::Color aSColor;
5211 aSColor.R = aColor.redF();
5212 aSColor.G = aColor.greenF();
5213 aSColor.B = aColor.blueF();
5218 const char gSeparator = '_'; // character used to separate parameter names
5219 const char gDigitsSep = ':'; // character used to separate numeric parameter values (color = r:g:b)
5220 const char gPathSep = '|'; // character used to separate paths
5223 * \brief Store visual parameters
5225 * This method is called just before the study document is saved.
5226 * Store visual parameters in AttributeParameter attribue(s)
5228 void SMESHGUI::storeVisualParameters (int savePoint)
5230 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5231 if (!appStudy || !appStudy->studyDS())
5233 _PTR(Study) studyDS = appStudy->studyDS();
5235 // componentName is used for encoding of entries when storing them in IParameters
5236 std::string componentName = myComponentSMESH->ComponentDataType();
5237 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5238 //if (!aSComponent) return;
5241 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5242 componentName.c_str(),
5244 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5246 // store map of custom markers
5247 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5248 if( !aMarkerMap.empty() )
5250 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5251 for( ; anIter != aMarkerMap.end(); anIter++ )
5253 int anId = anIter->first;
5254 VTK::MarkerData aMarkerData = anIter->second;
5255 std::string aMarkerFileName = aMarkerData.first;
5256 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5257 if( aMarkerTexture.size() < 3 )
5258 continue; // should contain at least width, height and the first value
5260 QString aPropertyName( "texture" );
5261 aPropertyName += gSeparator;
5262 aPropertyName += QString::number( anId );
5264 QString aPropertyValue = aMarkerFileName.c_str();
5265 aPropertyValue += gPathSep;
5267 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5268 ushort aWidth = *aTextureIter++;
5269 ushort aHeight = *aTextureIter++;
5270 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5271 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5272 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5273 aPropertyValue += QString::number( *aTextureIter );
5275 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5279 // viewers counters are used for storing view_numbers in IParameters
5282 // main cycle to store parameters of displayed objects
5283 QList<SUIT_ViewManager*> lst;
5284 QList<SUIT_ViewManager*>::Iterator it;
5285 getApp()->viewManagers(lst);
5286 for (it = lst.begin(); it != lst.end(); it++)
5288 SUIT_ViewManager* vman = *it;
5289 QString vType = vman->getType();
5291 // saving VTK actors properties
5292 if (vType == SVTK_Viewer::Type())
5294 // store the clipping planes attached to the view manager
5295 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5296 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5297 if( anIter != myClippingPlaneInfoMap.end() )
5298 aClippingPlaneInfoList = anIter->second;
5300 if( !aClippingPlaneInfoList.empty() ) {
5301 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5302 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5304 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5305 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5307 QString aPropertyName( "ClippingPlane" );
5308 aPropertyName += gSeparator;
5309 aPropertyName += QString::number( vtkViewers );
5310 aPropertyName += gSeparator;
5311 aPropertyName += QString::number( anId );
5313 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5314 aPropertyValue += gDigitsSep;
5315 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5316 aPropertyValue += gDigitsSep;
5317 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5318 aPropertyValue += gDigitsSep;
5319 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5321 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5325 QVector<SUIT_ViewWindow*> views = vman->getViews();
5326 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5328 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5330 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5331 vtkActorCollection* allActors = aCopy.GetActors();
5332 allActors->InitTraversal();
5333 while (vtkActor* actor = allActors->GetNextActor())
5335 if (actor->GetVisibility()) // store only visible actors
5337 SMESH_Actor* aSmeshActor = 0;
5338 if (actor->IsA("SMESH_Actor"))
5339 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5340 if (aSmeshActor && aSmeshActor->hasIO())
5342 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5345 // entry is "encoded" = it does NOT contain component adress,
5346 // since it is a subject to change on next component loading
5347 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5349 std::string param, vtkParam = vType.toLatin1().data();
5350 vtkParam += gSeparator;
5351 vtkParam += QString::number(vtkViewers).toLatin1().data();
5352 vtkParam += gSeparator;
5355 param = vtkParam + "Visibility";
5356 ip->setParameter(entry, param, "On");
5359 param = vtkParam + "Representation";
5360 ip->setParameter(entry, param, QString::number
5361 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5364 param = vtkParam + "IsShrunk";
5365 ip->setParameter(entry, param, QString::number
5366 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5368 // Displayed entities
5369 unsigned int aMode = aSmeshActor->GetEntityMode();
5370 bool isE = aMode & SMESH_Actor::eEdges;
5371 bool isF = aMode & SMESH_Actor::eFaces;
5372 bool isV = aMode & SMESH_Actor::eVolumes;
5374 QString modeStr ("e");
5375 modeStr += gDigitsSep; modeStr += QString::number(isE);
5376 modeStr += gDigitsSep; modeStr += "f";
5377 modeStr += gDigitsSep; modeStr += QString::number(isF);
5378 modeStr += gDigitsSep; modeStr += "v";
5379 modeStr += gDigitsSep; modeStr += QString::number(isV);
5381 param = vtkParam + "Entities";
5382 ip->setParameter(entry, param, modeStr.toLatin1().data());
5384 // Colors (surface:edge:)
5385 vtkFloatingPointType r, g, b;
5388 aSmeshActor->GetSufaceColor(r, g, b, delta);
5389 QString colorStr ("surface");
5390 colorStr += gDigitsSep; colorStr += QString::number(r);
5391 colorStr += gDigitsSep; colorStr += QString::number(g);
5392 colorStr += gDigitsSep; colorStr += QString::number(b);
5394 colorStr += gDigitsSep; colorStr += "backsurface";
5395 colorStr += gDigitsSep; colorStr += QString::number(delta);
5398 aSmeshActor->GetEdgeColor(r, g, b);
5399 colorStr += gDigitsSep; colorStr += "edge";
5400 colorStr += gDigitsSep; colorStr += QString::number(r);
5401 colorStr += gDigitsSep; colorStr += QString::number(g);
5402 colorStr += gDigitsSep; colorStr += QString::number(b);
5404 aSmeshActor->GetNodeColor(r, g, b);
5405 colorStr += gDigitsSep; colorStr += "node";
5406 colorStr += gDigitsSep; colorStr += QString::number(r);
5407 colorStr += gDigitsSep; colorStr += QString::number(g);
5408 colorStr += gDigitsSep; colorStr += QString::number(b);
5410 aSmeshActor->GetOutlineColor(r, g, b);
5411 colorStr += gDigitsSep; colorStr += "outline";
5412 colorStr += gDigitsSep; colorStr += QString::number(r);
5413 colorStr += gDigitsSep; colorStr += QString::number(g);
5414 colorStr += gDigitsSep; colorStr += QString::number(b);
5416 param = vtkParam + "Colors";
5417 ip->setParameter(entry, param, colorStr.toLatin1().data());
5419 // Sizes of lines and points
5420 QString sizeStr ("line");
5421 sizeStr += gDigitsSep; sizeStr += QString::number((int)aSmeshActor->GetLineWidth());
5422 sizeStr += gDigitsSep; sizeStr += "shrink";
5423 sizeStr += gDigitsSep; sizeStr += QString::number(aSmeshActor->GetShrinkFactor());
5425 param = vtkParam + "Sizes";
5426 ip->setParameter(entry, param, sizeStr.toLatin1().data());
5431 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5432 if( aMarkerType == VTK::MT_USER ) {
5433 markerStr += "custom";
5434 markerStr += gDigitsSep;
5435 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5439 markerStr += gDigitsSep;
5440 markerStr += QString::number( (int)aMarkerType );
5441 markerStr += gDigitsSep;
5442 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5445 param = vtkParam + "PointMarker";
5446 ip->setParameter(entry, param, markerStr.toLatin1().data());
5449 param = vtkParam + "Opacity";
5450 ip->setParameter(entry, param,
5451 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5454 param = vtkParam + "ClippingPlane";
5456 if( !aClippingPlaneInfoList.empty() ) {
5457 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5458 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5460 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5461 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5462 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5463 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5464 if( aSmeshActor == *anIter2 ) {
5465 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5466 QString::number( anId ).toLatin1().constData() );
5473 ip->setParameter( entry, param, "Off" );
5474 } // if (io->hasEntry())
5475 } // SMESH_Actor && hasIO
5477 } // while.. actors traversal
5481 } // if (SVTK view model)
5482 } // for (viewManagers)
5485 // data structures for clipping planes processing
5488 vtkIdType Orientation;
5489 vtkFloatingPointType Distance;
5490 vtkFloatingPointType Angle[2];
5492 typedef std::list<TPlaneData> TPlaneDataList;
5493 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5495 typedef std::list<vtkActor*> TActorList;
5498 TActorList ActorList;
5499 SUIT_ViewManager* ViewManager;
5501 typedef std::list<TPlaneInfo> TPlaneInfoList;
5502 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5505 * \brief Restore visual parameters
5507 * This method is called after the study document is opened.
5508 * Restore visual parameters from AttributeParameter attribue(s)
5510 void SMESHGUI::restoreVisualParameters (int savePoint)
5512 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5513 if (!appStudy || !appStudy->studyDS())
5515 _PTR(Study) studyDS = appStudy->studyDS();
5517 // componentName is used for encoding of entries when storing them in IParameters
5518 std::string componentName = myComponentSMESH->ComponentDataType();
5519 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5520 //if (!aSComponent) return;
5523 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5524 componentName.c_str(),
5526 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5528 // restore map of custom markers and map of clipping planes
5529 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5530 TPlaneDataMap aPlaneDataMap;
5532 std::vector<std::string> properties = ip->getProperties();
5533 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5535 std::string property = *propIt;
5536 QString aPropertyName( property.c_str() );
5537 QString aPropertyValue( ip->getProperty( property ).c_str() );
5539 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5540 if( aPropertyNameList.isEmpty() )
5543 QString aPropertyType = aPropertyNameList[0];
5544 if( aPropertyType == "texture" )
5546 if( aPropertyNameList.size() != 2 )
5550 int anId = aPropertyNameList[1].toInt( &ok );
5551 if( !ok || anId < 1 )
5554 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5555 if( aPropertyValueList.size() != 2 )
5558 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5559 QString aMarkerTextureString = aPropertyValueList[1];
5560 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5561 if( aMarkerTextureStringList.size() != 3 )
5565 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5570 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5574 VTK::MarkerTexture aMarkerTexture;
5575 aMarkerTexture.push_back( aWidth );
5576 aMarkerTexture.push_back( aHeight );
5578 QString aMarkerTextureData = aMarkerTextureStringList[2];
5579 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5581 QChar aChar = aMarkerTextureData.at( i );
5582 if( aChar.isDigit() )
5583 aMarkerTexture.push_back( aChar.digitValue() );
5586 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5588 else if( aPropertyType == "ClippingPlane" )
5590 if( aPropertyNameList.size() != 3 )
5594 int aViewId = aPropertyNameList[1].toInt( &ok );
5595 if( !ok || aViewId < 0 )
5599 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5600 if( !ok || aClippingPlaneId < 0 )
5603 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5604 if( aPropertyValueList.size() != 4 )
5607 TPlaneData aPlaneData;
5608 aPlaneData.Id = aClippingPlaneId;
5611 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5616 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5621 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5626 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5630 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5631 aPlaneDataList.push_back( aPlaneData );
5635 TPlaneInfoMap aPlaneInfoMap;
5637 std::vector<std::string> entries = ip->getEntries();
5639 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5641 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5642 QString entry (ip->decodeEntry(*entIt).c_str());
5644 // Check that the entry corresponds to a real object in the Study
5645 // as the object may be deleted or modified after the visual state is saved.
5646 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5647 if (!so) continue; //Skip the not existent entry
5649 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5650 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5652 std::vector<std::string>::iterator namesIt = paramNames.begin();
5653 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5655 // actors are stored in a map after displaying of them for
5656 // quicker access in the future: map < viewID to actor >
5657 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5659 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5661 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5662 // '_' is used as separator and should not be used in viewer type or parameter names.
5663 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5664 if (lst.size() != 3)
5667 QString viewerTypStr = lst[0];
5668 QString viewIndexStr = lst[1];
5669 QString paramNameStr = lst[2];
5672 int viewIndex = viewIndexStr.toUInt(&ok);
5673 if (!ok) // bad conversion of view index to integer
5677 if (viewerTypStr == SVTK_Viewer::Type())
5679 SMESH_Actor* aSmeshActor = 0;
5680 if (vtkActors.IsBound(viewIndex))
5681 aSmeshActor = vtkActors.Find(viewIndex);
5683 QList<SUIT_ViewManager*> lst;
5684 getApp()->viewManagers(viewerTypStr, lst);
5686 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5687 SUIT_ViewManager* vman = NULL;
5688 if (viewIndex >= 0 && viewIndex < lst.count())
5689 vman = lst.at(viewIndex);
5691 if (paramNameStr == "Visibility")
5693 if (!aSmeshActor && displayer() && vman)
5695 SUIT_ViewModel* vmodel = vman->getViewModel();
5696 // SVTK view model can be casted to SALOME_View
5697 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5699 // store displayed actor in a temporary map for quicker
5700 // access later when restoring other parameters
5701 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5702 vtkRenderer* Renderer = vtkView->getRenderer();
5703 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5704 vtkActorCollection* theActors = aCopy.GetActors();
5705 theActors->InitTraversal();
5706 bool isFound = false;
5707 vtkActor *ac = theActors->GetNextActor();
5708 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5709 if (ac->IsA("SMESH_Actor")) {
5710 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5711 if (aGeomAc->hasIO()) {
5712 Handle(SALOME_InteractiveObject) io =
5713 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5714 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5716 vtkActors.Bind(viewIndex, aGeomAc);
5722 } // if (paramNameStr == "Visibility")
5725 // the rest properties "work" with SMESH_Actor
5728 QString val ((*valuesIt).c_str());
5731 if (paramNameStr == "Representation") {
5732 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5735 else if (paramNameStr == "IsShrunk") {
5737 if (!aSmeshActor->IsShrunk())
5738 aSmeshActor->SetShrink();
5741 if (aSmeshActor->IsShrunk())
5742 aSmeshActor->UnShrink();
5745 // Displayed entities
5746 else if (paramNameStr == "Entities") {
5747 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5748 if (mode.count() == 6) {
5749 if (mode[0] != "e" || mode[2] != "f" || mode[4] != "v") {
5750 MESSAGE("Invalid order of data in Entities, must be: "
5751 "e:0/1:f:0/1:v:0/1");
5754 unsigned int aMode = aSmeshActor->GetEntityMode();
5755 unsigned int aNewMode =
5756 (int(SMESH_Actor::eEdges ) * mode[1].toInt()) |
5757 (int(SMESH_Actor::eFaces ) * mode[3].toInt()) |
5758 (int(SMESH_Actor::eVolumes) * mode[5].toInt());
5759 if (aNewMode != aMode)
5760 aSmeshActor->SetEntityMode(aNewMode);
5765 else if (paramNameStr == "Colors") {
5766 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5767 if (colors.count() == 16 || colors.count() == 18 ) {
5768 if (colors[0] != "surface" || colors[4] != "backsurface" ||
5769 (colors[8] != "edge" && colors[6] != "edge" ) || (colors[12] != "node" && colors[10] != "node") ||
5770 (colors.count() == 18 && colors[14] != "outline")) {
5771 MESSAGE("Invalid order of data in Colors, must be: "
5772 "surface:r:g:b:backsurface:r:g:b:edge:r:g:b:node:r:g:b or surface:r:g:b:backsurface:delta:edge:r:g:b:node:r:g:b:outline:r:g:b");
5778 vtkFloatingPointType otr,otg,otb;
5779 //Old case backsurface color is independent
5780 if( colors.count() == 16 ) {
5782 SMESH::GetColor( "SMESH", "fill_color", ffc, delta, "0,170,255|-100" ) ;
5783 er = colors[9].toFloat();
5784 eg = colors[10].toFloat();
5785 eb = colors[11].toFloat();
5787 nr = colors[13].toFloat();
5788 ng = colors[14].toFloat();
5789 nb = colors[15].toFloat();
5790 SMESH::GetColor("SMESH", "outline_color", otr, otg, otb, QColor( 0, 70, 0 ) );
5792 //New case backsurface color depends on surface color
5793 delta = colors[5].toInt();
5795 er = colors[7].toFloat();
5796 eg = colors[8].toFloat();
5797 eb = colors[9].toFloat();
5799 nr = colors[11].toFloat();
5800 ng = colors[12].toFloat();
5801 nb = colors[13].toFloat();
5803 otr = colors[15].toFloat();
5804 otg = colors[16].toFloat();
5805 otb = colors[17].toFloat();
5807 aSmeshActor->SetSufaceColor(colors[1].toFloat(), colors[2].toFloat(), colors[3].toFloat(), delta);
5808 aSmeshActor->SetEdgeColor(er,eg,eb);
5809 aSmeshActor->SetNodeColor(nr,ng,nb);
5810 aSmeshActor->SetOutlineColor(otr,otg,otb);
5814 // Sizes of lines and points
5815 else if (paramNameStr == "Sizes") {
5816 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
5817 if (sizes.count() == 4) {
5818 if (sizes[0] != "line" || sizes[2] != "shrink") {
5819 MESSAGE("Invalid order of data in Sizes, must be: "
5820 "line:int:shrink:float");
5823 aSmeshActor->SetLineWidth(sizes[1].toInt());
5824 aSmeshActor->SetShrinkFactor(sizes[3].toFloat());
5827 else if (sizes.count() == 6) { // just to support old format
5828 if (sizes[0] != "line" || sizes[2] != "node" || sizes[4] != "shrink") {
5829 MESSAGE("Invalid order of data in Sizes, must be: "
5830 "line:int:node:int:shrink:float");
5833 aSmeshActor->SetLineWidth(sizes[1].toInt());
5834 //aSmeshActor->SetNodeSize(sizes[3].toInt()); // made obsolete
5835 aSmeshActor->SetShrinkFactor(sizes[5].toFloat());
5840 else if (paramNameStr == "PointMarker") {
5841 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
5842 if( data.count() >= 2 ) {
5844 int aParam1 = data[1].toInt( &ok );
5846 if( data[0] == "std" && data.count() == 3 ) {
5847 int aParam2 = data[2].toInt( &ok );
5848 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
5850 else if( data[0] == "custom" ) {
5851 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
5852 if( markerIt != aMarkerMap.end() ) {
5853 VTK::MarkerData aMarkerData = markerIt->second;
5854 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
5861 else if (paramNameStr == "Opacity") {
5862 aSmeshActor->SetOpacity(val.toFloat());
5865 else if (paramNameStr.startsWith("ClippingPlane")) {
5866 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
5867 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
5868 // new format - val looks like "Off" or "0" (plane id)
5869 // (note: in new format "Off" value is used only for consistency,
5870 // so it is processed together with values in old format)
5871 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
5872 if( anIsOldFormat ) {
5873 if (paramNameStr == "ClippingPlane1" || val == "Off")
5874 aSmeshActor->RemoveAllClippingPlanes();
5876 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
5877 double aDistance = vals[1].toFloat();
5878 vtkFloatingPointType anAngle[2];
5879 anAngle[0] = vals[2].toFloat();
5880 anAngle[1] = vals[3].toFloat();
5882 QList<SUIT_ViewManager*> lst;
5883 getApp()->viewManagers(viewerTypStr, lst);
5884 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5885 if (viewIndex >= 0 && viewIndex < lst.count()) {
5886 SUIT_ViewManager* vman = lst.at(viewIndex);
5887 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5889 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
5891 SMESH::TActorList anActorList;
5892 anActorList.push_back( aSmeshActor );
5893 SMESH::OrientedPlane* aPlane =
5894 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
5896 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5897 aClippingPlaneInfo.Plane = aPlane;
5898 aClippingPlaneInfo.ActorList = anActorList;
5899 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5906 int aPlaneId = val.toInt( &ok );
5907 if( ok && aPlaneId >= 0 ) {
5908 bool anIsDefinedPlane = false;
5909 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
5910 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
5911 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5912 TPlaneInfo& aPlaneInfo = *anIter;
5913 if( aPlaneInfo.PlaneId == aPlaneId ) {
5914 aPlaneInfo.ActorList.push_back( aSmeshActor );
5915 anIsDefinedPlane = true;
5919 if( !anIsDefinedPlane ) {
5920 TPlaneInfo aPlaneInfo;
5921 aPlaneInfo.PlaneId = aPlaneId;
5922 aPlaneInfo.ActorList.push_back( aSmeshActor );
5923 aPlaneInfo.ViewManager = vman;
5925 // to make the list sorted by plane id
5926 anIter = aPlaneInfoList.begin();
5927 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5928 const TPlaneInfo& aPlaneInfoRef = *anIter;
5929 if( aPlaneInfoRef.PlaneId > aPlaneId )
5932 aPlaneInfoList.insert( anIter, aPlaneInfo );
5937 } // if (aSmeshActor)
5938 } // other parameters than Visibility
5940 } // for names/parameters iterator
5941 } // for entries iterator
5943 // take into account planes with empty list of actors referred to them
5944 QList<SUIT_ViewManager*> aVMList;
5945 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
5947 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
5948 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
5949 int aViewId = aPlaneDataIter->first;
5950 if( aViewId >= 0 && aViewId < aVMList.count() ) {
5951 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
5953 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
5955 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
5956 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
5957 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
5958 const TPlaneData& aPlaneData = *anIter2;
5959 int aPlaneId = aPlaneData.Id;
5961 bool anIsFound = false;
5962 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5963 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5964 const TPlaneInfo& aPlaneInfo = *anIter3;
5965 if( aPlaneInfo.PlaneId == aPlaneId ) {
5972 TPlaneInfo aPlaneInfo; // ActorList field is empty
5973 aPlaneInfo.PlaneId = aPlaneId;
5974 aPlaneInfo.ViewManager = aViewManager;
5976 // to make the list sorted by plane id
5977 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
5978 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
5979 const TPlaneInfo& aPlaneInfoRef = *anIter4;
5980 if( aPlaneInfoRef.PlaneId > aPlaneId )
5983 aPlaneInfoList.insert( anIter4, aPlaneInfo );
5989 // add clipping planes to actors according to the restored parameters
5990 // and update the clipping plane map
5991 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
5992 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
5993 int aViewId = anIter1->first;
5994 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
5996 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
5997 if( anIter2 == aPlaneDataMap.end() )
5999 const TPlaneDataList& aPlaneDataList = anIter2->second;
6001 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6002 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6003 const TPlaneInfo& aPlaneInfo = *anIter3;
6004 int aPlaneId = aPlaneInfo.PlaneId;
6005 const TActorList& anActorList = aPlaneInfo.ActorList;
6006 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6010 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6014 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6016 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6017 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6018 const TPlaneData& aPlaneData = *anIter4;
6019 if( aPlaneData.Id == aPlaneId ) {
6020 SMESH::OrientedPlane* aPlane =
6021 SMESHGUI_ClippingDlg::AddPlane( anActorList,
6023 (SMESH::Orientation)aPlaneData.Orientation,
6024 aPlaneData.Distance,
6027 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6028 aClippingPlaneInfo.Plane = aPlane;
6029 aClippingPlaneInfo.ActorList = anActorList;
6030 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6038 // update all VTK views
6039 QList<SUIT_ViewManager*> lst;
6040 getApp()->viewManagers(lst);
6041 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6042 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6043 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6044 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6045 vtkView->getRenderer()->ResetCameraClippingRange();
6052 \brief Adds preferences for dfont of VTK viewer
6054 \param pIf group identifier
6055 \param param parameter
6056 \return identifier of preferences
6058 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
6060 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6062 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6065 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6066 fam.append( tr( "SMESH_FONT_COURIER" ) );
6067 fam.append( tr( "SMESH_FONT_TIMES" ) );
6069 setPreferenceProperty( tfont, "fonts", fam );
6071 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6072 setPreferenceProperty( tfont, "features", f );
6078 \brief Actions after hypothesis edition
6079 Updates object browser after hypothesis edition
6081 void SMESHGUI::onHypothesisEdit( int result )
6084 SMESHGUI::Modified();
6085 updateObjBrowser( true );
6090 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6091 \param pview view being closed
6093 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6094 #ifndef DISABLE_PLOT2DVIEWER
6095 //Crear all Plot2d Viewers if need.
6096 SMESH::ClearPlot2Viewers(pview);
6100 void SMESHGUI::message( const QString& msg )
6103 QStringList data = msg.split("/");
6104 if ( data.count() > 0 ) {
6105 if ( data.first() == "mesh_loading" ) {
6107 QString entry = data.count() > 1 ? data[1] : QString();
6108 if ( entry.isEmpty() )
6111 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6113 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6116 name = obj->GetName().c_str();
6117 if ( name.isEmpty() )
6120 if ( data.last() == "stop" )
6121 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6123 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6124 QApplication::processEvents();
6130 \brief Connects or disconnects signals about activating and cloning view on the module slots
6131 \param pview view which is connected/disconnected
6133 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6137 SUIT_ViewManager* viewMgr = pview->getViewManager();
6139 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6140 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6142 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6143 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6148 \brief Return \c true if object can be renamed
6150 bool SMESHGUI::renameAllowed( const QString& entry) const {
6151 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6155 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6159 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6164 if(appStudy->isComponent(entry) || obj->isReference())
6167 // check type to prevent renaming of inappropriate objects
6168 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6169 if (aType == MESH || aType == GROUP ||
6170 aType == SUBMESH || aType == SUBMESH_COMPOUND ||
6171 aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
6172 aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
6173 aType == HYPOTHESIS || aType == ALGORITHM)
6180 Rename object by entry.
6181 \param entry entry of the object
6182 \param name new name of the object
6183 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6185 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6187 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6191 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6196 _PTR(Study) aStudy = appStudy->studyDS();
6201 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6203 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6208 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6209 _PTR(GenericAttribute) anAttr;
6210 _PTR(AttributeName) aName;
6212 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6214 // check type to prevent renaming of inappropriate objects
6215 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6216 if (aType == MESH || aType == GROUP ||
6217 aType == SUBMESH || aType == SUBMESH_COMPOUND ||
6218 aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
6219 aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
6220 aType == HYPOTHESIS || aType == ALGORITHM) {
6221 if ( !name.isEmpty() ) {
6222 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6224 // update name of group object and its actor
6225 Handle(SALOME_InteractiveObject) IObject =
6226 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6228 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6229 if( !aGroupObject->_is_nil() ) {
6230 aGroupObject->SetName( qPrintable(name) );
6231 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6232 anActor->setName( qPrintable(name) );