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 #include <Basics_Utils.hxx>
170 //To disable automatic genericobj management, the following line should be commented.
171 //Otherwise, it should be uncommented. Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
172 #define WITHGENERICOBJ
176 //=============================================================
177 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
180 void ExportMeshToFile(int theCommandID);
182 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
184 void SetDisplayEntity(int theCommandID);
186 void Control( int theCommandID );
190 //=============================================================
191 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
195 std::string myExtension;
197 if ( theCommandID == 113 ) {
198 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.med)" );
199 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
201 else if ( theCommandID == 112 ) {
202 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
204 else if ( theCommandID == 111 ) {
205 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
207 else if ( theCommandID == 115 ) {
208 filter.append( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
210 else if ( theCommandID == 116 ) {
211 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
213 else if ( theCommandID == 117 ) {
214 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
215 filter.append( QObject::tr( "All files (*)" ) );
217 else if ( theCommandID == 118 ) {
218 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
219 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
222 QString anInitialPath = "";
223 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
224 anInitialPath = QDir::currentPath();
226 QStringList filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
229 QObject::tr( "SMESH_IMPORT_MESH" ) );
230 if ( filenames.count() > 0 ) {
231 SUIT_OverrideCursor wc;
232 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
235 QStringList anEntryList;
236 bool isEmpty = false;
237 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
238 QString filename = *it;
239 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
241 switch ( theCommandID ) {
244 // DAT format (currently unsupported)
245 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
246 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
252 aMeshes->length( 1 );
253 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toLatin1().constData() );
254 if ( aMeshes[0]->_is_nil() )
255 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
256 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
262 SMESH::DriverMED_ReadStatus res;
263 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toLatin1().constData(), res );
264 if ( res != SMESH::DRS_OK ) {
265 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
266 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
273 aMeshes->length( 1 );
274 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toLatin1().constData() );
275 if ( aMeshes[0]->_is_nil() ) {
276 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
277 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
284 SMESH::DriverMED_ReadStatus res;
285 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toLatin1().constData(), res );
286 if ( res != SMESH::DRS_OK ) {
287 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
288 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
295 SMESH::DriverMED_ReadStatus res;
296 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toLatin1().constData(), res );
297 if ( res != SMESH::DRS_OK ) {
298 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
299 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
306 SMESH::ComputeError_var res;
307 aMeshes->length( 1 );
308 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toLatin1().constData(), res.out() );
309 if ( res->code != SMESH::DRS_OK ) {
310 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
311 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
312 if ( strlen( res->comment.in() ) > 0 ) {
313 errors.back() += ": ";
314 errors.back() += res->comment.in();
321 catch ( const SALOME::SALOME_Exception& S_ex ) {
322 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
323 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
326 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
327 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
329 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
330 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
331 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
332 if ( theCommandID == 112 ) // mesh names aren't taken from the file for UNV import
333 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
335 anEntryList.append( aMeshSO->GetID().c_str() );
337 #ifdef WITHGENERICOBJ
338 // obj has been published in study. Its refcount has been incremented.
339 // It is safe to decrement its refcount
340 // so that it will be destroyed when the entry in study will be removed
341 aMeshes[i]->UnRegister();
350 // update Object browser
351 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
353 // browse to the published meshes
354 if( LightApp_Application* anApp =
355 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
356 anApp->browseObjects( anEntryList );
358 // show Error message box if there were errors
359 if ( errors.count() > 0 ) {
360 SUIT_MessageBox::critical( SMESHGUI::desktop(),
361 QObject::tr( "SMESH_ERROR" ),
362 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
365 // show warning message box, if some imported mesh is empty
367 SUIT_MessageBox::warning( SMESHGUI::desktop(),
368 QObject::tr( "SMESH_WRN_WARNING" ),
369 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
374 //================================================================================
376 * \brief Export selected meshes or groups into a file
378 //================================================================================
380 void ExportMeshToFile( int theCommandID )
382 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
383 SALOME_ListIO selected;
385 aSel->selectedObjects( selected );
387 const bool isMED = ( theCommandID == 122 || theCommandID == 125 );
388 const bool isDAT = ( theCommandID == 121 || theCommandID == 124 );
389 const bool isUNV = ( theCommandID == 123 || theCommandID == 126 );
390 const bool isSTL = ( theCommandID == 140 || theCommandID == 141 );
391 const bool isCGNS= ( theCommandID == 142 || theCommandID == 143 );
392 const bool isSAUV= ( theCommandID == 144 || theCommandID == 145 );
393 const bool isGMF = ( theCommandID == 146 || theCommandID == 147 );
395 // actually, the following condition can't be met (added for insurance)
396 if( selected.Extent() == 0 ||
397 ( selected.Extent() > 1 && !isMED && !isSTL ))
400 // get mesh object from selection and check duplication of their names
401 bool hasDuplicatedMeshNames = false;
402 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
403 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
404 SALOME_ListIteratorOfListIO It( selected );
405 for( ; It.More(); It.Next() )
407 Handle(SALOME_InteractiveObject) anIObject = It.Value();
408 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
409 if ( aMeshItem->_is_nil() ) {
410 SUIT_MessageBox::warning( SMESHGUI::desktop(),
411 QObject::tr( "SMESH_WRN_WARNING" ),
412 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
416 QString aMeshName = anIObject->getName();
418 // check for name duplications
419 if ( !hasDuplicatedMeshNames )
420 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
421 if( aMeshName == (*aMeshIter).second ) {
422 hasDuplicatedMeshNames = true;
427 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
430 if( hasDuplicatedMeshNames && isMED ) {
431 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
432 QObject::tr("SMESH_WRN_WARNING"),
433 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
434 QObject::tr("SMESH_BUT_YES"),
435 QObject::tr("SMESH_BUT_NO"), 0, 1);
440 aMeshIter = aMeshList.begin();
441 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
442 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
443 QString aMeshName = (*aMeshIter).second;
445 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
447 // check for equal group names within each mesh
448 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
449 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
450 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
451 int aRet = SUIT_MessageBox::warning
452 (SMESHGUI::desktop(),
453 QObject::tr("SMESH_WRN_WARNING"),
454 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
455 QObject::tr("SMESH_BUT_YES"),
456 QObject::tr("SMESH_BUT_NO"), 0, 1);
463 // Warn the user about presence of not supported elements
465 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
469 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Quadrangle );
470 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
471 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
472 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
473 notSupportedElemTypes.push_back( SMESH::Entity_Tetra );
474 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Tetra );
475 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
476 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
477 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Hexa );
478 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
479 notSupportedElemTypes.push_back( SMESH::Entity_Penta );
480 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
481 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
482 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
483 notSupportedElemTypes.push_back( SMESH::Entity_0D );
484 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
489 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
490 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
491 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
492 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
493 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
494 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
495 notSupportedElemTypes.push_back( SMESH::Entity_0D );
496 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
501 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
502 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
503 notSupportedElemTypes.push_back( SMESH::Entity_0D );
504 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
509 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
514 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
515 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
516 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
517 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
518 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
519 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
524 notSupportedElemTypes.push_back( SMESH::Entity_0D );
525 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Quadrangle );
526 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
527 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
528 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
529 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Hexa );
530 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
531 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
532 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
533 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
534 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
536 if ( ! notSupportedElemTypes.empty() )
538 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
539 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
540 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
541 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
543 if ( !presentNotSupported.empty() )
546 const char* typeMsg[SMESH::Entity_Last] = { "SMESH_NODES",
547 "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES","SMESH_TRIANGLES",
548 "SMESH_QUADRATIC_TRIANGLES","SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES",
549 "SMESH_BIQUADRATIC_QUADRANGLES","SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
550 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
551 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
552 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
553 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
555 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
556 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
557 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
558 if ( iType != presentNotSupported.size() - 1 )
559 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
561 int aRet = SUIT_MessageBox::warning
562 (SMESHGUI::desktop(),
563 QObject::tr("SMESH_WRN_WARNING"),
564 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
565 QObject::tr("SMESH_BUT_YES"),
566 QObject::tr("SMESH_BUT_NO"), 0, 1);
571 // Get parameters of export operation
574 SMESH::MED_VERSION aFormat;
575 // Init the parameters with the default values
576 bool aIsASCII_STL = true;
577 bool toCreateGroups = false;
578 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
580 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
581 bool toOverwrite = true;
583 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
584 QString anInitialPath = "";
585 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
586 anInitialPath = QDir::currentPath();
588 // Get a file name to write in and additional otions
589 if ( isUNV || isDAT || isGMF ) // Export w/o options
592 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
594 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
596 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
597 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
598 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
599 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
600 anInitialPath + QString("/") + aMeshName,
601 aFilter, aTitle, false);
603 else if ( isCGNS )// Export to CGNS
605 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
606 fd->setWindowTitle( aTitle );
607 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
608 if ( !anInitialPath.isEmpty() )
609 fd->setDirectory( anInitialPath );
610 fd->selectFile(aMeshName);
611 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
612 fd->setValidator( fv );
615 aFilename = fd->selectedFile();
616 toOverwrite = fv->isOverwrite();
620 else if ( isSTL ) // Export to STL
622 QMap<QString, int> aFilterMap;
623 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
624 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
627 QMap<QString, int>::const_iterator it = aFilterMap.begin();
628 for ( ; it != aFilterMap.end(); ++it )
629 filters.push_back( it.key() );
631 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
632 fd->setWindowTitle( aTitle );
633 fd->setNameFilters( filters );
634 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
635 if ( !anInitialPath.isEmpty() )
636 fd->setDirectory( anInitialPath );
637 fd->selectFile(aMeshName);
641 aFilename = fd->selectedFile();
642 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
647 else if ( isMED || isSAUV ) // Export to MED or SAUV
649 QMap<QString, SMESH::MED_VERSION> aFilterMap;
650 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
652 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
653 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
654 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
657 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
658 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
659 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
663 QString aDefaultFilter;
664 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
665 for ( ; it != aFilterMap.end(); ++it ) {
666 filters.push_back( it.key() );
667 if (it.value() == SMESH::MED_V2_2)
668 aDefaultFilter = it.key();
671 SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
672 ( SMESHGUI::desktop(), false, QObject::tr("SMESH_AUTO_GROUPS"), true, true );
673 fd->setWindowTitle( aTitle );
674 fd->setNameFilters( filters );
675 fd->selectNameFilter(aDefaultFilter);
676 fd->SetChecked(toCreateGroups);
677 if ( !anInitialPath.isEmpty() )
678 fd->setDirectory( anInitialPath );
679 fd->selectFile(aMeshName);
681 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
682 fd->setValidator( fv );
687 aFilename = fd->selectedFile();
689 aFilename = QString::null;
692 aFormat = aFilterMap[fd->selectedNameFilter()];
693 toOverwrite = fv->isOverwrite();
695 if ( !aFilename.isEmpty() ) {
696 // med-2.1 does not support poly elements
697 if ( aFormat==SMESH::MED_V2_1 )
698 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
699 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
700 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
701 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
702 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
704 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
705 QObject::tr("SMESH_WRN_WARNING"),
706 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
707 QObject::tr("SMESH_BUT_YES"),
708 QObject::tr("SMESH_BUT_NO"), 0, 1);
716 // can't append to an existing using other format
717 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
718 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toLatin1().constData(), aVersion );
719 if( !isVersionOk || aVersion != aFormat ) {
720 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
721 QObject::tr("SMESH_WRN_WARNING"),
722 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
723 QObject::tr("SMESH_BUT_YES"),
724 QObject::tr("SMESH_BUT_NO"), 0, 1);
731 QStringList aMeshNamesCollisionList;
732 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toLatin1().constData() );
733 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
734 QString anExistingMeshName( aMeshNames[ i ] );
735 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
736 QString anExportMeshName = (*aMeshIter).second;
737 if( anExportMeshName == anExistingMeshName ) {
738 aMeshNamesCollisionList.append( anExportMeshName );
743 if( !aMeshNamesCollisionList.isEmpty() ) {
744 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
745 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
746 QObject::tr("SMESH_WRN_WARNING"),
747 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
748 QObject::tr("SMESH_BUT_YES"),
749 QObject::tr("SMESH_BUT_NO"),
750 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
759 toCreateGroups = fd->IsChecked();
769 if ( !aFilename.isEmpty() ) {
770 // Check whether the file already exists and delete it if yes
771 QFile aFile( aFilename );
772 if ( aFile.exists() && toOverwrite )
774 SUIT_OverrideCursor wc;
777 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
778 // bool Renumber = false;
779 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
781 // Renumber= resMgr->booleanValue("renumbering");
783 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
784 // aMeshEditor->RenumberNodes();
785 // aMeshEditor->RenumberElements();
786 // if ( SMESHGUI::automaticUpdate() )
787 // SMESH::UpdateView();
791 aMeshIter = aMeshList.begin();
792 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
794 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
795 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
796 if ( aMeshOrGroup->_is_equivalent( aMeshItem ))
797 aMeshItem->ExportToMEDX( aFilename.toLatin1().data(), toCreateGroups,
798 aFormat, toOverwrite && aMeshIndex == 0 );
800 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups,
801 aFormat, toOverwrite && aMeshIndex == 0 );
806 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
808 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
809 if( !aMeshItem->_is_nil() )
810 aMeshItem->ExportSAUV( aFilename.toLatin1().data(), toCreateGroups );
815 if ( aMeshOrGroup->_is_equivalent( aMesh ))
816 aMesh->ExportDAT( aFilename.toLatin1().data() );
818 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toLatin1().data() );
822 if ( aMeshOrGroup->_is_equivalent( aMesh ))
823 aMesh->ExportUNV( aFilename.toLatin1().data() );
825 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toLatin1().data() );
829 if ( aMeshOrGroup->_is_equivalent( aMesh ))
830 aMesh->ExportSTL( aFilename.toLatin1().data(), aIsASCII_STL );
832 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toLatin1().data(), aIsASCII_STL );
836 aMeshIter = aMeshList.begin();
837 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
839 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
840 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
841 aMeshItem->ExportCGNS( aMeshOrGroup,
842 aFilename.toLatin1().data(),
843 toOverwrite && aMeshIndex == 0 );
848 aMesh->ExportGMF( aMeshOrGroup, aFilename.toLatin1().data() );
851 catch (const SALOME::SALOME_Exception& S_ex){
853 SUIT_MessageBox::warning(SMESHGUI::desktop(),
854 QObject::tr("SMESH_WRN_WARNING"),
855 QObject::tr("SMESH_EXPORT_FAILED"));
861 inline void InverseEntityMode(unsigned int& theOutputMode,
862 unsigned int theMode)
864 bool anIsNotPresent = ~theOutputMode & theMode;
866 theOutputMode |= theMode;
868 theOutputMode &= ~theMode;
871 void SetDisplayEntity(int theCommandID){
872 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
873 SALOME_ListIO selected;
875 aSel->selectedObjects( selected );
877 if(selected.Extent() >= 1){
878 SALOME_ListIteratorOfListIO It( selected );
879 for( ; It.More(); It.Next()){
880 Handle(SALOME_InteractiveObject) IObject = It.Value();
881 if(IObject->hasEntry()){
882 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
883 unsigned int aMode = anActor->GetEntityMode();
884 switch(theCommandID){
886 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
889 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
892 InverseEntityMode(aMode,SMESH_Actor::eEdges);
895 InverseEntityMode(aMode,SMESH_Actor::eFaces);
898 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
901 aMode = SMESH_Actor::eAllEntity;
905 anActor->SetEntityMode(aMode);
913 SALOME_ListIO selected;
914 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
918 LightApp_SelectionMgr* aSel = app->selectionMgr();
919 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
920 if( !aSel || !appStudy )
923 aSel->selectedObjects( selected );
924 if( selected.IsEmpty() )
927 Handle(SALOME_InteractiveObject) anIObject = selected.First();
929 _PTR(Study) aStudy = appStudy->studyDS();
930 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
931 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
932 if( aMainObject->_is_nil() )
935 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
937 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
938 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
940 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
941 SALOMEDS::Color aColor = aGroupObject->GetColor();
942 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
946 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
947 switch ( aGroupObject->GetType ()) {
949 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
951 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
953 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
955 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
957 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
958 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
961 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
962 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
968 SMESH::RepaintCurrentView();
971 QString functorToString( SMESH::Controls::FunctorPtr f )
973 QString type = QObject::tr( "UNKNOWN_CONTROL" );
974 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
975 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
976 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
977 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
978 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
979 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
980 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
981 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
982 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
983 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
984 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
985 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
986 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
987 type = QObject::tr( "WARP_ELEMENTS" );
988 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
989 type = QObject::tr( "TAPER_ELEMENTS" );
990 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
991 type = QObject::tr( "SKEW_ELEMENTS" );
992 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
993 type = QObject::tr( "AREA_ELEMENTS" );
994 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
995 type = QObject::tr( "LENGTH_EDGES" );
996 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
997 type = QObject::tr( "LENGTH2D_EDGES" );
998 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
999 type = QObject::tr( "MULTI_BORDERS" );
1000 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1001 type = QObject::tr( "MULTI2D_BORDERS" );
1002 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1003 type = QObject::tr( "FREE_NODES" );
1004 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1005 type = QObject::tr( "FREE_EDGES" );
1006 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1007 type = QObject::tr( "FREE_BORDERS" );
1008 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1009 type = QObject::tr( "FREE_FACES" );
1010 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1011 type = QObject::tr( "BARE_BORDER_VOLUME" );
1012 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1013 type = QObject::tr( "BARE_BORDER_FACE" );
1014 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1015 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1016 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1017 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1018 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1019 type = QObject::tr( "EQUAL_NODE" );
1020 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1021 type = QObject::tr( "EQUAL_EDGE" );
1022 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1023 type = QObject::tr( "EQUAL_FACE" );
1024 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1025 type = QObject::tr( "EQUAL_VOLUME" );
1029 void SaveDistribution()
1031 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1032 SALOME_ListIO selected;
1034 aSel->selectedObjects( selected );
1036 if ( selected.Extent() == 1 ) {
1037 Handle(SALOME_InteractiveObject) anIO = selected.First();
1038 if ( anIO->hasEntry() ) {
1039 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1040 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1041 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1042 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1043 if ( aScalarBarActor && aFunctor ) {
1044 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1046 std::vector<int> elements;
1047 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1048 if ( mesh->_is_nil() ) {
1049 SMESH::SMESH_IDSource_var idSource =
1050 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1051 if ( !idSource->_is_nil() )
1053 SMESH::long_array_var ids = idSource->GetIDs();
1054 elements.resize( ids->length() );
1055 for ( unsigned i = 0; i < elements.size(); ++i )
1056 elements[i] = ids[i];
1059 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1060 vtkLookupTable* lookupTable =
1061 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1062 double * minmax = lookupTable->GetRange();
1063 std::vector<int> nbEvents;
1064 std::vector<double> funValues;
1065 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax );
1066 QString anInitialPath = "";
1067 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1068 anInitialPath = QDir::currentPath();
1069 QString aMeshName = anIO->getName();
1071 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1072 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1073 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1074 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1075 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1078 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1080 if ( !aFilename.isEmpty() ) {
1081 QFile f( aFilename );
1082 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1083 QTextStream out( &f );
1084 out << "# Mesh: " << aMeshName << endl;
1085 out << "# Control: " << functorToString( aFunctor ) << endl;
1087 out.setFieldWidth( 10 );
1088 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1089 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1100 void ShowDistribution() {
1101 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1102 SALOME_ListIO selected;
1104 aSel->selectedObjects( selected );
1106 if ( selected.Extent() == 1 ) {
1107 Handle(SALOME_InteractiveObject) anIO = selected.First();
1108 if ( anIO->hasEntry() ) {
1109 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1110 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1111 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1112 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1118 #ifndef DISABLE_PLOT2DVIEWER
1119 void PlotDistribution() {
1120 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1124 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1125 SALOME_ListIO selected;
1127 aSel->selectedObjects( selected );
1129 if ( selected.Extent() == 1 ) {
1130 Handle(SALOME_InteractiveObject) anIO = selected.First();
1131 if ( anIO->hasEntry() ) {
1132 //Find Actor by entry before getting Plot2d viewer,
1133 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1134 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1136 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1141 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1145 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1149 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1150 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1151 QString functorName = functorToString( anActor->GetFunctor());
1152 QString aHistogramName("%1 : %2");
1153 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1154 aHistogram->setName(aHistogramName);
1155 aHistogram->setHorTitle(functorName);
1156 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1157 aPlot->displayObject(aHistogram, true);
1162 #endif //DISABLE_PLOT2DVIEWER
1164 void DisableAutoColor(){
1165 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1166 SALOME_ListIO selected;
1168 aSel->selectedObjects( selected );
1170 if(selected.Extent()){
1171 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1172 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1173 if ( !aMesh->_is_nil() ) {
1174 aMesh->SetAutoColor( false );
1179 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1181 SALOME_ListIO selected;
1182 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1186 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1187 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1188 if( !aSel || !appStudy )
1191 if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection
1192 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1193 aModule->EmitSignalDeactivateDialog();
1194 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1195 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1200 _PTR(Study) aStudy = appStudy->studyDS();
1202 aSel->selectedObjects( selected );
1204 if(selected.Extent() >= 1){
1205 switch(theCommandID){
1207 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1208 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1212 vtkFloatingPointType color[3];
1213 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1214 QColor orientationColor, outlineColor, volumeColor;
1215 int deltaF = 0, deltaV = 0;
1219 int outlineWidth = 1;
1220 vtkFloatingPointType shrinkCoef = 0.0;
1221 vtkFloatingPointType orientationScale = 0.0;
1222 bool orientation3d = false;
1223 VTK::MarkerType markerType = VTK::MT_NONE;
1224 VTK::MarkerScale markerScale = VTK::MS_NONE;
1226 bool hasNodes = false;
1227 int presentEntities = 0;
1228 bool firstTime = true;
1230 SALOME_ListIteratorOfListIO It( selected );
1231 for ( ; It.More(); It.Next() ) {
1232 Handle(SALOME_InteractiveObject) IObject = It.Value();
1233 if ( !IObject->hasEntry() ) continue;
1234 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1235 if ( !anActor || !anActor->GetObject() ) continue;
1238 // nodes: color, marker
1239 anActor->GetNodeColor( color[0], color[1], color[2] );
1240 nodeColor.setRgbF( color[0], color[1], color[2] );
1241 markerType = anActor->GetMarkerType();
1242 markerScale = anActor->GetMarkerScale();
1243 markerId = anActor->GetMarkerTexture();
1244 // edges: color, width
1245 anActor->GetEdgeColor( color[0], color[1], color[2] );
1246 edgeColor.setRgbF( color[0], color[1], color[2] );
1247 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1248 // faces: front color, back color (delta)
1249 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1250 faceColor.setRgbF( color[0], color[1], color[2] );
1251 // faces: front color, back color (delta)
1252 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1253 volumeColor.setRgbF( color[0], color[1], color[2] );
1254 // 0d elements: color, size
1255 anActor->Get0DColor( color[0], color[1], color[2] );
1256 elem0dColor.setRgbF( color[0], color[1], color[2] );
1257 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1258 // balls: color, size
1259 anActor->GetBallColor( color[0], color[1], color[2] );
1260 ballColor.setRgbF( color[0], color[1], color[2] );
1261 ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1263 anActor->GetOutlineColor( color[0], color[1], color[2] );
1264 outlineColor.setRgbF( color[0], color[1], color[2] );
1265 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1266 // orientation vectors: color, scale, 3d flag
1267 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1268 orientationColor.setRgbF( color[0], color[1], color[2] );
1269 orientationScale = anActor->GetFacesOrientationScale();
1270 orientation3d = anActor->GetFacesOrientation3DVectors();
1272 shrinkCoef = anActor->GetShrinkFactor();
1275 firstTime = false; // we only take properties from first object (for performance reasons)
1278 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1279 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1280 presentEntities = presentEntities | SMESH_Actor::eEdges;
1281 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1282 presentEntities = presentEntities | SMESH_Actor::eFaces;
1283 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1284 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1285 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1286 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1287 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1288 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1290 // as we know that all types of elements are present, we can exit the loop
1291 if ( presentEntities == SMESH_Actor::eAllEntity )
1295 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1296 // nodes: color, marker
1297 dlg.setNodeColor( nodeColor );
1298 if( markerType != VTK::MT_USER )
1299 dlg.setNodeMarker( markerType, markerScale );
1301 dlg.setNodeCustomMarker( markerId );
1302 // edges: color, line width
1303 dlg.setEdgeColor( edgeColor );
1304 dlg.setEdgeWidth( edgeWidth );
1305 // faces: front color, back color
1306 dlg.setFaceColor( faceColor, deltaF );
1307 // volumes: normal color, reversed color
1308 dlg.setVolumeColor( volumeColor, deltaV );
1309 // outlines: color, line width
1310 dlg.setOutlineColor( outlineColor );
1311 dlg.setOutlineWidth( outlineWidth );
1312 // 0d elements: color, size
1313 dlg.setElem0dColor( elem0dColor );
1314 dlg.setElem0dSize( elem0dSize );
1315 // balls: color, size
1316 dlg.setBallColor( ballColor );
1317 dlg.setBallSize( ballSize );
1318 // orientation: color, scale, 3d flag
1319 dlg.setOrientationColor( orientationColor );
1320 dlg.setOrientationSize( int( orientationScale * 100. ) );
1321 dlg.setOrientation3d( orientation3d );
1322 // shrink: scale factor
1323 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1324 // hide unused controls
1325 dlg.showControls( presentEntities, hasNodes );
1328 nodeColor = dlg.nodeColor();
1329 markerType = dlg.nodeMarkerType();
1330 markerScale = dlg.nodeMarkerScale();
1331 markerId = dlg.nodeMarkerId();
1332 edgeColor = dlg.edgeColor();
1333 edgeWidth = dlg.edgeWidth();
1334 faceColor = dlg.faceColor();
1335 deltaF = dlg.faceColorDelta();
1336 volumeColor = dlg.volumeColor();
1337 deltaV = dlg.volumeColorDelta();
1338 outlineColor = dlg.outlineColor();
1339 outlineWidth = dlg.outlineWidth();
1340 elem0dColor = dlg.elem0dColor();
1341 elem0dSize = dlg.elem0dSize();
1342 ballColor = dlg.ballColor();
1343 ballSize = dlg.ballSize();
1344 orientationColor = dlg.orientationColor();
1345 orientationScale = dlg.orientationSize() / 100.;
1346 orientation3d = dlg.orientation3d();
1347 shrinkCoef = dlg.shrinkCoef() / 100.;
1349 // store point markers map that might be changed by the user
1350 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1352 // set properties from dialog box to the presentations
1353 SALOME_ListIteratorOfListIO It( selected );
1354 for ( ; It.More(); It.Next() ) {
1355 Handle(SALOME_InteractiveObject) IObject = It.Value();
1356 if ( !IObject->hasEntry() ) continue;
1357 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1358 if ( !anActor ) continue;
1360 // nodes: color, marker
1361 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1362 if ( markerType != VTK::MT_USER ) {
1363 anActor->SetMarkerStd( markerType, markerScale );
1366 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1367 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1368 if ( iter != markerMap.end() )
1369 anActor->SetMarkerTexture( markerId, iter->second.second );
1371 // volumes: normal color, reversed color (delta)
1372 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1373 // faces: front color, back color (delta)
1374 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1375 // edges: color, width
1376 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1377 anActor->SetLineWidth( edgeWidth );
1379 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1380 anActor->SetOutlineWidth( outlineWidth );
1381 // 0D elements: color, size
1382 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1383 anActor->Set0DSize( elem0dSize );
1384 // balls: color, size
1385 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1386 anActor->SetBallSize( ballSize );
1387 // orientation: color, scale, 3d flag
1388 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1389 anActor->SetFacesOrientationScale( orientationScale );
1390 anActor->SetFacesOrientation3DVectors( orientation3d );
1392 anActor->SetShrinkFactor( shrinkCoef );
1394 // for groups, set also proper color
1395 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1396 if ( !aGroupObject->_is_nil() ) {
1397 SMESH::ElementType anElementType = aGroupObject->GetType();
1399 switch( anElementType ) {
1401 aColor = nodeColor; break;
1403 aColor = edgeColor; break;
1405 aColor = faceColor; break;
1407 aColor = volumeColor; break;
1409 aColor = elem0dColor; break;
1411 aColor = ballColor; break;
1415 if ( aColor.isValid() ) {
1416 SALOMEDS::Color aGroupColor;
1417 aGroupColor.R = aColor.redF();
1418 aGroupColor.G = aColor.greenF();
1419 aGroupColor.B = aColor.blueF();
1420 aGroupObject->SetColor( aGroupColor );
1422 } // if ( !aGroupObject->_is_nil() )
1423 } // for ( ; It.More(); It.Next() )
1424 SMESH::RepaintCurrentView();
1425 } // if ( dlg.exec() )
1428 } // switch(theCommandID)
1429 SALOME_ListIteratorOfListIO It( selected );
1430 for( ; It.More(); It.Next()){
1431 Handle(SALOME_InteractiveObject) IObject = It.Value();
1432 if(IObject->hasEntry()){
1433 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1434 switch(theCommandID){
1436 anActor->SetRepresentation(SMESH_Actor::eEdge);
1439 anActor->SetRepresentation(SMESH_Actor::eSurface);
1442 if(anActor->IsShrunk())
1443 anActor->UnShrink();
1445 anActor->SetShrink();
1448 anActor->SetRepresentation(SMESH_Actor::ePoint);
1451 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1452 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1455 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1456 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1462 SMESH::RepaintCurrentView();
1466 void Control( int theCommandID )
1468 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1469 SALOME_ListIO selected;
1471 aSel->selectedObjects( selected );
1473 if( !selected.IsEmpty() ){
1474 Handle(SALOME_InteractiveObject) anIO = selected.First();
1476 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1477 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1478 switch ( theCommandID ){
1480 aControl = SMESH_Actor::eLength;
1483 aControl = SMESH_Actor::eLength2D;
1486 aControl = SMESH_Actor::eFreeEdges;
1489 aControl = SMESH_Actor::eFreeBorders;
1492 aControl = SMESH_Actor::eMultiConnection;
1495 aControl = SMESH_Actor::eFreeNodes;
1498 aControl = SMESH_Actor::eMultiConnection2D;
1501 aControl = SMESH_Actor::eArea;
1504 aControl = SMESH_Actor::eTaper;
1507 aControl = SMESH_Actor::eAspectRatio;
1510 aControl = SMESH_Actor::eAspectRatio3D;
1513 aControl = SMESH_Actor::eMinimumAngle;
1516 aControl = SMESH_Actor::eWarping;
1519 aControl = SMESH_Actor::eSkew;
1522 aControl = SMESH_Actor::eVolume3D;
1525 aControl = SMESH_Actor::eFreeFaces;
1528 aControl = SMESH_Actor::eMaxElementLength2D;
1531 aControl = SMESH_Actor::eMaxElementLength3D;
1534 aControl = SMESH_Actor::eBareBorderVolume;
1537 aControl = SMESH_Actor::eBareBorderFace;
1540 aControl = SMESH_Actor::eOverConstrainedVolume;
1543 aControl = SMESH_Actor::eOverConstrainedFace;
1546 aControl = SMESH_Actor::eCoincidentNodes;
1549 aControl = SMESH_Actor::eCoincidentElems1D;
1552 aControl = SMESH_Actor:: eCoincidentElems2D;
1555 aControl = SMESH_Actor::eCoincidentElems3D;
1559 anActor->SetControlMode(aControl);
1560 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1561 SMESH::RepaintCurrentView();
1562 #ifndef DISABLE_PLOT2DVIEWER
1563 if(anActor->GetPlot2Histogram()) {
1564 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1565 QString functorName = functorToString( anActor->GetFunctor());
1566 QString aHistogramName("%1 : %2");
1567 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1568 aHistogram->setName(aHistogramName);
1569 aHistogram->setHorTitle(functorName);
1570 SMESH::ProcessIn2DViewers(anActor);
1579 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1580 SMESH::MeshObjectType theType,
1581 const QString theInTypeName,
1582 QString & theOutTypeName)
1584 SMESH_TypeFilter aTypeFilter( theType );
1586 if( !theIO.IsNull() )
1588 entry = theIO->getEntry();
1589 LightApp_DataOwner owner( entry );
1590 if ( aTypeFilter.isOk( &owner )) {
1591 theOutTypeName = theInTypeName;
1599 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1601 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1602 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1604 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1605 CORBA::String_var anID = aSComp->GetID().c_str();
1606 if (!strcmp(anID.in(),theIO->getEntry()))
1612 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1613 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1614 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1615 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1616 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1624 QString CheckHomogeneousSelection()
1626 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1627 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1628 SALOME_ListIO selected;
1630 aSel->selectedObjects( selected );
1632 QString RefType = CheckTypeObject(selected.First());
1633 SALOME_ListIteratorOfListIO It(selected);
1634 for ( ; It.More(); It.Next())
1636 Handle(SALOME_InteractiveObject) IObject = It.Value();
1637 QString Type = CheckTypeObject(IObject);
1638 if (Type.compare(RefType) != 0)
1639 return "Heterogeneous Selection";
1646 void SMESHGUI::OnEditDelete()
1648 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1649 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1650 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1652 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1653 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1654 _PTR(GenericAttribute) anAttr;
1655 _PTR(AttributeIOR) anIOR;
1657 int objectCount = 0;
1659 QString aParentComponent = QString::null;
1660 Handle(SALOME_InteractiveObject) anIO;
1661 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1663 anIO = anIt.Value();
1664 QString cur = anIO->getComponentDataType();
1665 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1667 // check if object is reference
1668 _PTR(SObject) aRefSObj;
1669 aNameList.append("\n - ");
1670 if ( aSO->ReferencedObject( aRefSObj ) ) {
1671 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1672 aNameList.append( aRefName );
1673 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1676 aNameList.append(anIO->getName());
1680 if( aParentComponent.isNull() )
1681 aParentComponent = cur;
1682 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1683 aParentComponent = "";
1686 if ( objectCount == 0 )
1687 return; // No Valid Objects Selected
1689 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1690 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1691 QObject::tr("ERR_ERROR"),
1692 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1695 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1696 if (SUIT_MessageBox::warning
1697 (SMESHGUI::desktop(),
1698 QObject::tr("SMESH_WRN_WARNING"),
1699 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1700 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1701 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1704 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1706 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1707 // then treat them all starting from the deepest objects (at list back)
1708 std::list< _PTR(SObject) > listSO;
1709 SALOME_ListIteratorOfListIO It(selected);
1710 for( ; It.More(); It.Next()) // loop on selected IO's
1712 Handle(SALOME_InteractiveObject) IObject = It.Value();
1713 if(IObject->hasEntry()) {
1714 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1716 // disable removal of "SMESH" component object
1717 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1719 if ( engineIOR() == anIOR->Value().c_str() )
1722 //Check the referenced object
1723 _PTR(SObject) aRefSObject;
1724 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1725 aSO = aRefSObject; // Delete main Object instead of reference
1727 listSO.push_back( aSO );
1728 std::list< _PTR(SObject) >::iterator itSO = listSO.begin();
1729 for ( ; itSO != listSO.end(); ++itSO ) {
1730 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1731 for (it->InitEx(false); it->More(); it->Next())
1732 listSO.push_back( it->Value() );
1736 // Check if none of objects to delete is referred from outside
1737 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1738 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1740 _PTR(SObject) SO = *ritSO;
1741 if ( !SO ) continue;
1742 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1743 for (size_t i = 0; i < aReferences.size(); i++) {
1744 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1745 std::string type = aComponent->ComponentDataType();
1746 if ( type != "SMESH" )
1748 SUIT_MessageBox::warning( anApp->desktop(),
1749 QObject::tr("WRN_WARNING"),
1750 QObject::tr("DEP_OBJECT") );
1751 return; // outside SMESH, there is an object depending on a SMESH object
1756 // Treat SO's in the list starting from the back
1757 aStudyBuilder->NewCommand(); // There is a transaction
1758 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1760 _PTR(SObject) SO = *ritSO;
1761 if ( !SO ) continue;
1762 std::string anEntry = SO->GetID();
1764 /** Erase graphical object **/
1765 if(SO->FindAttribute(anAttr, "AttributeIOR")){
1766 ViewManagerList aViewMenegers = anApp->viewManagers();
1767 ViewManagerList::const_iterator it = aViewMenegers.begin();
1768 for( ; it != aViewMenegers.end(); it++) {
1769 SUIT_ViewManager* vm = *it;
1770 int nbSf = vm ? vm->getViewsCount() : 0;
1772 QVector<SUIT_ViewWindow*> aViews = vm->getViews();
1773 for(int i = 0; i < nbSf; i++){
1774 SUIT_ViewWindow *sf = aViews[i];
1775 if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
1776 SMESH::RemoveActor(sf,anActor);
1782 /** Remove an object from data structures **/
1783 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1784 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1785 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1786 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1787 aMesh->RemoveGroup( aGroup );
1789 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1790 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1791 aMesh->RemoveSubMesh( aSubMesh );
1793 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1795 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1798 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1799 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1800 QString objType = CheckTypeObject(IObject);
1801 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1802 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1803 aStudyBuilder->RemoveObjectWithChildren( SO );
1805 else {// default action: remove SObject from the study
1806 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1807 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1809 aStudyBuilder->RemoveObjectWithChildren( SO );
1813 } /* listSO back loop */
1815 aStudyBuilder->CommitCommand();
1817 /* Clear any previous selection */
1819 aSel->setSelectedObjects( l1 );
1821 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1826 SMESHGUI_EXPORT CAM_Module* createModule()
1828 return new SMESHGUI();
1831 SMESHGUI_EXPORT char* getModuleVersion() {
1832 return (char*)SMESH_VERSION_STR;
1836 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1838 //=============================================================================
1842 //=============================================================================
1843 SMESHGUI::SMESHGUI() :
1844 SalomeApp_Module( "SMESH" ),
1845 LightApp_Module( "SMESH" )
1847 if ( CORBA::is_nil( myComponentSMESH ) )
1849 CORBA::Boolean anIsEmbeddedMode;
1850 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1851 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1853 // 0019923: EDF 765 SMESH : default values of hypothesis
1854 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1855 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1856 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1857 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1858 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1860 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1861 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1862 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1864 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1865 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1869 myActiveDialogBox = 0;
1870 myFilterLibraryDlg = 0;
1874 myEventCallbackCommand = vtkCallbackCommand::New();
1875 myEventCallbackCommand->Delete();
1876 myEventCallbackCommand->SetClientData( this );
1877 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1880 SMESH::GetFilterManager();
1881 SMESH::GetPattern();
1882 SMESH::GetMeasurements();
1884 /* load resources for all available meshers */
1885 SMESH::InitAvailableHypotheses();
1888 //=============================================================================
1892 //=============================================================================
1893 SMESHGUI::~SMESHGUI()
1895 #ifdef WITHGENERICOBJ
1896 SMESH::GetFilterManager()->UnRegister();
1897 SMESH::GetMeasurements()->UnRegister();
1899 SMESH::GetFilterManager() = SMESH::FilterManager::_nil();
1900 SMESH::GetMeasurements() = SMESH::Measurements::_nil();
1903 //=============================================================================
1907 //=============================================================================
1908 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1910 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1912 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1917 //=============================================================================
1921 //=============================================================================
1922 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1924 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1928 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
1929 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1930 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
1931 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
1932 return autoUpdate && !exceeded;
1935 //=============================================================================
1939 //=============================================================================
1940 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
1942 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
1945 //=============================================================================
1949 //=============================================================================
1950 SMESHGUI* SMESHGUI::GetSMESHGUI()
1952 SMESHGUI* smeshMod = 0;
1953 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
1956 CAM_Module* module = app->module( "Mesh" );
1957 smeshMod = dynamic_cast<SMESHGUI*>( module );
1960 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
1962 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
1965 _PTR(Study) aStudy = study->studyDS();
1967 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
1976 Standard_EXPORT SMESHGUI* GetComponentGUI()
1978 return SMESHGUI::GetSMESHGUI();
1982 //=============================================================================
1986 //=============================================================================
1987 void SMESHGUI::SetState(int aState)
1992 //=============================================================================
1996 //=============================================================================
1997 void SMESHGUI::ResetState()
2002 //=============================================================================
2006 //=============================================================================
2007 void SMESHGUI::EmitSignalDeactivateDialog()
2009 emit SignalDeactivateActiveDialog();
2012 //=============================================================================
2016 //=============================================================================
2017 void SMESHGUI::EmitSignalStudyFrameChanged()
2019 emit SignalStudyFrameChanged();
2022 //=============================================================================
2026 //=============================================================================
2027 void SMESHGUI::EmitSignalCloseAllDialogs()
2029 emit SignalCloseAllDialogs();
2032 //=============================================================================
2036 //=============================================================================
2037 void SMESHGUI::EmitSignalVisibilityChanged()
2039 emit SignalVisibilityChanged();
2042 //=============================================================================
2046 //=============================================================================
2047 QDialog *SMESHGUI::GetActiveDialogBox()
2049 return myActiveDialogBox;
2052 //=============================================================================
2056 //=============================================================================
2057 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2059 myActiveDialogBox = (QDialog *) aDlg;
2063 //=============================================================================
2067 //=============================================================================
2068 SUIT_Desktop* SMESHGUI::desktop()
2070 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2072 return app->desktop();
2077 //=============================================================================
2081 //=============================================================================
2082 SalomeApp_Study* SMESHGUI::activeStudy()
2084 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2086 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2091 //=============================================================================
2095 //=============================================================================
2096 void SMESHGUI::Modified( bool theIsUpdateActions )
2098 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2099 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2100 appStudy->Modified();
2101 if( theIsUpdateActions )
2102 app->updateActions();
2107 //=============================================================================
2111 //=============================================================================
2112 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2114 /* Here the position is on the bottom right corner - 10 */
2115 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2117 SUIT_Desktop *PP = desktop();
2118 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2119 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2123 //=============================================================================
2127 //=============================================================================
2128 static int isStudyLocked(_PTR(Study) theStudy){
2129 return theStudy->GetProperties()->IsLocked();
2132 static bool checkLock(_PTR(Study) theStudy) {
2133 if (isStudyLocked(theStudy)) {
2134 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2135 QObject::tr("WRN_WARNING"),
2136 QObject::tr("WRN_STUDY_LOCKED") );
2142 //=======================================================================
2143 //function : CheckActiveStudyLocked
2145 //=======================================================================
2147 bool SMESHGUI::isActiveStudyLocked()
2149 _PTR(Study) aStudy = activeStudy()->studyDS();
2150 return checkLock( aStudy );
2153 //=============================================================================
2157 //=============================================================================
2158 bool SMESHGUI::OnGUIEvent( int theCommandID )
2160 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2164 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2165 SUIT_ResourceMgr* mgr = resourceMgr();
2169 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2170 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2173 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2174 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2176 //QAction* act = action( theCommandID );
2178 switch (theCommandID) {
2180 if(checkLock(aStudy)) break;
2192 if(checkLock(aStudy)) break;
2193 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2197 case 150: //MED FILE INFORMATION
2199 SALOME_ListIO selected;
2200 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2202 aSel->selectedObjects( selected );
2203 if( selected.Extent() )
2205 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2206 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2207 if ( !aMesh->_is_nil() )
2209 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2216 case 122: // EXPORT MED
2231 ::ExportMeshToFile(theCommandID);
2235 case 200: // SCALAR BAR
2237 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2238 SALOME_ListIO selected;
2240 aSel->selectedObjects( selected );
2242 if( selected.Extent() ) {
2243 Handle(SALOME_InteractiveObject) anIO = selected.First();
2244 if( anIO->hasEntry() ) {
2245 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2246 anActor->SetControlMode( SMESH_Actor::eNone );
2247 #ifndef DISABLE_PLOT2DVIEWER
2248 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2257 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2262 // dump control distribution data to the text file
2263 ::SaveDistribution();
2269 // show/ distribution
2270 ::ShowDistribution();
2274 #ifndef DISABLE_PLOT2DVIEWER
2277 // plot distribution
2278 ::PlotDistribution();
2289 ::DisableAutoColor();
2292 case 1134: // Clipping
2293 case 1133: // Tranparency
2294 case 1132: // Display preferences (colors, shrink size, line width, ...)
2301 ::SetDisplayMode(theCommandID, myMarkerMap);
2304 //2D quadratic representation
2307 ::SetDisplayMode(theCommandID, myMarkerMap);
2311 case 216: // 0D elements
2314 case 219: // Volumes
2315 case 220: // All Entity
2317 ::SetDisplayEntity(theCommandID);
2320 case 221: // Orientation of faces
2322 LightApp_SelectionMgr* mgr = selectionMgr();
2323 SALOME_ListIO selected; mgr->selectedObjects( selected );
2325 SALOME_ListIteratorOfListIO it(selected);
2326 for( ; it.More(); it.Next()) {
2327 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2328 if(anIObject->hasEntry()) {
2329 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2330 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2339 if(checkLock(aStudy)) break;
2341 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2344 SMESH::UpdateView();
2346 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2347 SMESH::OnVisuException();
2349 catch (...) { // PAL16774 (Crash after display of many groups)
2350 SMESH::OnVisuException();
2354 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2355 aSel->selectedObjects( l );
2356 aSel->setSelectedObjects( l );
2361 case 301: // DISPLAY
2362 case 302: // DISPLAY ONLY
2364 SMESH::EDisplaing anAction;
2365 switch (theCommandID) {
2366 case 300: anAction = SMESH::eErase; break;
2367 case 301: anAction = SMESH::eDisplay; break;
2368 case 302: anAction = SMESH::eDisplayOnly; break;
2371 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2372 SALOME_ListIO sel_objects, to_process;
2374 aSel->selectedObjects( sel_objects );
2376 if( theCommandID==302 )
2378 MESSAGE("anAction = SMESH::eDisplayOnly");
2379 startOperation( myEraseAll );
2382 extractContainers( sel_objects, to_process );
2385 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2389 SALOME_ListIteratorOfListIO It( to_process );
2390 for ( ; It.More(); It.Next()) {
2392 Handle(SALOME_InteractiveObject) IOS = It.Value();
2393 if (IOS->hasEntry()) {
2395 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2396 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2397 break; // PAL16774 (Crash after display of many groups)
2399 if (anAction == SMESH::eDisplayOnly)
2401 MESSAGE("anAction = SMESH::eDisplayOnly");
2402 anAction = SMESH::eDisplay;
2408 // PAL13338 + PAL15161 -->
2409 if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2410 MESSAGE("anAction = SMESH::eDisplayOnly");
2411 SMESH::UpdateView();
2412 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2414 // PAL13338 + PAL15161 <--
2416 catch (...) { // PAL16774 (Crash after display of many groups)
2417 SMESH::OnVisuException();
2420 if (anAction == SMESH::eErase) {
2421 MESSAGE("anAction == SMESH::eErase");
2423 aSel->setSelectedObjects( l1 );
2426 aSel->setSelectedObjects( to_process );
2433 if(checkLock(aStudy)) break;
2436 EmitSignalDeactivateDialog();
2438 ( new SMESHGUI_NodesDlg( this ) )->show();
2441 SUIT_MessageBox::warning(desktop(),
2442 tr("SMESH_WRN_WARNING"),
2443 tr("SMESH_WRN_VIEWER_VTK"));
2448 case 2151: // FILTER
2452 EmitSignalDeactivateDialog();
2453 ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2458 case 701: // COMPUTE MESH
2459 case 711: // PRECOMPUTE MESH
2460 case 712: // EVALUATE MESH
2461 case 713: // MESH ORDER
2462 case 702: // Create mesh
2463 case 703: // Create sub-mesh
2464 case 704: // Edit mesh/sub-mesh
2465 startOperation( theCommandID );
2467 case 705: // copy mesh
2469 if (checkLock(aStudy)) break;
2470 EmitSignalDeactivateDialog();
2471 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2474 case 710: // Build compound mesh
2476 if (checkLock(aStudy)) break;
2477 EmitSignalDeactivateDialog();
2478 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2482 case 407: // DIAGONAL INVERSION
2483 case 408: // Delete diagonal
2487 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2488 tr( "NOT_A_VTK_VIEWER" ) );
2492 if ( checkLock( aStudy ) )
2495 /*Standard_Boolean aRes;
2496 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2497 if ( aMesh->_is_nil() )
2499 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2500 tr( "SMESH_BAD_SELECTION" ) );
2504 EmitSignalDeactivateDialog();
2505 if ( theCommandID == 407 )
2506 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2508 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2511 case 409: // Change orientation
2512 case 410: // Union of triangles
2513 case 411: // Cutting of quadrangles
2514 case 419: // Splitting volumes into tetrahedra
2518 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2519 tr( "NOT_A_VTK_VIEWER" ) );
2523 if ( checkLock( aStudy ) )
2526 EmitSignalDeactivateDialog();
2527 SMESHGUI_MultiEditDlg* aDlg = NULL;
2528 if ( theCommandID == 409 )
2529 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2530 else if ( theCommandID == 410 )
2531 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2532 else if ( theCommandID == 419 )
2533 aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2535 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2540 case 412: // Smoothing
2542 if(checkLock(aStudy)) break;
2544 EmitSignalDeactivateDialog();
2545 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2548 SUIT_MessageBox::warning(desktop(),
2549 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2553 case 413: // Extrusion
2555 if (checkLock(aStudy)) break;
2557 EmitSignalDeactivateDialog();
2558 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2560 SUIT_MessageBox::warning(desktop(),
2561 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2565 case 414: // Revolution
2567 if(checkLock(aStudy)) break;
2569 EmitSignalDeactivateDialog();
2570 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2573 SUIT_MessageBox::warning(desktop(),
2574 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2578 case 415: // Pattern mapping
2580 if ( checkLock( aStudy ) )
2584 EmitSignalDeactivateDialog();
2585 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2588 SUIT_MessageBox::warning(desktop(),
2589 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2593 case 416: // Extrusion along a path
2595 if (checkLock(aStudy)) break;
2597 EmitSignalDeactivateDialog();
2598 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2600 SUIT_MessageBox::warning(desktop(),
2601 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2605 case 417: // Convert mesh to quadratic
2606 case 418: // create 2D mesh from 3D
2607 case 420: // Reorient faces
2608 case 806: // CREATE GEO GROUP
2610 startOperation( theCommandID );
2613 case 801: // CREATE GROUP
2617 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2618 tr( "NOT_A_VTK_VIEWER" ) );
2622 if(checkLock(aStudy)) break;
2623 EmitSignalDeactivateDialog();
2624 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2626 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2627 SALOME_ListIO selected;
2629 aSel->selectedObjects( selected );
2631 int nbSel = selected.Extent();
2633 // check if mesh is selected
2634 aMesh = SMESH::GetMeshByIO( selected.First() );
2636 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2641 case 802: // CONSTRUCT GROUP
2645 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2646 tr( "NOT_A_VTK_VIEWER" ) );
2650 if(checkLock(aStudy)) break;
2651 EmitSignalDeactivateDialog();
2653 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2654 SALOME_ListIO selected;
2656 aSel->selectedObjects( selected );
2658 int nbSel = selected.Extent();
2660 // check if submesh is selected
2661 Handle(SALOME_InteractiveObject) IObject = selected.First();
2662 if (IObject->hasEntry()) {
2663 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2665 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2666 if (!aSubMesh->_is_nil()) {
2668 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2669 // get submesh elements list by types
2670 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2671 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2672 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2673 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2674 // create group for each type o elements
2675 QString aName = IObject->getName();
2676 QStringList anEntryList;
2677 if (aNodes->length() > 0) {
2678 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2679 aGroup->Add(aNodes.inout());
2680 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2681 anEntryList.append( aSObject->GetID().c_str() );
2683 if (aEdges->length() > 0) {
2684 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2685 aGroup->Add(aEdges.inout());
2686 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2687 anEntryList.append( aSObject->GetID().c_str() );
2689 if (aFaces->length() > 0) {
2690 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2691 aGroup->Add(aFaces.inout());
2692 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2693 anEntryList.append( aSObject->GetID().c_str() );
2695 if (aVolumes->length() > 0) {
2696 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2697 aGroup->Add(aVolumes.inout());
2698 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2699 anEntryList.append( aSObject->GetID().c_str() );
2702 anApp->browseObjects( anEntryList );
2704 catch(const SALOME::SALOME_Exception & S_ex){
2705 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2712 SUIT_MessageBox::warning(desktop(),
2713 tr("SMESH_WRN_WARNING"),
2714 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2719 case 803: // EDIT GROUP
2723 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2724 tr( "NOT_A_VTK_VIEWER" ) );
2728 if(checkLock(aStudy)) break;
2729 EmitSignalDeactivateDialog();
2731 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2732 SALOME_ListIO selected;
2734 aSel->selectedObjects( selected );
2736 SALOME_ListIteratorOfListIO It (selected);
2737 int nbSelectedGroups = 0;
2738 for ( ; It.More(); It.Next() )
2740 SMESH::SMESH_GroupBase_var aGroup =
2741 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2742 if (!aGroup->_is_nil()) {
2744 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2748 if (nbSelectedGroups == 0)
2750 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2756 case 804: // Add elements to group
2758 if(checkLock(aStudy)) break;
2759 if (myState == 800) {
2760 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2761 if (aDlg) aDlg->onAdd();
2766 case 805: // Remove elements from group
2768 if(checkLock(aStudy)) break;
2769 if (myState == 800) {
2770 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2771 if (aDlg) aDlg->onRemove();
2776 case 815: // Edit GEOM GROUP as standalone
2780 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2781 tr( "NOT_A_VTK_VIEWER" ) );
2785 if(checkLock(aStudy)) break;
2786 EmitSignalDeactivateDialog();
2788 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2789 SALOME_ListIO selected;
2791 aSel->selectedObjects( selected );
2793 SALOME_ListIteratorOfListIO It (selected);
2794 for ( ; It.More(); It.Next() )
2796 SMESH::SMESH_GroupOnGeom_var aGroup =
2797 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2798 if (!aGroup->_is_nil()) {
2799 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2804 SMESH::SMESH_GroupOnFilter_var aGroup =
2805 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2806 if (!aGroup->_is_nil()) {
2807 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2815 case 810: // Union Groups
2816 case 811: // Intersect groups
2817 case 812: // Cut groups
2821 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2822 tr( "NOT_A_VTK_VIEWER" ) );
2826 if ( checkLock( aStudy ) )
2829 EmitSignalDeactivateDialog();
2831 SMESHGUI_GroupOpDlg* aDlg = 0;
2832 if ( theCommandID == 810 )
2833 aDlg = new SMESHGUI_UnionGroupsDlg( this );
2834 else if ( theCommandID == 811 )
2835 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2837 aDlg = new SMESHGUI_CutGroupsDlg( this );
2844 case 814: // Create groups of entities from existing groups of superior dimensions
2846 if ( checkLock( aStudy ) )
2849 EmitSignalDeactivateDialog();
2850 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2856 case 813: // Delete groups with their contents
2860 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2861 tr( "NOT_A_VTK_VIEWER" ) );
2865 if ( checkLock( aStudy ) )
2868 EmitSignalDeactivateDialog();
2870 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2874 case 900: // MESH INFOS
2875 case 903: // WHAT IS
2877 int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2878 EmitSignalDeactivateDialog();
2879 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2880 SALOME_ListIO selected;
2882 aSel->selectedObjects( selected );
2884 if ( selected.Extent() > 1 ) { // a dlg for each IO
2885 SALOME_ListIteratorOfListIO It( selected );
2886 for ( ; It.More(); It.Next() ) {
2887 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2888 dlg->showInfo( It.Value() );
2893 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2899 case 904: // FIND ELEM
2901 startOperation( theCommandID );
2905 case 1100: // EDIT HYPOTHESIS
2907 if(checkLock(aStudy)) break;
2909 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2910 SALOME_ListIO selected;
2912 aSel->selectedObjects( selected );
2914 int nbSel = selected.Extent();
2917 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2918 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
2920 /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
2921 /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects */
2922 /* Warning : however by internal mechanism all subMeshes icons are changed ! */
2923 if ( !aHypothesis->_is_nil() )
2926 //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2927 SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2929 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
2939 case 1102: // REMOVE HYPOTHESIS / ALGORITHMS
2941 if(checkLock(aStudy)) break;
2942 SUIT_OverrideCursor wc;
2944 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2945 SALOME_ListIO selected;
2947 aSel->selectedObjects( selected, QString::null, false );
2949 SALOME_ListIteratorOfListIO It(selected);
2950 for (int i = 0; It.More(); It.Next(), i++) {
2951 Handle(SALOME_InteractiveObject) IObject = It.Value();
2952 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2955 aSel->setSelectedObjects( l1 );
2961 case 4009: // ELEM0D
2963 case 4021: // TRIANGLE
2965 case 4023: // POLYGON
2969 case 4134: // PYRAMID
2970 case 4135: // OCTA12
2972 if(checkLock(aStudy)) break;
2974 EmitSignalDeactivateDialog();
2975 SMDSAbs_EntityType type = SMDSEntity_Edge;
2976 switch (theCommandID) {
2977 case 4008: type = SMDSEntity_Ball; break;
2978 case 4009: type = SMDSEntity_0D; break;
2979 case 4021: type = SMDSEntity_Triangle; break;
2980 case 4022: type = SMDSEntity_Quadrangle; break;
2981 case 4031: type = SMDSEntity_Tetra; break;
2982 case 4023: type = SMDSEntity_Polygon; break;
2983 case 4032: type = SMDSEntity_Hexa; break;
2984 case 4133: type = SMDSEntity_Penta; break;
2985 case 4134: type = SMDSEntity_Pyramid; break;
2986 case 4135: type = SMDSEntity_Hexagonal_Prism; break;
2989 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
2992 SUIT_MessageBox::warning(desktop(),
2993 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2997 case 4033: // POLYHEDRON
2999 if(checkLock(aStudy)) break;
3001 EmitSignalDeactivateDialog();
3002 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3005 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3006 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3010 case 4034: // QUADRATIC EDGE
3011 case 4035: // QUADRATIC TRIANGLE
3012 case 4036: // QUADRATIC QUADRANGLE
3013 case 4136: // BIQUADRATIC QUADRANGLE
3014 case 4037: // QUADRATIC TETRAHEDRON
3015 case 4038: // QUADRATIC PYRAMID
3016 case 4039: // QUADRATIC PENTAHEDRON
3017 case 4040: // QUADRATIC HEXAHEDRON
3018 case 4140: // TRIQUADRATIC HEXAHEDRON
3020 if(checkLock(aStudy)) break;
3022 EmitSignalDeactivateDialog();
3023 SMDSAbs_EntityType type;
3025 switch (theCommandID) {
3027 type = SMDSEntity_Quad_Edge; break;
3029 type = SMDSEntity_Quad_Triangle; break;
3031 type = SMDSEntity_Quad_Quadrangle; break;
3033 type = SMDSEntity_BiQuad_Quadrangle; break;
3035 type = SMDSEntity_Quad_Tetra; break;
3037 type = SMDSEntity_Quad_Pyramid; break;
3039 type = SMDSEntity_Quad_Penta; break;
3041 type = SMDSEntity_Quad_Hexa;
3043 type = SMDSEntity_TriQuad_Hexa;
3047 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3050 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3051 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3055 case 4041: // REMOVES NODES
3057 if(checkLock(aStudy)) break;
3059 EmitSignalDeactivateDialog();
3060 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3063 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3064 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3068 case 4042: // REMOVES ELEMENTS
3070 if(checkLock(aStudy)) break;
3072 EmitSignalDeactivateDialog();
3073 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3077 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3078 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3082 case 4043: { // CLEAR_MESH
3084 if(checkLock(aStudy)) break;
3086 SALOME_ListIO selected;
3087 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3088 aSel->selectedObjects( selected );
3090 SUIT_OverrideCursor wc;
3091 SALOME_ListIteratorOfListIO It (selected);
3092 for ( ; It.More(); It.Next() )
3094 Handle(SALOME_InteractiveObject) IOS = It.Value();
3095 SMESH::SMESH_Mesh_var aMesh =
3096 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3097 if ( aMesh->_is_nil()) continue;
3099 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3101 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3102 SMESH::ModifiedMesh( aMeshSObj, false, true);
3103 // hide groups and submeshes
3104 _PTR(ChildIterator) anIter =
3105 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3106 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3108 _PTR(SObject) so = anIter->Value();
3109 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3112 catch (const SALOME::SALOME_Exception& S_ex){
3114 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3118 SMESH::UpdateView();
3122 case 4044: // REMOVE ORPHAN NODES
3124 if(checkLock(aStudy)) break;
3125 SALOME_ListIO selected;
3126 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3127 aSel->selectedObjects( selected );
3128 if ( selected.Extent() == 1 ) {
3129 Handle(SALOME_InteractiveObject) anIO = selected.First();
3130 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3131 if ( !aMesh->_is_nil() ) {
3132 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3133 tr( "SMESH_WARNING" ),
3134 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3135 SUIT_MessageBox::Yes |
3136 SUIT_MessageBox::No,
3137 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3140 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3141 int removed = aMeshEditor->RemoveOrphanNodes();
3142 SUIT_MessageBox::information(SMESHGUI::desktop(),
3143 tr("SMESH_INFORMATION"),
3144 tr("NB_NODES_REMOVED").arg(removed));
3145 if ( removed > 0 ) {
3146 SMESH::UpdateView();
3147 SMESHGUI::Modified();
3150 catch (const SALOME::SALOME_Exception& S_ex) {
3151 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3160 case 4051: // RENUMBERING NODES
3162 if(checkLock(aStudy)) break;
3164 EmitSignalDeactivateDialog();
3165 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3169 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3170 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3174 case 4052: // RENUMBERING ELEMENTS
3176 if(checkLock(aStudy)) break;
3178 EmitSignalDeactivateDialog();
3179 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3183 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3184 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3188 case 4061: // TRANSLATION
3190 if(checkLock(aStudy)) break;
3192 EmitSignalDeactivateDialog();
3193 ( new SMESHGUI_TranslationDlg( this ) )->show();
3196 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3197 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3201 case 4062: // ROTATION
3203 if(checkLock(aStudy)) break;
3205 EmitSignalDeactivateDialog();
3206 ( new SMESHGUI_RotationDlg( this ) )->show();
3209 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3210 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3214 case 4063: // SYMMETRY
3216 if(checkLock(aStudy)) break;
3218 EmitSignalDeactivateDialog();
3219 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3222 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3223 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3227 case 4064: // SEWING
3229 if(checkLock(aStudy)) break;
3231 EmitSignalDeactivateDialog();
3232 ( new SMESHGUI_SewingDlg( this ) )->show();
3235 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3236 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3240 case 4065: // MERGE NODES
3242 if(checkLock(aStudy)) break;
3244 EmitSignalDeactivateDialog();
3245 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3248 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3249 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3253 case 4066: // MERGE EQUAL ELEMENTS
3255 if (checkLock(aStudy)) break;
3257 EmitSignalDeactivateDialog();
3258 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3260 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3261 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3266 case 4067: // MAKE MESH PASS THROUGH POINT
3267 startOperation( 4067 );
3272 if(checkLock(aStudy)) break;
3274 EmitSignalDeactivateDialog();
3275 ( new SMESHGUI_ScaleDlg( this ) )->show();
3278 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3279 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3284 case 4069: // DUPLICATE NODES
3286 if(checkLock(aStudy)) break;
3288 EmitSignalDeactivateDialog();
3289 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3292 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3293 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3298 case 5105: // Library of selection filters
3300 static QList<int> aTypes;
3301 if ( aTypes.isEmpty() )
3303 aTypes.append( SMESH::NODE );
3304 aTypes.append( SMESH::EDGE );
3305 aTypes.append( SMESH::FACE );
3306 aTypes.append( SMESH::VOLUME );
3308 if (!myFilterLibraryDlg)
3309 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3310 else if (myFilterLibraryDlg->isHidden())
3311 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3312 myFilterLibraryDlg->raise();
3316 case 6017: // CONTROLS
3344 LightApp_SelectionMgr* mgr = selectionMgr();
3345 SALOME_ListIO selected; mgr->selectedObjects( selected );
3347 if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3348 _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3350 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3351 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
3352 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3353 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
3354 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3355 ::Control( theCommandID );
3360 SUIT_MessageBox::warning(desktop(),
3361 tr( "SMESH_WRN_WARNING" ),
3362 tr( "SMESH_BAD_SELECTION" ) );
3366 SUIT_MessageBox::warning(desktop(),
3367 tr( "SMESH_WRN_WARNING" ),
3368 tr( "NOT_A_VTK_VIEWER" ) );
3373 LightApp_SelectionMgr* mgr = selectionMgr();
3374 SALOME_ListIO selected; mgr->selectedObjects( selected );
3376 SALOME_ListIteratorOfListIO it(selected);
3377 for( ; it.More(); it.Next()) {
3378 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3379 if(anIObject->hasEntry()) {
3380 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3381 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3389 LightApp_SelectionMgr* mgr = selectionMgr();
3390 SALOME_ListIO selected; mgr->selectedObjects( selected );
3392 SALOME_ListIteratorOfListIO it(selected);
3393 for( ; it.More(); it.Next()) {
3394 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3395 if(anIObject->hasEntry())
3396 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3397 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3405 int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3406 EmitSignalDeactivateDialog();
3407 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3413 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3414 //updateObjBrowser();
3418 //=============================================================================
3422 //=============================================================================
3423 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3428 //=============================================================================
3432 //=============================================================================
3433 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3438 //=============================================================================
3442 //=============================================================================
3443 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3448 //=============================================================================
3449 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3450 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3452 //=============================================================================
3453 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3454 SUIT_ViewWindow* wnd )
3456 if(theIO->hasEntry()){
3457 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3458 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3462 //=======================================================================
3463 // function : createSMESHAction
3465 //=======================================================================
3466 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3467 const int key, const bool toggle, const QString& shortcutAction )
3470 QWidget* parent = application()->desktop();
3471 SUIT_ResourceMgr* resMgr = resourceMgr();
3473 if ( !icon_id.isEmpty() )
3474 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3476 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3477 if ( !pix.isNull() )
3478 icon = QIcon( pix );
3480 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3481 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3482 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3484 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3485 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3488 //=======================================================================
3489 // function : createPopupItem
3491 //=======================================================================
3492 void SMESHGUI::createPopupItem( const int id,
3493 const QString& clients,
3494 const QString& types,
3495 const QString& theRule,
3498 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3499 popupMgr()->insert( action( id ), pId, 0 );
3501 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3502 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3503 QString rule = "(%1) and (%2) and (%3)";
3504 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3505 if( clients.isEmpty() )
3506 rule = rule.arg( QString( "true" ) );
3508 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3509 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3512 bool cont = myRules.contains( id );
3514 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3516 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3517 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3520 //=======================================================================
3521 // function : initialize
3523 //=======================================================================
3524 void SMESHGUI::initialize( CAM_Application* app )
3526 SalomeApp_Module::initialize( app );
3528 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3530 /* Automatic Update flag */
3531 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3533 // ----- create actions --------------
3535 //createSMESHAction( 111, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3536 createSMESHAction( 112, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3537 createSMESHAction( 113, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3538 createSMESHAction( 114, "NUM" );
3539 createSMESHAction( 115, "IMPORT_STL" );
3540 createSMESHAction( 116, "IMPORT_CGNS" );
3541 createSMESHAction( 117, "IMPORT_SAUV" );
3542 createSMESHAction( 118, "IMPORT_GMF" );
3543 createSMESHAction( 121, "DAT" );
3544 createSMESHAction( 122, "MED" );
3545 createSMESHAction( 123, "UNV" );
3546 createSMESHAction( 140, "STL" );
3547 createSMESHAction( 142, "CGNS");
3548 createSMESHAction( 144, "SAUV");
3549 createSMESHAction( 146, "GMF" );
3550 createSMESHAction( 124, "DAT" );
3551 createSMESHAction( 125, "MED" );
3552 createSMESHAction( 126, "UNV" );
3553 createSMESHAction( 141, "STL" );
3554 createSMESHAction( 143, "CGNS");
3555 createSMESHAction( 145, "SAUV");
3556 createSMESHAction( 147, "GMF" );
3557 createSMESHAction( 150, "FILE_INFO" );
3558 createSMESHAction( 33, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3559 createSMESHAction( 5105, "SEL_FILTER_LIB" );
3560 createSMESHAction( 701, "COMPUTE", "ICON_COMPUTE" );
3561 createSMESHAction( 702, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3562 createSMESHAction( 703, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3563 createSMESHAction( 704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3564 createSMESHAction( 705, "COPY_MESH", "ICON_COPY_MESH" );
3565 createSMESHAction( 710, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3566 createSMESHAction( 711, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3567 createSMESHAction( 712, "EVALUATE", "ICON_COMPUTE" );
3568 createSMESHAction( 713, "MESH_ORDER", "ICON_COMPUTE" );
3569 createSMESHAction( 806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3570 createSMESHAction( 801, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3571 createSMESHAction( 802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3572 createSMESHAction( 803, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3573 createSMESHAction( 815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3574 createSMESHAction( 804, "ADD" );
3575 createSMESHAction( 805, "REMOVE" );
3576 createSMESHAction( 810, "UN_GROUP", "ICON_UNION" );
3577 createSMESHAction( 811, "INT_GROUP", "ICON_INTERSECT" );
3578 createSMESHAction( 812, "CUT_GROUP", "ICON_CUT" );
3579 createSMESHAction( 814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3580 createSMESHAction( 813, "DEL_GROUP", "ICON_DEL_GROUP" );
3581 createSMESHAction( 900, "ADV_INFO", "ICON_ADV_INFO" );
3582 //createSMESHAction( 902, "STD_INFO", "ICON_STD_INFO" );
3583 //createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3584 createSMESHAction( 904, "FIND_ELEM", "ICON_FIND_ELEM" );
3585 createSMESHAction( 6001, "LENGTH", "ICON_LENGTH", 0, true );
3586 createSMESHAction( 6002, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3587 createSMESHAction( 6021, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3588 createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3589 createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3590 createSMESHAction( 6024, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3591 createSMESHAction( 6025, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3592 createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3593 createSMESHAction( 6027, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3594 createSMESHAction( 6028, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3595 createSMESHAction( 6029, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3596 createSMESHAction( 6030, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3597 createSMESHAction( 6031, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3598 createSMESHAction( 6003, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3599 createSMESHAction( 6004, "CONNECTION", "ICON_CONNECTION", 0, true );
3600 createSMESHAction( 6005, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3601 createSMESHAction( 6011, "AREA", "ICON_AREA", 0, true );
3602 createSMESHAction( 6012, "TAPER", "ICON_TAPER", 0, true );
3603 createSMESHAction( 6013, "ASPECT", "ICON_ASPECT", 0, true );
3604 createSMESHAction( 6014, "MIN_ANG", "ICON_ANGLE", 0, true );
3605 createSMESHAction( 6015, "WARP", "ICON_WARP", 0, true );
3606 createSMESHAction( 6016, "SKEW", "ICON_SKEW", 0, true );
3607 createSMESHAction( 6017, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3608 createSMESHAction( 6018, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3609 createSMESHAction( 6019, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3610 createSMESHAction( 6009, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3611 createSMESHAction( 4000, "NODE", "ICON_DLG_NODE" );
3612 createSMESHAction( 4009, "ELEM0D", "ICON_DLG_ELEM0D" );
3613 createSMESHAction( 4008, "BALL", "ICON_DLG_BALL" );
3614 createSMESHAction( 4010, "EDGE", "ICON_DLG_EDGE" );
3615 createSMESHAction( 4021, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3616 createSMESHAction( 4022, "QUAD", "ICON_DLG_QUADRANGLE" );
3617 createSMESHAction( 4023, "POLYGON", "ICON_DLG_POLYGON" );
3618 createSMESHAction( 4031, "TETRA", "ICON_DLG_TETRAS" );
3619 createSMESHAction( 4032, "HEXA", "ICON_DLG_HEXAS" );
3620 createSMESHAction( 4133, "PENTA", "ICON_DLG_PENTA" );
3621 createSMESHAction( 4134, "PYRAMID", "ICON_DLG_PYRAMID" );
3622 createSMESHAction( 4135, "OCTA", "ICON_DLG_OCTA" );
3623 createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3624 createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3625 createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3626 createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3627 createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3628 createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3629 createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3630 createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3631 createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3632 createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3633 createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3634 createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3635 createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3636 createSMESHAction( 4043, "CLEAR_MESH" , "ICON_CLEAR_MESH" );
3637 createSMESHAction( 4051, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3638 createSMESHAction( 4052, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3639 createSMESHAction( 4061, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3640 createSMESHAction( 4062, "ROT", "ICON_DLG_MESH_ROTATION" );
3641 createSMESHAction( 4063, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3642 createSMESHAction( 4064, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3643 createSMESHAction( 4065, "MERGE", "ICON_SMESH_MERGE_NODES" );
3644 createSMESHAction( 4066, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3645 createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3646 createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" );
3647 createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3648 createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" );
3649 createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" );
3650 createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3651 createSMESHAction( 410, "UNION", "ICON_UNIONTRI" );
3652 createSMESHAction( 411, "CUT", "ICON_CUTQUAD" );
3653 createSMESHAction( 412, "SMOOTH", "ICON_DLG_SMOOTHING" );
3654 createSMESHAction( 413, "EXTRUSION", "ICON_EXTRUSION" );
3655 createSMESHAction( 414, "REVOLUTION", "ICON_REVOLUTION" );
3656 createSMESHAction( 415, "MAP", "ICON_MAP" );
3657 createSMESHAction( 416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3658 createSMESHAction( 417, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3659 createSMESHAction( 418, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3660 createSMESHAction( 419, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3661 createSMESHAction( 420, "REORIENT_2D", "ICON_REORIENT_2D" );
3662 createSMESHAction( 200, "RESET" );
3663 createSMESHAction( 201, "SCALAR_BAR_PROP" );
3664 createSMESHAction( 2021, "SAVE_DISTRIBUTION" );
3665 createSMESHAction( 2022, "SHOW_DISTRIBUTION","",0, true );
3666 #ifndef DISABLE_PLOT2DVIEWER
3667 createSMESHAction( 2023, "PLOT_DISTRIBUTION" );
3669 createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true );
3670 createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true );
3671 createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true );
3672 createSMESHAction( 214, "UPDATE", "ICON_UPDATE" );
3673 createSMESHAction( 215, "NODES", "ICON_POINTS", 0, true );
3674 createSMESHAction( 222, "BALLS", "ICON_DLG_BALL", 0, true );
3675 createSMESHAction( 216, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3676 createSMESHAction( 217, "EDGES", "ICON_DLG_EDGE", 0, true );
3677 createSMESHAction( 218, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3678 createSMESHAction( 219, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3679 createSMESHAction( 220, "ALL" );
3680 createSMESHAction( 221, "FACE_ORIENTATION", "", 0, true );
3682 createSMESHAction( 231, "LINE_REPRESENTATION", "", 0, true );
3683 createSMESHAction( 232, "ARC_REPRESENTATION", "", 0, true );
3685 createSMESHAction( 1100, "EDIT_HYPO" );
3686 createSMESHAction( 1102, "UNASSIGN" );
3687 createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3688 createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3689 createSMESHAction( 1131, "DISPMODE" );
3690 createSMESHAction( 1132, "COLORS" );
3691 createSMESHAction( 1133, "TRANSP" );
3692 createSMESHAction( 1134, "CLIP" );
3693 createSMESHAction( 1135, "DISP_ENT" );
3694 createSMESHAction( 1136, "AUTO_COLOR" );
3695 createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3696 createSMESHAction( 2000, "CTRL" );
3698 createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3699 createSMESHAction( 502, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3701 createSMESHAction( 300, "HIDE" );
3702 createSMESHAction( 301, "SHOW" );
3703 createSMESHAction( 302, "DISPLAY_ONLY" );
3705 // ----- create menu --------------
3706 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3707 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3708 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3709 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3710 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3711 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3712 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3713 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3715 createMenu( separator(), fileId );
3717 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3718 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3719 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3720 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3721 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3722 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3723 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3724 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3725 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3726 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3728 //createMenu( 111, importId, -1 );
3729 createMenu( 112, importId, -1 );
3730 createMenu( 113, importId, -1 );
3731 createMenu( 115, importId, -1 );
3733 createMenu( 116, importId, -1 );
3735 createMenu( 117, importId, -1 );
3736 createMenu( 118, importId, -1 );
3737 createMenu( 121, exportId, -1 );
3738 createMenu( 122, exportId, -1 );
3739 createMenu( 123, exportId, -1 );
3740 createMenu( 140, exportId, -1 ); // export to STL
3742 createMenu( 142, exportId, -1 ); // export to CGNS
3744 createMenu( 144, exportId, -1 ); // export to SAUV
3745 createMenu( 146, exportId, -1 ); // export to GMF
3746 createMenu( separator(), fileId, 10 );
3748 createMenu( 33, editId, -1 );
3750 createMenu( 5105, toolsId, -1 );
3752 createMenu( 702, meshId, -1 ); // "Mesh" menu
3753 createMenu( 703, meshId, -1 );
3754 createMenu( 704, meshId, -1 );
3755 createMenu( 710, meshId, -1 );
3756 createMenu( 705, meshId, -1 );
3757 createMenu( separator(), meshId, -1 );
3758 createMenu( 701, meshId, -1 );
3759 createMenu( 711, meshId, -1 );
3760 createMenu( 712, meshId, -1 );
3761 createMenu( 713, meshId, -1 );
3762 createMenu( separator(), meshId, -1 );
3763 createMenu( 801, meshId, -1 );
3764 createMenu( 806, meshId, -1 );
3765 createMenu( 802, meshId, -1 );
3766 createMenu( 803, meshId, -1 );
3767 createMenu( 815, meshId, -1 );
3768 createMenu( separator(), meshId, -1 );
3769 createMenu( 810, meshId, -1 );
3770 createMenu( 811, meshId, -1 );
3771 createMenu( 812, meshId, -1 );
3772 createMenu( separator(), meshId, -1 );
3773 createMenu( 814, meshId, -1 );
3774 createMenu( separator(), meshId, -1 );
3775 createMenu( 900, meshId, -1 );
3776 //createMenu( 902, meshId, -1 );
3777 //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3778 createMenu( 904, meshId, -1 );
3779 createMenu( separator(), meshId, -1 );
3781 createMenu( 6005, nodeId, -1 );
3782 createMenu( 6028, nodeId, -1 );
3783 createMenu( 6002, edgeId, -1 );
3784 createMenu( 6003, edgeId, -1 );
3785 createMenu( 6001, edgeId, -1 );
3786 createMenu( 6004, edgeId, -1 );
3787 createMenu( 6029, edgeId, -1 );
3788 createMenu( 6021, faceId, -1 );
3789 createMenu( 6025, faceId, -1 );
3790 createMenu( 6027, faceId, -1 );
3791 createMenu( 6018, faceId, -1 );
3792 createMenu( 6019, faceId, -1 );
3793 createMenu( 6011, faceId, -1 );
3794 createMenu( 6012, faceId, -1 );
3795 createMenu( 6013, faceId, -1 );
3796 createMenu( 6014, faceId, -1 );
3797 createMenu( 6015, faceId, -1 );
3798 createMenu( 6016, faceId, -1 );
3799 createMenu( 6022, faceId, -1 );
3800 createMenu( 6030, faceId, -1 );
3801 createMenu( 6017, volumeId, -1 );
3802 createMenu( 6009, volumeId, -1 );
3803 createMenu( 6023, volumeId, -1 );
3804 createMenu( 6024, volumeId, -1 );
3805 createMenu( 6026, volumeId, -1 );
3806 createMenu( 6031, volumeId, -1 );
3808 createMenu( 4000, addId, -1 );
3809 createMenu( 4009, addId, -1 );
3810 createMenu( 4008, addId, -1 );
3811 createMenu( 4010, addId, -1 );
3812 createMenu( 4021, addId, -1 );
3813 createMenu( 4022, addId, -1 );
3814 createMenu( 4023, addId, -1 );
3815 createMenu( 4031, addId, -1 );
3816 createMenu( 4032, addId, -1 );
3817 createMenu( 4133, addId, -1 );
3818 createMenu( 4134, addId, -1 );
3819 createMenu( 4135, addId, -1 );
3820 createMenu( 4033, addId, -1 );
3821 createMenu( separator(), addId, -1 );
3822 createMenu( 4034, addId, -1 );
3823 createMenu( 4035, addId, -1 );
3824 createMenu( 4036, addId, -1 );
3825 createMenu( 4136, addId, -1 );
3826 createMenu( 4037, addId, -1 );
3827 createMenu( 4038, addId, -1 );
3828 createMenu( 4039, addId, -1 );
3829 createMenu( 4040, addId, -1 );
3830 createMenu( 4140, addId, -1 );
3832 createMenu( 4041, removeId, -1 );
3833 createMenu( 4042, removeId, -1 );
3834 createMenu( 4044, removeId, -1 );
3835 createMenu( separator(), removeId, -1 );
3836 createMenu( 813, removeId, -1 );
3837 createMenu( separator(), removeId, -1 );
3838 createMenu( 4043, removeId, -1 );
3840 createMenu( 4051, renumId, -1 );
3841 createMenu( 4052, renumId, -1 );
3843 createMenu( 4061, transfId, -1 );
3844 createMenu( 4062, transfId, -1 );
3845 createMenu( 4063, transfId, -1 );
3846 createMenu( 4068, transfId, -1 );
3847 createMenu( 4064, transfId, -1 );
3848 createMenu( 4065, transfId, -1 );
3849 createMenu( 4066, transfId, -1 );
3850 createMenu( 4069, transfId, -1 );
3852 createMenu( 4067,modifyId, -1 );
3853 createMenu( 407, modifyId, -1 );
3854 createMenu( 408, modifyId, -1 );
3855 createMenu( 409, modifyId, -1 );
3856 createMenu( 420, modifyId, -1 );
3857 createMenu( 410, modifyId, -1 );
3858 createMenu( 411, modifyId, -1 );
3859 createMenu( 419, modifyId, -1 );
3860 createMenu( 412, modifyId, -1 );
3861 createMenu( 413, modifyId, -1 );
3862 createMenu( 416, modifyId, -1 );
3863 createMenu( 414, modifyId, -1 );
3864 createMenu( 415, modifyId, -1 );
3865 createMenu( 417, modifyId, -1 );
3866 createMenu( 418, modifyId, -1 );
3868 createMenu( 501, measureId, -1 );
3869 createMenu( 502, measureId, -1 );
3870 createMenu( 214, viewId, -1 );
3872 // ----- create toolbars --------------
3873 int meshTb = createTool( tr( "TB_MESH" ) ),
3874 ctrlTb = createTool( tr( "TB_CTRL" ) ),
3875 addRemTb = createTool( tr( "TB_ADD_REMOVE" ) ),
3876 modifyTb = createTool( tr( "TB_MODIFY" ) ),
3877 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
3879 createTool( 702, meshTb );
3880 createTool( 703, meshTb );
3881 createTool( 704, meshTb );
3882 createTool( 710, meshTb );
3883 createTool( 705, meshTb );
3884 createTool( separator(), meshTb );
3885 createTool( 701, meshTb );
3886 createTool( 711, meshTb );
3887 createTool( 712, meshTb );
3888 createTool( 713, meshTb );
3889 createTool( separator(), meshTb );
3890 createTool( 801, meshTb );
3891 createTool( 806, meshTb );
3892 createTool( 802, meshTb );
3893 createTool( 803, meshTb );
3894 //createTool( 815, meshTb );
3895 createTool( separator(), meshTb );
3896 createTool( 900, meshTb );
3897 //createTool( 902, meshTb );
3898 //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3899 createTool( 904, meshTb );
3900 createTool( separator(), meshTb );
3902 createTool( 6005, ctrlTb );
3903 createTool( 6028, ctrlTb );
3904 createTool( separator(), ctrlTb );
3905 createTool( 6002, ctrlTb );
3906 createTool( 6003, ctrlTb );
3907 createTool( 6001, ctrlTb );
3908 createTool( 6004, ctrlTb );
3909 createTool( 6029, ctrlTb );
3910 createTool( separator(), ctrlTb );
3911 createTool( 6021, ctrlTb );
3912 createTool( 6025, ctrlTb );
3913 createTool( 6027, ctrlTb );
3914 createTool( 6018, ctrlTb );
3915 createTool( 6019, ctrlTb );
3916 createTool( 6011, ctrlTb );
3917 createTool( 6012, ctrlTb );
3918 createTool( 6013, ctrlTb );
3919 createTool( 6014, ctrlTb );
3920 createTool( 6015, ctrlTb );
3921 createTool( 6016, ctrlTb );
3922 createTool( 6022, ctrlTb );
3923 createTool( 6030, ctrlTb );
3924 createTool( separator(), ctrlTb );
3925 createTool( 6017, ctrlTb );
3926 createTool( 6009, ctrlTb );
3927 createTool( 6023, ctrlTb );
3928 createTool( 6024, ctrlTb );
3929 createTool( 6026, ctrlTb );
3930 createTool( 6031, ctrlTb );
3931 createTool( separator(), ctrlTb );
3933 createTool( 4000, addRemTb );
3934 createTool( 4009, addRemTb );
3935 createTool( 4008, addRemTb );
3936 createTool( 4010, addRemTb );
3937 createTool( 4021, addRemTb );
3938 createTool( 4022, addRemTb );
3939 createTool( 4023, addRemTb );
3940 createTool( 4031, addRemTb );
3941 createTool( 4032, addRemTb );
3942 createTool( 4133, addRemTb );
3943 createTool( 4134, addRemTb );
3944 createTool( 4135, addRemTb );
3945 createTool( 4033, addRemTb );
3946 createTool( separator(), addRemTb );
3947 createTool( 4034, addRemTb );
3948 createTool( 4035, addRemTb );
3949 createTool( 4036, addRemTb );
3950 createTool( 4136, addRemTb );
3951 createTool( 4037, addRemTb );
3952 createTool( 4038, addRemTb );
3953 createTool( 4039, addRemTb );
3954 createTool( 4040, addRemTb );
3955 createTool( 4140, addRemTb );
3956 createTool( separator(), addRemTb );
3957 createTool( 4041, addRemTb );
3958 createTool( 4042, addRemTb );
3959 createTool( 4044, addRemTb );
3960 createTool( 4043, addRemTb );
3961 createTool( separator(), addRemTb );
3962 createTool( 4051, addRemTb );
3963 createTool( 4052, addRemTb );
3964 createTool( separator(), addRemTb );
3965 createTool( 4061, addRemTb );
3966 createTool( 4062, addRemTb );
3967 createTool( 4063, addRemTb );
3968 createTool( 4068, addRemTb );
3969 createTool( 4064, addRemTb );
3970 createTool( 4065, addRemTb );
3971 createTool( 4066, addRemTb );
3972 createTool( 4069, addRemTb );
3973 createTool( separator(), addRemTb );
3975 createTool( 4067,modifyTb );
3976 createTool( 407, modifyTb );
3977 createTool( 408, modifyTb );
3978 createTool( 409, modifyTb );
3979 createTool( 420, modifyTb );
3980 createTool( 410, modifyTb );
3981 createTool( 411, modifyTb );
3982 createTool( 419, modifyTb );
3983 createTool( 412, modifyTb );
3984 createTool( 413, modifyTb );
3985 createTool( 416, modifyTb );
3986 createTool( 414, modifyTb );
3987 createTool( 415, modifyTb );
3988 createTool( 417, modifyTb );
3989 createTool( 418, modifyTb );
3991 createTool( 214, dispModeTb );
3993 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3994 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3997 QString OB = "'ObjectBrowser'",
3998 View = "'" + SVTK_Viewer::Type() + "'",
4000 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4001 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4002 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4003 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4004 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4005 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4006 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4007 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4008 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4009 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4010 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4012 mesh_part = mesh + " " + subMesh + " " + group,
4013 mesh_group = mesh + " " + group,
4014 hyp_alg = hypo + " " + algo;
4016 // popup for object browser
4018 isInvisible("not( isVisible )"),
4019 isEmpty("numberOfNodes = 0"),
4020 isNotEmpty("numberOfNodes <> 0"),
4022 // has nodes, edges, etc in VISIBLE! actor
4023 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4024 hasElems("(count( elemTypes ) > 0)"),
4025 hasDifferentElems("(count( elemTypes ) > 1)"),
4026 hasBalls("({'BallElem'} in elemTypes)"),
4027 hasElems0d("({'Elem0d'} in elemTypes)"),
4028 hasEdges("({'Edge'} in elemTypes)"),
4029 hasFaces("({'Face'} in elemTypes)"),
4030 hasVolumes("({'Volume'} in elemTypes)");
4032 createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
4033 createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
4034 createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
4035 createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
4036 createPopupItem( 803, OB, group ); // EDIT_GROUP
4037 createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
4039 popupMgr()->insert( separator(), -1, 0 );
4040 createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
4041 createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
4042 createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
4043 createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
4044 createPopupItem( 214, OB, mesh_part ); // UPDATE
4045 createPopupItem( 900, OB, mesh_part ); // ADV_INFO
4046 createPopupItem( 904, OB, mesh_group ); // FIND_ELEM
4047 popupMgr()->insert( separator(), -1, 0 );
4048 createPopupItem( 801, OB, mesh ); // CREATE_GROUP
4049 createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
4050 createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
4051 popupMgr()->insert( separator(), -1, 0 );
4052 createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
4053 createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4054 popupMgr()->insert( separator(), -1, 0 );
4055 createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
4056 popupMgr()->insert( separator(), -1, 0 );
4057 createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
4058 createPopupItem( 418, OB, mesh + " " + group, // create 2D mesh from 3D
4060 popupMgr()->insert( separator(), -1, 0 );
4062 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4063 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4064 QString only_one_2D = only_one_non_empty + " && dim>1";
4066 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4067 createPopupItem( 125, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_MED
4068 createPopupItem( 126, OB, mesh_group, only_one_non_empty, anId ); // EXPORT_UNV
4069 createPopupItem( 141, OB, mesh_group, only_one_2D, anId ); // EXPORT_STL
4071 createPopupItem( 143, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_CGNS
4073 createPopupItem( 145, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_SAUV
4074 createPopupItem( 147, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_GMF
4075 createPopupItem( 124, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_DAT
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 );
4095 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4096 QString aType = QString( "%1type in {%2}" ).arg( lc );
4097 aType = aType.arg( mesh_part );
4098 QString aMeshInVTK = aClient + "&&" + aType;
4100 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4101 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4102 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4104 //-------------------------------------------------
4106 //-------------------------------------------------
4107 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4109 popupMgr()->insert( action( 9010 ), anId, -1 );
4110 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4111 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4113 popupMgr()->insert( action( 9011 ), anId, -1 );
4114 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4115 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4117 popupMgr()->insert( separator(), -1, -1 );
4119 //-------------------------------------------------
4121 //-------------------------------------------------
4122 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4124 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4125 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4126 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4128 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4129 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4130 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4132 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4133 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4134 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4136 popupMgr()->insert( separator(), anId, -1 );
4138 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4139 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4140 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4142 //-------------------------------------------------
4144 //-------------------------------------------------
4145 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4147 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4149 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4150 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4151 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4153 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4154 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4155 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4157 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4158 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4159 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4161 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4162 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4163 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4165 popupMgr()->insert( action( 222 ), anId, -1 ); // BALLS
4166 popupMgr()->setRule( action( 222 ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4167 popupMgr()->setRule( action( 222 ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4169 popupMgr()->insert( separator(), anId, -1 );
4171 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4172 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4175 //-------------------------------------------------
4176 // Representation of the 2D Quadratic elements
4177 //-------------------------------------------------
4178 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4179 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4180 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4181 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4183 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4184 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4185 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4187 //-------------------------------------------------
4188 // Orientation of faces
4189 //-------------------------------------------------
4190 popupMgr()->insert( action( 221 ), -1, -1 );
4191 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4192 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4194 //-------------------------------------------------
4196 //-------------------------------------------------
4197 popupMgr()->insert( action( 1132 ), -1, -1 );
4198 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4200 //-------------------------------------------------
4202 //-------------------------------------------------
4203 popupMgr()->insert( action( 1133 ), -1, -1 );
4204 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4206 //-------------------------------------------------
4208 //-------------------------------------------------
4210 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4211 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4212 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4213 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4215 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4217 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4218 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4220 popupMgr()->insert( separator(), anId, -1 );
4222 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4224 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4225 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4226 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4228 popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4229 popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4230 popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4232 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4234 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4235 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4236 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4238 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4239 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4240 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4242 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4243 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4244 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4246 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4247 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4248 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4249 popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4250 popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4251 popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4253 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4255 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4256 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4257 QtxPopupMgr::VisibleRule );
4258 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4260 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4261 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4262 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4264 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4265 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4266 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4268 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4269 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4270 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4272 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4273 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4274 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4276 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4277 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4278 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4280 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4281 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4282 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4284 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4285 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4286 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4288 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4289 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4290 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4292 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4293 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4294 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4296 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4297 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4298 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4300 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4301 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4302 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4303 popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4304 popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4305 popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4307 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4309 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4310 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4311 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4313 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4314 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4315 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4317 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4318 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4319 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4321 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4322 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4323 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4325 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4326 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4327 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4329 popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4330 popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4331 popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4333 popupMgr()->insert( separator(), anId, -1 );
4335 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4336 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4338 popupMgr()->insert( separator(), anId, -1 );
4340 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4342 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4343 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4345 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4346 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4347 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4349 #ifndef DISABLE_PLOT2DVIEWER
4350 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4351 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4354 //-------------------------------------------------
4356 //-------------------------------------------------
4357 popupMgr()->insert( separator(), -1, -1 );
4358 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4359 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4360 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4361 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4363 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4364 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4366 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4367 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4369 popupMgr()->insert( separator(), -1, -1 );
4371 //-------------------------------------------------
4373 //-------------------------------------------------
4374 popupMgr()->insert( action( 1134 ), -1, -1 );
4375 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4377 popupMgr()->insert( separator(), -1, -1 );
4379 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4380 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4382 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4383 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4386 //================================================================================
4388 * \brief Return true if SMESH or GEOM objects are selected.
4389 * Is called form LightApp_Module::activateModule() which clear selection if
4390 * not isSelectionCompatible()
4392 //================================================================================
4394 bool SMESHGUI::isSelectionCompatible()
4396 bool isCompatible = true;
4397 SALOME_ListIO selected;
4398 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4399 Sel->selectedObjects( selected );
4401 SALOME_ListIteratorOfListIO It( selected );
4402 for ( ; isCompatible && It.More(); It.Next())
4404 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4405 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4407 return isCompatible;
4411 bool SMESHGUI::reusableOperation( const int id )
4413 // compute, evaluate and precompute are not reusable operations
4414 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4417 bool SMESHGUI::activateModule( SUIT_Study* study )
4419 bool res = SalomeApp_Module::activateModule( study );
4421 setMenuShown( true );
4422 setToolShown( true );
4424 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4425 PyGILState_STATE gstate = PyGILState_Ensure();
4426 PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4427 if(pluginsmanager==NULL)
4431 PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4436 PyGILState_Release(gstate);
4437 // end of GEOM plugins loading
4439 // Reset actions accelerator keys
4440 //action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4441 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4442 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4444 action( 33)->setEnabled(true); // Delete: Key_Delete
4446 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4447 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4448 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4449 if ( _PTR(Study) aStudy = s->studyDS()) {
4450 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4451 updateObjBrowser(); // objects can be removed
4454 // get all view currently opened in the study and connect their signals to
4455 // the corresponding slots of the class.
4456 SUIT_Desktop* aDesk = study->application()->desktop();
4458 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4459 SUIT_ViewWindow* wnd;
4460 foreach ( wnd, wndList )
4467 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4469 setMenuShown( false );
4470 setToolShown( false );
4472 EmitSignalCloseAllDialogs();
4474 // Unset actions accelerator keys
4475 //action(111)->setShortcut(QKeySequence()); // Import DAT
4476 action(112)->setShortcut(QKeySequence()); // Import UNV
4477 action(113)->setShortcut(QKeySequence()); // Import MED
4479 action( 33)->setEnabled(false); // Delete: Key_Delete
4481 return SalomeApp_Module::deactivateModule( study );
4484 void SMESHGUI::studyClosed( SUIT_Study* s )
4486 SMESH::RemoveVisuData( s->id() );
4487 SalomeApp_Module::studyClosed( s );
4490 void SMESHGUI::OnGUIEvent()
4492 const QObject* obj = sender();
4493 if ( !obj || !obj->inherits( "QAction" ) )
4495 int id = actionId((QAction*)obj);
4500 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4502 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4503 if ( CORBA::is_nil( myComponentSMESH ) )
4505 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4507 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4508 return aGUI.myComponentSMESH;
4511 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4512 return myComponentSMESH;
4515 QString SMESHGUI::engineIOR() const
4517 CORBA::ORB_var anORB = getApp()->orb();
4518 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4519 return QString( anIOR.in() );
4522 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4524 SalomeApp_Module::contextMenuPopup( client, menu, title );
4526 selectionMgr()->selectedObjects( lst );
4527 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4528 Handle(SALOME_InteractiveObject) io = lst.First();
4529 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4530 _PTR(Study) study = appStudy->studyDS();
4531 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4533 QString aName = QString( obj->GetName().c_str() );
4534 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4535 aName.remove( (aName.length() - 1), 1 );
4541 LightApp_Selection* SMESHGUI::createSelection() const
4543 return new SMESHGUI_Selection();
4546 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4548 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4549 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4552 void SMESHGUI::viewManagers( QStringList& list ) const
4554 list.append( SVTK_Viewer::Type() );
4557 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4559 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4560 SMESH::UpdateSelectionProp( this );
4562 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4563 for(int i = 0; i < aViews.count() ; i++){
4564 SUIT_ViewWindow *sf = aViews[i];
4570 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4572 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4573 myClippingPlaneInfoMap.erase( theViewManager );
4576 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4578 theActor->AddObserver( SMESH::DeleteActorEvent,
4579 myEventCallbackCommand.GetPointer(),
4583 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4584 unsigned long theEvent,
4585 void* theClientData,
4588 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4589 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4590 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4591 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4592 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4593 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4594 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4595 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4596 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4597 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4598 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4599 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4600 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4601 if( anActor == *anIter3 ) {
4602 anActorList.erase( anIter3 );
4613 void SMESHGUI::createPreferences()
4615 // General tab ------------------------------------------------------------------------
4616 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4618 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4619 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4620 setPreferenceProperty( lim, "min", 0 );
4621 setPreferenceProperty( lim, "max", 100000000 );
4622 setPreferenceProperty( lim, "step", 1000 );
4623 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4625 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4626 setPreferenceProperty( qaGroup, "columns", 2 );
4627 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4628 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4629 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4630 setPreferenceProperty( prec, "min", 0 );
4631 setPreferenceProperty( prec, "max", 16 );
4632 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4633 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4634 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4635 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4636 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4638 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4639 setPreferenceProperty( dispgroup, "columns", 2 );
4640 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4642 modes.append( tr("MEN_WIRE") );
4643 modes.append( tr("MEN_SHADE") );
4644 modes.append( tr("MEN_NODES") );
4645 modes.append( tr("MEN_SHRINK") );
4646 QList<QVariant> indices;
4647 indices.append( 0 );
4648 indices.append( 1 );
4649 indices.append( 2 );
4650 indices.append( 3 );
4651 setPreferenceProperty( dispmode, "strings", modes );
4652 setPreferenceProperty( dispmode, "indexes", indices );
4654 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4655 setPreferenceProperty( arcgroup, "columns", 2 );
4656 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4657 QStringList quadraticModes;
4658 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4659 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4661 indices.append( 0 );
4662 indices.append( 1 );
4663 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4664 setPreferenceProperty( quadraticmode, "indexes", indices );
4666 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4667 "SMESH", "max_angle" );
4668 setPreferenceProperty( maxAngle, "min", 1 );
4669 setPreferenceProperty( maxAngle, "max", 90 );
4673 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4674 setPreferenceProperty( exportgroup, "columns", 2 );
4675 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4676 addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4678 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4679 setPreferenceProperty( computeGroup, "columns", 2 );
4680 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4682 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4683 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4684 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4686 indices.append( 0 );
4687 indices.append( 1 );
4688 indices.append( 2 );
4689 setPreferenceProperty( notifyMode, "strings", modes );
4690 setPreferenceProperty( notifyMode, "indexes", indices );
4692 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4693 setPreferenceProperty( infoGroup, "columns", 4 );
4694 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4696 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4697 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4699 indices.append( 0 );
4700 indices.append( 1 );
4701 setPreferenceProperty( elemInfo, "strings", modes );
4702 setPreferenceProperty( elemInfo, "indexes", indices );
4703 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4704 setPreferenceProperty( nodesLim, "min", 0 );
4705 setPreferenceProperty( nodesLim, "max", 10000000 );
4706 setPreferenceProperty( nodesLim, "step", 10000 );
4707 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4709 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4710 setPreferenceProperty( segGroup, "columns", 2 );
4711 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4712 "SMESH", "segmentation" );
4713 setPreferenceProperty( segLen, "min", 1 );
4714 setPreferenceProperty( segLen, "max", 10000000 );
4715 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4716 "SMESH", "nb_segments_per_edge" );
4717 setPreferenceProperty( nbSeg, "min", 1 );
4718 setPreferenceProperty( nbSeg, "max", 10000000 );
4720 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4721 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4722 "SMESH", "forget_mesh_on_hyp_modif" );
4725 // Quantities with individual precision settings
4726 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4727 setPreferenceProperty( precGroup, "columns", 2 );
4729 const int nbQuantities = 6;
4730 int precs[nbQuantities], ii = 0;
4731 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4732 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4733 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4734 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4735 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4736 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4737 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4738 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4739 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4740 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4741 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4742 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4744 // Set property for precision value for spinboxes
4745 for ( ii = 0; ii < nbQuantities; ii++ ){
4746 setPreferenceProperty( precs[ii], "min", -14 );
4747 setPreferenceProperty( precs[ii], "max", 14 );
4748 setPreferenceProperty( precs[ii], "precision", 2 );
4751 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4752 setPreferenceProperty( previewGroup, "columns", 2 );
4753 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4754 setPreferenceProperty( chunkSize, "min", 1 );
4755 setPreferenceProperty( chunkSize, "max", 1000 );
4756 setPreferenceProperty( chunkSize, "step", 50 );
4758 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4759 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4761 // Mesh tab ------------------------------------------------------------------------
4762 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4763 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4764 setPreferenceProperty( nodeGroup, "columns", 3 );
4766 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4768 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4770 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4771 QList<QVariant> aMarkerTypeIndicesList;
4772 QList<QVariant> aMarkerTypeIconsList;
4773 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4774 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4775 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4776 aMarkerTypeIndicesList << i;
4777 aMarkerTypeIconsList << pixmap;
4779 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4780 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4782 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4784 QList<QVariant> aMarkerScaleIndicesList;
4785 QStringList aMarkerScaleValuesList;
4786 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4787 aMarkerScaleIndicesList << i;
4788 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4790 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4791 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4793 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4794 //setPreferenceProperty( elemGroup, "columns", 2 );
4796 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4797 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4798 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
4799 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
4800 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4801 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
4802 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4803 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4806 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4807 setPreferenceProperty( grpGroup, "columns", 2 );
4809 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4810 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
4812 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4813 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4814 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
4815 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
4816 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4817 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4818 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
4819 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
4820 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4821 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4823 setPreferenceProperty( size0d, "min", 1 );
4824 setPreferenceProperty( size0d, "max", 10 );
4826 setPreferenceProperty( ballSize, "min", 1 );
4827 setPreferenceProperty( ballSize, "max", 10 );
4829 setPreferenceProperty( elemW, "min", 1 );
4830 setPreferenceProperty( elemW, "max", 5 );
4832 setPreferenceProperty( outW, "min", 1 );
4833 setPreferenceProperty( outW, "max", 5 );
4835 setPreferenceProperty( shrink, "min", 0 );
4836 setPreferenceProperty( shrink, "max", 100 );
4838 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4839 setPreferenceProperty( orientGroup, "columns", 1 );
4841 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4842 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4844 setPreferenceProperty( orientScale, "min", 0.05 );
4845 setPreferenceProperty( orientScale, "max", 0.5 );
4846 setPreferenceProperty( orientScale, "step", 0.05 );
4848 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4850 // Selection tab ------------------------------------------------------------------------
4851 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4853 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4854 setPreferenceProperty( selGroup, "columns", 2 );
4856 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4857 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4859 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4860 setPreferenceProperty( preGroup, "columns", 2 );
4862 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4864 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4865 setPreferenceProperty( precSelGroup, "columns", 2 );
4867 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4868 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4869 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4871 // Scalar Bar tab ------------------------------------------------------------------------
4872 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4873 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4874 setPreferenceProperty( fontGr, "columns", 2 );
4876 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4877 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4879 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4880 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4882 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4883 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4885 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4886 setPreferenceProperty( numcol, "min", 2 );
4887 setPreferenceProperty( numcol, "max", 256 );
4889 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4890 setPreferenceProperty( numlab, "min", 2 );
4891 setPreferenceProperty( numlab, "max", 65 );
4893 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4894 setPreferenceProperty( orientGr, "columns", 2 );
4895 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4896 QStringList orients;
4897 orients.append( tr( "SMESH_VERTICAL" ) );
4898 orients.append( tr( "SMESH_HORIZONTAL" ) );
4899 indices.clear(); indices.append( 0 ); indices.append( 1 );
4900 setPreferenceProperty( orient, "strings", orients );
4901 setPreferenceProperty( orient, "indexes", indices );
4903 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4904 setPreferenceProperty( posVSizeGr, "columns", 2 );
4905 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4906 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4907 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4908 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4909 setPreferenceProperty( xv, "step", 0.1 );
4910 setPreferenceProperty( xv, "min", 0.0 );
4911 setPreferenceProperty( xv, "max", 1.0 );
4912 setPreferenceProperty( yv, "step", 0.1 );
4913 setPreferenceProperty( yv, "min", 0.0 );
4914 setPreferenceProperty( yv, "max", 1.0 );
4915 setPreferenceProperty( wv, "step", 0.1 );
4916 setPreferenceProperty( wv, "min", 0.0 );
4917 setPreferenceProperty( wv, "max", 1.0 );
4918 setPreferenceProperty( hv, "min", 0.0 );
4919 setPreferenceProperty( hv, "max", 1.0 );
4920 setPreferenceProperty( hv, "step", 0.1 );
4922 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
4923 setPreferenceProperty( posHSizeGr, "columns", 2 );
4924 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
4925 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
4926 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
4927 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
4928 setPreferenceProperty( xv, "min", 0.0 );
4929 setPreferenceProperty( xv, "max", 1.0 );
4930 setPreferenceProperty( xv, "step", 0.1 );
4931 setPreferenceProperty( xh, "min", 0.0 );
4932 setPreferenceProperty( xh, "max", 1.0 );
4933 setPreferenceProperty( xh, "step", 0.1 );
4934 setPreferenceProperty( yh, "min", 0.0 );
4935 setPreferenceProperty( yh, "max", 1.0 );
4936 setPreferenceProperty( yh, "step", 0.1 );
4937 setPreferenceProperty( wh, "min", 0.0 );
4938 setPreferenceProperty( wh, "max", 1.0 );
4939 setPreferenceProperty( wh, "step", 0.1 );
4940 setPreferenceProperty( hh, "min", 0.0 );
4941 setPreferenceProperty( hh, "max", 1.0 );
4942 setPreferenceProperty( hh, "step", 0.1 );
4944 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
4945 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
4946 setPreferenceProperty( distributionGr, "columns", 3 );
4948 types.append( tr( "SMESH_MONOCOLOR" ) );
4949 types.append( tr( "SMESH_MULTICOLOR" ) );
4950 indices.clear(); indices.append( 0 ); indices.append( 1 );
4951 setPreferenceProperty( coloringType, "strings", types );
4952 setPreferenceProperty( coloringType, "indexes", indices );
4953 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
4957 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
4959 if( sect=="SMESH" ) {
4960 float sbX1,sbY1,sbW,sbH;
4961 float aTol = 1.00000009999999;
4962 std::string aWarning;
4963 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4964 if( name=="selection_object_color" || name=="selection_element_color" ||
4965 name=="highlight_color" ||
4966 name=="selection_precision_node" || name=="selection_precision_element" ||
4967 name=="selection_precision_object")
4968 SMESH::UpdateSelectionProp( this );
4969 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
4970 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
4971 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
4972 if(sbX1+sbW > aTol){
4973 aWarning = "Origin and Size Vertical: X+Width > 1\n";
4976 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
4977 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
4980 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
4981 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
4982 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
4983 if(sbY1+sbH > aTol){
4984 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
4985 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
4986 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
4989 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
4990 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4991 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
4992 if(sbX1+sbW > aTol){
4993 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
4996 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4997 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5000 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5001 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5002 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5003 if(sbY1+sbH > aTol){
5004 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5007 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5008 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5011 else if ( name == "segmentation" ) {
5012 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5013 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5015 else if ( name == "nb_segments_per_edge" ) {
5016 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5017 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5019 else if ( name == "historical_python_dump" ||
5020 name == "forget_mesh_on_hyp_modif") {
5021 QString val = aResourceMgr->stringValue( "SMESH", name );
5022 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5025 if(aWarning.size() != 0){
5026 aWarning += "The default values are applied instead.";
5027 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5028 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5029 QObject::tr(aWarning.c_str()));
5034 //================================================================================
5036 * \brief Update something in accordance with update flags
5037 * \param theFlags - update flags
5039 * Update viewer or/and object browser etc. in accordance with update flags ( see
5040 * LightApp_UpdateFlags enumeration ).
5042 //================================================================================
5043 void SMESHGUI::update( const int flags )
5045 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5046 SMESH::UpdateView();
5048 SalomeApp_Module::update( flags );
5051 //================================================================================
5053 * \brief Set default selection mode
5055 * SLOT called when operation commited. Sets default selection mode
5057 //================================================================================
5058 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5060 SVTK_ViewWindow* vtkWnd =
5061 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5063 vtkWnd->SetSelectionMode( ActorSelection );
5066 //================================================================================
5068 * \brief Set default selection mode
5070 * SLOT called when operation aborted. Sets default selection mode
5072 //================================================================================
5073 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5075 SVTK_ViewWindow* vtkWnd =
5076 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5078 vtkWnd->SetSelectionMode( ActorSelection );
5081 //================================================================================
5083 * \brief Creates operation with given identifier
5084 * \param id - identifier of operation to be started
5085 * \return Pointer on created operation or NULL if operation is not created
5087 * Virtual method redefined from the base class creates operation with given id.
5088 * It is called called automatically from startOperation method of base class.
5090 //================================================================================
5091 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5093 LightApp_Operation* op = 0;
5094 // to do : create operation here
5097 case 417: //convert to quadratic
5098 op = new SMESHGUI_ConvToQuadOp();
5100 case 418: // create 2D mesh as boundary on 3D
5101 op = new SMESHGUI_Make2DFrom3DOp();
5103 case 420: // Reorient faces
5104 op = new SMESHGUI_ReorientFacesOp();
5106 case 701: // Compute mesh
5107 op = new SMESHGUI_ComputeOp();
5109 case 702: // Create mesh
5110 op = new SMESHGUI_MeshOp( true, true );
5112 case 703: // Create sub-mesh
5113 op = new SMESHGUI_MeshOp( true, false );
5115 case 704: // Edit mesh/sub-mesh
5116 op = new SMESHGUI_MeshOp( false );
5118 case 711: // Precompute mesh
5119 op = new SMESHGUI_PrecomputeOp();
5121 case 712: // Evaluate mesh
5122 op = new SMESHGUI_EvaluateOp();
5124 case 713: // Evaluate mesh
5125 op = new SMESHGUI_MeshOrderOp();
5127 case 806: // Create group on geom
5128 op = new SMESHGUI_GroupOnShapeOp();
5130 case 904: // Find element
5131 op = new SMESHGUI_FindElemByPointOp();
5133 case 4067: // make mesh pass through point
5134 op = new SMESHGUI_MakeNodeAtPointOp();
5141 op = SalomeApp_Module::createOperation( id );
5145 //================================================================================
5147 * \brief Stops current operations and starts a given one
5148 * \param id - The id of the operation to start
5150 //================================================================================
5152 void SMESHGUI::switchToOperation(int id)
5154 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5155 activeStudy()->abortAllOperations();
5156 startOperation( id );
5159 LightApp_Displayer* SMESHGUI::displayer()
5162 myDisplayer = new SMESHGUI_Displayer( getApp() );
5166 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5169 int aTolerance = 64;
5170 int anIterations = 0;
5176 if( anIterations % aPeriod == 0 )
5179 if( aTolerance < 1 )
5183 aHue = (int)( 360.0 * rand() / RAND_MAX );
5186 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5187 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5188 for( ; it != itEnd; ++it )
5190 SALOMEDS::Color anAutoColor = *it;
5191 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5194 aQColor.getHsv( &h, &s, &v );
5195 if( abs( h - aHue ) < aTolerance )
5207 aColor.setHsv( aHue, 255, 255 );
5209 SALOMEDS::Color aSColor;
5210 aSColor.R = aColor.redF();
5211 aSColor.G = aColor.greenF();
5212 aSColor.B = aColor.blueF();
5217 const char* gSeparator = "_"; // character used to separate parameter names
5218 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5219 const char* gPathSep = "|"; // character used to separate paths
5222 * \brief Store visual parameters
5224 * This method is called just before the study document is saved.
5225 * Store visual parameters in AttributeParameter attribue(s)
5227 void SMESHGUI::storeVisualParameters (int savePoint)
5230 Kernel_Utils::Localizer loc;
5232 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5233 if (!appStudy || !appStudy->studyDS())
5235 _PTR(Study) studyDS = appStudy->studyDS();
5237 // componentName is used for encoding of entries when storing them in IParameters
5238 std::string componentName = myComponentSMESH->ComponentDataType();
5239 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5240 //if (!aSComponent) return;
5243 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5244 componentName.c_str(),
5246 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5248 // store map of custom markers
5249 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5250 if( !aMarkerMap.empty() )
5252 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5253 for( ; anIter != aMarkerMap.end(); anIter++ )
5255 int anId = anIter->first;
5256 VTK::MarkerData aMarkerData = anIter->second;
5257 std::string aMarkerFileName = aMarkerData.first;
5258 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5259 if( aMarkerTexture.size() < 3 )
5260 continue; // should contain at least width, height and the first value
5262 QString aPropertyName( "texture" );
5263 aPropertyName += gSeparator;
5264 aPropertyName += QString::number( anId );
5266 QString aPropertyValue = aMarkerFileName.c_str();
5267 aPropertyValue += gPathSep;
5269 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5270 ushort aWidth = *aTextureIter++;
5271 ushort aHeight = *aTextureIter++;
5272 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5273 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5274 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5275 aPropertyValue += QString::number( *aTextureIter );
5277 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5281 // viewers counters are used for storing view_numbers in IParameters
5284 // main cycle to store parameters of displayed objects
5285 QList<SUIT_ViewManager*> lst;
5286 QList<SUIT_ViewManager*>::Iterator it;
5287 getApp()->viewManagers(lst);
5288 for (it = lst.begin(); it != lst.end(); it++)
5290 SUIT_ViewManager* vman = *it;
5291 QString vType = vman->getType();
5293 // saving VTK actors properties
5294 if (vType == SVTK_Viewer::Type())
5296 // store the clipping planes attached to the view manager
5297 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5298 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5299 if( anIter != myClippingPlaneInfoMap.end() )
5300 aClippingPlaneInfoList = anIter->second;
5302 if( !aClippingPlaneInfoList.empty() ) {
5303 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5304 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5306 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5307 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5309 QString aPropertyName( "ClippingPlane" );
5310 aPropertyName += gSeparator;
5311 aPropertyName += QString::number( vtkViewers );
5312 aPropertyName += gSeparator;
5313 aPropertyName += QString::number( anId );
5315 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5316 aPropertyValue += gDigitsSep;
5317 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5318 aPropertyValue += gDigitsSep;
5319 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5320 aPropertyValue += gDigitsSep;
5321 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5323 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5327 QVector<SUIT_ViewWindow*> views = vman->getViews();
5328 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5330 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5332 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5333 vtkActorCollection* allActors = aCopy.GetActors();
5334 allActors->InitTraversal();
5335 while (vtkActor* actor = allActors->GetNextActor())
5337 if (actor->GetVisibility()) // store only visible actors
5339 SMESH_Actor* aSmeshActor = 0;
5340 if (actor->IsA("SMESH_Actor"))
5341 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5342 if (aSmeshActor && aSmeshActor->hasIO())
5344 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5347 // entry is "encoded" = it does NOT contain component adress,
5348 // since it is a subject to change on next component loading
5349 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5351 std::string param, vtkParam = vType.toLatin1().data();
5352 vtkParam += gSeparator;
5353 vtkParam += QString::number(vtkViewers).toLatin1().data();
5354 vtkParam += gSeparator;
5357 param = vtkParam + "Visibility";
5358 ip->setParameter(entry, param, "On");
5361 param = vtkParam + "Representation";
5362 ip->setParameter(entry, param, QString::number
5363 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5366 param = vtkParam + "IsShrunk";
5367 ip->setParameter(entry, param, QString::number
5368 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5370 // Displayed entities
5371 unsigned int aMode = aSmeshActor->GetEntityMode();
5372 bool isE = aMode & SMESH_Actor::eEdges;
5373 bool isF = aMode & SMESH_Actor::eFaces;
5374 bool isV = aMode & SMESH_Actor::eVolumes;
5375 bool is0d = aMode & SMESH_Actor::e0DElements;
5376 bool isB = aMode & SMESH_Actor::eBallElem;
5378 QString modeStr ("e");
5379 modeStr += gDigitsSep; modeStr += QString::number(isE);
5380 modeStr += gDigitsSep; modeStr += "f";
5381 modeStr += gDigitsSep; modeStr += QString::number(isF);
5382 modeStr += gDigitsSep; modeStr += "v";
5383 modeStr += gDigitsSep; modeStr += QString::number(isV);
5384 modeStr += gDigitsSep; modeStr += "0d";
5385 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5386 modeStr += gDigitsSep; modeStr += "b";
5387 modeStr += gDigitsSep; modeStr += QString::number(isB);
5389 param = vtkParam + "Entities";
5390 ip->setParameter(entry, param, modeStr.toLatin1().data());
5393 vtkFloatingPointType r, g, b;
5396 aSmeshActor->GetSufaceColor(r, g, b, delta);
5397 QStringList colorStr;
5398 colorStr << "surface";
5399 colorStr << QString::number(r);
5400 colorStr << QString::number(g);
5401 colorStr << QString::number(b);
5403 colorStr << "backsurface";
5404 colorStr << QString::number(delta);
5406 aSmeshActor->GetVolumeColor(r, g, b, delta);
5407 colorStr << "volume";
5408 colorStr << QString::number(r);
5409 colorStr << QString::number(g);
5410 colorStr << QString::number(b);
5411 colorStr << QString::number(delta);
5413 aSmeshActor->GetEdgeColor(r, g, b);
5415 colorStr << QString::number(r);
5416 colorStr << QString::number(g);
5417 colorStr << QString::number(b);
5419 aSmeshActor->GetNodeColor(r, g, b);
5421 colorStr << QString::number(r);
5422 colorStr << QString::number(g);
5423 colorStr << QString::number(b);
5425 aSmeshActor->GetOutlineColor(r, g, b);
5426 colorStr << "outline";
5427 colorStr << QString::number(r);
5428 colorStr << QString::number(g);
5429 colorStr << QString::number(b);
5431 aSmeshActor->Get0DColor(r, g, b);
5432 colorStr << "elem0d";
5433 colorStr << QString::number(r);
5434 colorStr << QString::number(g);
5435 colorStr << QString::number(b);
5437 aSmeshActor->GetBallColor(r, g, b);
5439 colorStr << QString::number(r);
5440 colorStr << QString::number(g);
5441 colorStr << QString::number(b);
5443 aSmeshActor->GetFacesOrientationColor(r, g, b);
5444 colorStr << "orientation";
5445 colorStr << QString::number(r);
5446 colorStr << QString::number(g);
5447 colorStr << QString::number(b);
5449 param = vtkParam + "Colors";
5450 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5453 QStringList sizeStr;
5455 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5456 sizeStr << "outline";
5457 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5458 sizeStr << "elem0d";
5459 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5461 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5462 sizeStr << "shrink";
5463 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5464 sizeStr << "orientation";
5465 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5466 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5468 param = vtkParam + "Sizes";
5469 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5474 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5475 if( aMarkerType == VTK::MT_USER ) {
5476 markerStr += "custom";
5477 markerStr += gDigitsSep;
5478 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5482 markerStr += gDigitsSep;
5483 markerStr += QString::number( (int)aMarkerType );
5484 markerStr += gDigitsSep;
5485 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5488 param = vtkParam + "PointMarker";
5489 ip->setParameter(entry, param, markerStr.toLatin1().data());
5492 param = vtkParam + "Opacity";
5493 ip->setParameter(entry, param,
5494 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5497 param = vtkParam + "ClippingPlane";
5499 if( !aClippingPlaneInfoList.empty() ) {
5500 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5501 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5503 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5504 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5505 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5506 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5507 if( aSmeshActor == *anIter2 ) {
5508 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5509 QString::number( anId ).toLatin1().constData() );
5516 ip->setParameter( entry, param, "Off" );
5517 } // if (io->hasEntry())
5518 } // SMESH_Actor && hasIO
5520 } // while.. actors traversal
5524 } // if (SVTK view model)
5525 } // for (viewManagers)
5528 // data structures for clipping planes processing
5531 vtkIdType Orientation;
5532 vtkFloatingPointType Distance;
5533 vtkFloatingPointType Angle[2];
5535 typedef std::list<TPlaneData> TPlaneDataList;
5536 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5538 typedef std::list<vtkActor*> TActorList;
5541 TActorList ActorList;
5542 SUIT_ViewManager* ViewManager;
5544 typedef std::list<TPlaneInfo> TPlaneInfoList;
5545 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5548 * \brief Restore visual parameters
5550 * This method is called after the study document is opened.
5551 * Restore visual parameters from AttributeParameter attribue(s)
5553 void SMESHGUI::restoreVisualParameters (int savePoint)
5556 Kernel_Utils::Localizer loc;
5558 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5559 if (!appStudy || !appStudy->studyDS())
5561 _PTR(Study) studyDS = appStudy->studyDS();
5563 // componentName is used for encoding of entries when storing them in IParameters
5564 std::string componentName = myComponentSMESH->ComponentDataType();
5565 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5566 //if (!aSComponent) return;
5569 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5570 componentName.c_str(),
5572 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5574 // restore map of custom markers and map of clipping planes
5575 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5576 TPlaneDataMap aPlaneDataMap;
5578 std::vector<std::string> properties = ip->getProperties();
5579 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5581 std::string property = *propIt;
5582 QString aPropertyName( property.c_str() );
5583 QString aPropertyValue( ip->getProperty( property ).c_str() );
5585 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5586 if( aPropertyNameList.isEmpty() )
5589 QString aPropertyType = aPropertyNameList[0];
5590 if( aPropertyType == "texture" )
5592 if( aPropertyNameList.size() != 2 )
5596 int anId = aPropertyNameList[1].toInt( &ok );
5597 if( !ok || anId < 1 )
5600 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5601 if( aPropertyValueList.size() != 2 )
5604 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5605 QString aMarkerTextureString = aPropertyValueList[1];
5606 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5607 if( aMarkerTextureStringList.size() != 3 )
5611 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5616 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5620 VTK::MarkerTexture aMarkerTexture;
5621 aMarkerTexture.push_back( aWidth );
5622 aMarkerTexture.push_back( aHeight );
5624 QString aMarkerTextureData = aMarkerTextureStringList[2];
5625 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5627 QChar aChar = aMarkerTextureData.at( i );
5628 if( aChar.isDigit() )
5629 aMarkerTexture.push_back( aChar.digitValue() );
5632 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5634 else if( aPropertyType == "ClippingPlane" )
5636 if( aPropertyNameList.size() != 3 )
5640 int aViewId = aPropertyNameList[1].toInt( &ok );
5641 if( !ok || aViewId < 0 )
5645 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5646 if( !ok || aClippingPlaneId < 0 )
5649 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5650 if( aPropertyValueList.size() != 4 )
5653 TPlaneData aPlaneData;
5654 aPlaneData.Id = aClippingPlaneId;
5657 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5662 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5667 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5672 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5676 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5677 aPlaneDataList.push_back( aPlaneData );
5681 TPlaneInfoMap aPlaneInfoMap;
5683 std::vector<std::string> entries = ip->getEntries();
5685 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5687 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5688 QString entry (ip->decodeEntry(*entIt).c_str());
5690 // Check that the entry corresponds to a real object in the Study
5691 // as the object may be deleted or modified after the visual state is saved.
5692 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5693 if (!so) continue; //Skip the not existent entry
5695 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5696 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5698 std::vector<std::string>::iterator namesIt = paramNames.begin();
5699 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5701 // actors are stored in a map after displaying of them for
5702 // quicker access in the future: map < viewID to actor >
5703 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5705 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5707 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5708 // '_' is used as separator and should not be used in viewer type or parameter names.
5709 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5710 if (lst.size() != 3)
5713 QString viewerTypStr = lst[0];
5714 QString viewIndexStr = lst[1];
5715 QString paramNameStr = lst[2];
5718 int viewIndex = viewIndexStr.toUInt(&ok);
5719 if (!ok) // bad conversion of view index to integer
5723 if (viewerTypStr == SVTK_Viewer::Type())
5725 SMESH_Actor* aSmeshActor = 0;
5726 if (vtkActors.IsBound(viewIndex))
5727 aSmeshActor = vtkActors.Find(viewIndex);
5729 QList<SUIT_ViewManager*> lst;
5730 getApp()->viewManagers(viewerTypStr, lst);
5732 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5733 SUIT_ViewManager* vman = NULL;
5734 if (viewIndex >= 0 && viewIndex < lst.count())
5735 vman = lst.at(viewIndex);
5737 if (paramNameStr == "Visibility")
5739 if (!aSmeshActor && displayer() && vman)
5741 SUIT_ViewModel* vmodel = vman->getViewModel();
5742 // SVTK view model can be casted to SALOME_View
5743 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5745 // store displayed actor in a temporary map for quicker
5746 // access later when restoring other parameters
5747 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5748 vtkRenderer* Renderer = vtkView->getRenderer();
5749 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5750 vtkActorCollection* theActors = aCopy.GetActors();
5751 theActors->InitTraversal();
5752 bool isFound = false;
5753 vtkActor *ac = theActors->GetNextActor();
5754 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5755 if (ac->IsA("SMESH_Actor")) {
5756 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5757 if (aGeomAc->hasIO()) {
5758 Handle(SALOME_InteractiveObject) io =
5759 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5760 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5762 vtkActors.Bind(viewIndex, aGeomAc);
5768 } // if (paramNameStr == "Visibility")
5771 // the rest properties "work" with SMESH_Actor
5774 QString val ((*valuesIt).c_str());
5777 if (paramNameStr == "Representation") {
5778 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5781 else if (paramNameStr == "IsShrunk") {
5783 if (!aSmeshActor->IsShrunk())
5784 aSmeshActor->SetShrink();
5787 if (aSmeshActor->IsShrunk())
5788 aSmeshActor->UnShrink();
5791 // Displayed entities
5792 else if (paramNameStr == "Entities") {
5793 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5794 int aEntityMode = SMESH_Actor::eAllEntity;
5795 for ( int i = 0; i < mode.count(); i+=2 ) {
5796 if ( i < mode.count()-1 ) {
5797 QString type = mode[i];
5798 bool val = mode[i+1].toInt();
5799 if ( type == "e" && !val )
5800 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
5801 else if ( type == "f" && !val )
5802 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
5803 else if ( type == "v" && !val )
5804 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
5805 else if ( type == "0d" && !val )
5806 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
5807 else if ( type == "b" && !val )
5808 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
5811 aSmeshActor->SetEntityMode( aEntityMode );
5814 else if (paramNameStr == "Colors") {
5815 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5822 QColor outlineColor;
5823 QColor orientationColor;
5829 // below lines are required to get default values for delta coefficients
5830 // of backface color for faces and color of reversed volumes
5831 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
5832 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
5833 for ( int i = 0; i < colors.count(); i++ ) {
5834 QString type = colors[i];
5835 if ( type == "surface" ) {
5836 // face color is set by 3 values r:g:b, where
5837 // - r,g,b - is rgb color components
5838 if ( i+1 >= colors.count() ) break; // format error
5839 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5840 if ( i+2 >= colors.count() ) break; // format error
5841 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5842 if ( i+3 >= colors.count() ) break; // format error
5843 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5844 faceColor.setRgbF( r, g, b );
5847 else if ( type == "backsurface" ) {
5848 // backface color can be defined in several ways
5849 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
5850 // - in latest versions, it is set as delta coefficient
5851 bool rgbOk = false, deltaOk;
5852 if ( i+1 >= colors.count() ) break; // format error
5853 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5854 int delta = colors[i+1].toInt( &deltaOk );
5856 if ( i+1 < colors.count() ) // index is shifted to 1
5857 g = colors[i+1].toDouble( &rgbOk );
5858 if ( rgbOk ) i++; // shift index
5859 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
5860 b = colors[i+1].toDouble( &rgbOk );
5862 // - as currently there's no way to set directly backsurface color as it was before,
5863 // we ignore old dump where r,g,b triple was set
5864 // - also we check that delta parameter is set properly
5865 if ( !rgbOk && deltaOk )
5868 else if ( type == "volume" ) {
5869 // volume color is set by 4 values r:g:b:delta, where
5870 // - r,g,b - is a normal volume rgb color components
5871 // - delta - is a reversed volume color delta coefficient
5872 if ( i+1 >= colors.count() ) break; // format error
5873 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5874 if ( i+2 >= colors.count() ) break; // format error
5875 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5876 if ( i+3 >= colors.count() ) break; // format error
5877 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5878 if ( i+4 >= colors.count() ) break; // format error
5879 int delta = colors[i+4].toInt( &bOk );
5880 if ( !bOk ) break; // format error
5881 volumeColor.setRgbF( r, g, b );
5885 else if ( type == "edge" ) {
5886 // edge color is set by 3 values r:g:b, where
5887 // - r,g,b - is rgb color components
5888 if ( i+1 >= colors.count() ) break; // format error
5889 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5890 if ( i+2 >= colors.count() ) break; // format error
5891 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5892 if ( i+3 >= colors.count() ) break; // format error
5893 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5894 edgeColor.setRgbF( r, g, b );
5897 else if ( type == "node" ) {
5898 // node color is set by 3 values r:g:b, where
5899 // - r,g,b - is rgb color components
5900 if ( i+1 >= colors.count() ) break; // format error
5901 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5902 if ( i+2 >= colors.count() ) break; // format error
5903 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5904 if ( i+3 >= colors.count() ) break; // format error
5905 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5906 nodeColor.setRgbF( r, g, b );
5909 else if ( type == "elem0d" ) {
5910 // 0d element color is set by 3 values r:g:b, where
5911 // - r,g,b - is rgb color components
5912 if ( i+1 >= colors.count() ) break; // format error
5913 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5914 if ( i+2 >= colors.count() ) break; // format error
5915 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5916 if ( i+3 >= colors.count() ) break; // format error
5917 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5918 elem0dColor.setRgbF( r, g, b );
5921 else if ( type == "ball" ) {
5922 // ball color is set by 3 values r:g:b, where
5923 // - r,g,b - is rgb color components
5924 if ( i+1 >= colors.count() ) break; // format error
5925 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5926 if ( i+2 >= colors.count() ) break; // format error
5927 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5928 if ( i+3 >= colors.count() ) break; // format error
5929 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5930 ballColor.setRgbF( r, g, b );
5933 else if ( type == "outline" ) {
5934 // outline color is set by 3 values r:g:b, where
5935 // - r,g,b - is rgb color components
5936 if ( i+1 >= colors.count() ) break; // format error
5937 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5938 if ( i+2 >= colors.count() ) break; // format error
5939 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5940 if ( i+3 >= colors.count() ) break; // format error
5941 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5942 outlineColor.setRgbF( r, g, b );
5945 else if ( type == "orientation" ) {
5946 // orientation color is set by 3 values r:g:b, where
5947 // - r,g,b - is rgb color components
5948 if ( i+1 >= colors.count() ) break; // format error
5949 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5950 if ( i+2 >= colors.count() ) break; // format error
5951 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5952 if ( i+3 >= colors.count() ) break; // format error
5953 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5954 orientationColor.setRgbF( r, g, b );
5959 if ( nodeColor.isValid() )
5960 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
5962 if ( edgeColor.isValid() )
5963 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
5965 if ( faceColor.isValid() )
5966 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
5968 if ( volumeColor.isValid() )
5969 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
5970 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
5971 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
5973 if ( elem0dColor.isValid() )
5974 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
5976 if ( ballColor.isValid() )
5977 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
5979 if ( outlineColor.isValid() )
5980 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
5981 // orientation color
5982 if ( orientationColor.isValid() )
5983 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
5986 else if (paramNameStr == "Sizes") {
5987 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
5990 int outlineWidth = -1;
5991 int elem0dSize = -1;
5993 double shrinkSize = -1;
5994 double orientationSize = -1;
5995 bool orientation3d = false;
5996 for ( int i = 0; i < sizes.count(); i++ ) {
5997 QString type = sizes[i];
5998 if ( type == "line" ) {
5999 // line (wireframe) width is given as single integer value
6000 if ( i+1 >= sizes.count() ) break; // format error
6001 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6005 if ( type == "outline" ) {
6006 // outline width is given as single integer value
6007 if ( i+1 >= sizes.count() ) break; // format error
6008 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6012 else if ( type == "elem0d" ) {
6013 // 0d element size is given as single integer value
6014 if ( i+1 >= sizes.count() ) break; // format error
6015 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6019 else if ( type == "ball" ) {
6020 // ball size is given as single integer value
6021 if ( i+1 >= sizes.count() ) break; // format error
6022 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6026 else if ( type == "shrink" ) {
6027 // shrink factor is given as single floating point value
6028 if ( i+1 >= sizes.count() ) break; // format error
6029 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6033 else if ( type == "orientation" ) {
6034 // orientation vectors are specified by two values size:3d, where
6035 // - size - is a floating point value specifying scale factor
6036 // - 3d - is a boolean
6037 if ( i+1 >= sizes.count() ) break; // format error
6038 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6039 if ( i+2 >= sizes.count() ) break; // format error
6040 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6041 orientationSize = v1;
6042 orientation3d = (bool)v2;
6046 // line (wireframe) width
6047 if ( lineWidth > 0 )
6048 aSmeshActor->SetLineWidth( lineWidth );
6050 if ( outlineWidth > 0 )
6051 aSmeshActor->SetOutlineWidth( outlineWidth );
6052 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6053 aSmeshActor->SetOutlineWidth( lineWidth );
6055 if ( elem0dSize > 0 )
6056 aSmeshActor->Set0DSize( elem0dSize );
6059 aSmeshActor->SetBallSize( ballSize );
6061 if ( shrinkSize > 0 )
6062 aSmeshActor->SetShrinkFactor( shrinkSize );
6063 // orientation vectors
6064 if ( orientationSize > 0 ) {
6065 aSmeshActor->SetFacesOrientationScale( orientationSize );
6066 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6070 else if (paramNameStr == "PointMarker") {
6071 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6072 if( data.count() >= 2 ) {
6074 int aParam1 = data[1].toInt( &ok );
6076 if( data[0] == "std" && data.count() == 3 ) {
6077 int aParam2 = data[2].toInt( &ok );
6078 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6080 else if( data[0] == "custom" ) {
6081 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6082 if( markerIt != aMarkerMap.end() ) {
6083 VTK::MarkerData aMarkerData = markerIt->second;
6084 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6091 else if (paramNameStr == "Opacity") {
6092 aSmeshActor->SetOpacity(val.toFloat());
6095 else if (paramNameStr.startsWith("ClippingPlane")) {
6096 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6097 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
6098 // new format - val looks like "Off" or "0" (plane id)
6099 // (note: in new format "Off" value is used only for consistency,
6100 // so it is processed together with values in old format)
6101 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
6102 if( anIsOldFormat ) {
6103 if (paramNameStr == "ClippingPlane1" || val == "Off")
6104 aSmeshActor->RemoveAllClippingPlanes();
6106 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
6107 double aDistance = vals[1].toFloat();
6108 vtkFloatingPointType anAngle[2];
6109 anAngle[0] = vals[2].toFloat();
6110 anAngle[1] = vals[3].toFloat();
6112 QList<SUIT_ViewManager*> lst;
6113 getApp()->viewManagers(viewerTypStr, lst);
6114 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6115 if (viewIndex >= 0 && viewIndex < lst.count()) {
6116 SUIT_ViewManager* vman = lst.at(viewIndex);
6117 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6119 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6121 SMESH::TActorList anActorList;
6122 anActorList.push_back( aSmeshActor );
6123 SMESH::OrientedPlane* aPlane =
6124 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
6126 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6127 aClippingPlaneInfo.Plane = aPlane;
6128 aClippingPlaneInfo.ActorList = anActorList;
6129 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6136 int aPlaneId = val.toInt( &ok );
6137 if( ok && aPlaneId >= 0 ) {
6138 bool anIsDefinedPlane = false;
6139 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6140 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6141 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6142 TPlaneInfo& aPlaneInfo = *anIter;
6143 if( aPlaneInfo.PlaneId == aPlaneId ) {
6144 aPlaneInfo.ActorList.push_back( aSmeshActor );
6145 anIsDefinedPlane = true;
6149 if( !anIsDefinedPlane ) {
6150 TPlaneInfo aPlaneInfo;
6151 aPlaneInfo.PlaneId = aPlaneId;
6152 aPlaneInfo.ActorList.push_back( aSmeshActor );
6153 aPlaneInfo.ViewManager = vman;
6155 // to make the list sorted by plane id
6156 anIter = aPlaneInfoList.begin();
6157 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6158 const TPlaneInfo& aPlaneInfoRef = *anIter;
6159 if( aPlaneInfoRef.PlaneId > aPlaneId )
6162 aPlaneInfoList.insert( anIter, aPlaneInfo );
6167 } // if (aSmeshActor)
6168 } // other parameters than Visibility
6170 } // for names/parameters iterator
6171 } // for entries iterator
6173 // take into account planes with empty list of actors referred to them
6174 QList<SUIT_ViewManager*> aVMList;
6175 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6177 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6178 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6179 int aViewId = aPlaneDataIter->first;
6180 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6181 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6183 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6185 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6186 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6187 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6188 const TPlaneData& aPlaneData = *anIter2;
6189 int aPlaneId = aPlaneData.Id;
6191 bool anIsFound = false;
6192 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6193 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6194 const TPlaneInfo& aPlaneInfo = *anIter3;
6195 if( aPlaneInfo.PlaneId == aPlaneId ) {
6202 TPlaneInfo aPlaneInfo; // ActorList field is empty
6203 aPlaneInfo.PlaneId = aPlaneId;
6204 aPlaneInfo.ViewManager = aViewManager;
6206 // to make the list sorted by plane id
6207 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6208 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6209 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6210 if( aPlaneInfoRef.PlaneId > aPlaneId )
6213 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6219 // add clipping planes to actors according to the restored parameters
6220 // and update the clipping plane map
6221 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6222 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6223 int aViewId = anIter1->first;
6224 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6226 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6227 if( anIter2 == aPlaneDataMap.end() )
6229 const TPlaneDataList& aPlaneDataList = anIter2->second;
6231 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6232 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6233 const TPlaneInfo& aPlaneInfo = *anIter3;
6234 int aPlaneId = aPlaneInfo.PlaneId;
6235 const TActorList& anActorList = aPlaneInfo.ActorList;
6236 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6240 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6244 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6246 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6247 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6248 const TPlaneData& aPlaneData = *anIter4;
6249 if( aPlaneData.Id == aPlaneId ) {
6250 SMESH::OrientedPlane* aPlane =
6251 SMESHGUI_ClippingDlg::AddPlane( anActorList,
6253 (SMESH::Orientation)aPlaneData.Orientation,
6254 aPlaneData.Distance,
6257 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6258 aClippingPlaneInfo.Plane = aPlane;
6259 aClippingPlaneInfo.ActorList = anActorList;
6260 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6268 // update all VTK views
6269 QList<SUIT_ViewManager*> lst;
6270 getApp()->viewManagers(lst);
6271 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6272 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6273 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6274 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6275 vtkView->getRenderer()->ResetCameraClippingRange();
6282 \brief Adds preferences for dfont of VTK viewer
6284 \param pIf group identifier
6285 \param param parameter
6286 \return identifier of preferences
6288 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
6290 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6292 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6295 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6296 fam.append( tr( "SMESH_FONT_COURIER" ) );
6297 fam.append( tr( "SMESH_FONT_TIMES" ) );
6299 setPreferenceProperty( tfont, "fonts", fam );
6301 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6302 setPreferenceProperty( tfont, "features", f );
6308 \brief Actions after hypothesis edition
6309 Updates object browser after hypothesis edition
6311 void SMESHGUI::onHypothesisEdit( int result )
6314 SMESHGUI::Modified();
6315 updateObjBrowser( true );
6320 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6321 \param pview view being closed
6323 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6324 #ifndef DISABLE_PLOT2DVIEWER
6325 //Crear all Plot2d Viewers if need.
6326 SMESH::ClearPlot2Viewers(pview);
6330 void SMESHGUI::message( const QString& msg )
6333 QStringList data = msg.split("/");
6334 if ( data.count() > 0 ) {
6335 if ( data.first() == "mesh_loading" ) {
6337 QString entry = data.count() > 1 ? data[1] : QString();
6338 if ( entry.isEmpty() )
6341 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6343 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6346 name = obj->GetName().c_str();
6347 if ( name.isEmpty() )
6350 if ( data.last() == "stop" )
6351 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6353 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6354 QApplication::processEvents();
6360 \brief Connects or disconnects signals about activating and cloning view on the module slots
6361 \param pview view which is connected/disconnected
6363 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6367 SUIT_ViewManager* viewMgr = pview->getViewManager();
6369 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6370 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6372 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6373 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6378 \brief Return \c true if object can be renamed
6380 bool SMESHGUI::renameAllowed( const QString& entry) const {
6381 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6385 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6389 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6394 if(appStudy->isComponent(entry) || obj->isReference())
6397 // check type to prevent renaming of inappropriate objects
6398 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6399 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6400 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6401 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6402 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6403 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6410 Rename object by entry.
6411 \param entry entry of the object
6412 \param name new name of the object
6413 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6415 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6417 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6421 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6426 _PTR(Study) aStudy = appStudy->studyDS();
6431 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6433 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6438 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6439 _PTR(GenericAttribute) anAttr;
6440 _PTR(AttributeName) aName;
6442 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6444 // check type to prevent renaming of inappropriate objects
6445 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6446 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6447 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6448 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6449 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6450 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6451 if ( !name.isEmpty() ) {
6452 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6454 // update name of group object and its actor
6455 Handle(SALOME_InteractiveObject) IObject =
6456 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6458 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6459 if( !aGroupObject->_is_nil() ) {
6460 aGroupObject->SetName( qPrintable(name) );
6461 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6462 anActor->setName( qPrintable(name) );