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 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, HYPOTHESIS, "Hypothesis", aTypeName ) ||
1613 CheckOIType ( theIO, ALGORITHM, "Algorithm", aTypeName ) ||
1614 CheckOIType ( theIO, MESH, "Mesh", aTypeName ) ||
1615 CheckOIType ( theIO, SUBMESH, "SubMesh", aTypeName ) ||
1616 CheckOIType ( theIO, 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,
3500 parentId = popupMgr()->actionId( action( pId ) );
3502 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3503 popupMgr()->insert( action( id ), parentId, 0 );
3505 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3506 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3507 QString rule = "(%1) and (%2) and (%3)";
3508 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3509 if( clients.isEmpty() )
3510 rule = rule.arg( QString( "true" ) );
3512 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3513 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3516 bool cont = myRules.contains( id );
3518 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3520 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3521 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3524 //=======================================================================
3525 // function : initialize
3527 //=======================================================================
3528 void SMESHGUI::initialize( CAM_Application* app )
3530 SalomeApp_Module::initialize( app );
3532 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3534 /* Automatic Update flag */
3535 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3537 // ----- create actions --------------
3539 //createSMESHAction( 111, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3540 createSMESHAction( 112, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3541 createSMESHAction( 113, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3542 createSMESHAction( 114, "NUM" );
3543 createSMESHAction( 115, "IMPORT_STL" );
3544 createSMESHAction( 116, "IMPORT_CGNS" );
3545 createSMESHAction( 117, "IMPORT_SAUV" );
3546 createSMESHAction( 118, "IMPORT_GMF" );
3547 createSMESHAction( 121, "DAT" );
3548 createSMESHAction( 122, "MED" );
3549 createSMESHAction( 123, "UNV" );
3550 createSMESHAction( 140, "STL" );
3551 createSMESHAction( 142, "CGNS");
3552 createSMESHAction( 144, "SAUV");
3553 createSMESHAction( 146, "GMF" );
3554 createSMESHAction( 124, "EXPORT_DAT" );
3555 createSMESHAction( 125, "EXPORT_MED" );
3556 createSMESHAction( 126, "EXPORT_UNV" );
3557 createSMESHAction( 141, "EXPORT_STL" );
3558 createSMESHAction( 143, "EXPORT_CGNS");
3559 createSMESHAction( 145, "EXPORT_SAUV");
3560 createSMESHAction( 147, "EXPORT_GMF" );
3561 createSMESHAction( 150, "FILE_INFO" );
3562 createSMESHAction( 33, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3563 createSMESHAction( 5105, "SEL_FILTER_LIB" );
3564 createSMESHAction( 701, "COMPUTE", "ICON_COMPUTE" );
3565 createSMESHAction( 702, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3566 createSMESHAction( 703, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3567 createSMESHAction( 704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3568 createSMESHAction( 705, "COPY_MESH", "ICON_COPY_MESH" );
3569 createSMESHAction( 710, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3570 createSMESHAction( 711, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3571 createSMESHAction( 712, "EVALUATE", "ICON_COMPUTE" );
3572 createSMESHAction( 713, "MESH_ORDER", "ICON_COMPUTE" );
3573 createSMESHAction( 806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3574 createSMESHAction( 801, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3575 createSMESHAction( 802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3576 createSMESHAction( 803, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3577 createSMESHAction( 815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3578 createSMESHAction( 804, "ADD" );
3579 createSMESHAction( 805, "REMOVE" );
3580 createSMESHAction( 810, "UN_GROUP", "ICON_UNION" );
3581 createSMESHAction( 811, "INT_GROUP", "ICON_INTERSECT" );
3582 createSMESHAction( 812, "CUT_GROUP", "ICON_CUT" );
3583 createSMESHAction( 814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3584 createSMESHAction( 813, "DEL_GROUP", "ICON_DEL_GROUP" );
3585 createSMESHAction( 900, "ADV_INFO", "ICON_ADV_INFO" );
3586 //createSMESHAction( 902, "STD_INFO", "ICON_STD_INFO" );
3587 //createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3588 createSMESHAction( 904, "FIND_ELEM", "ICON_FIND_ELEM" );
3589 createSMESHAction( 6001, "LENGTH", "ICON_LENGTH", 0, true );
3590 createSMESHAction( 6002, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3591 createSMESHAction( 6021, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3592 createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3593 createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3594 createSMESHAction( 6024, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3595 createSMESHAction( 6025, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3596 createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3597 createSMESHAction( 6027, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3598 createSMESHAction( 6028, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3599 createSMESHAction( 6029, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3600 createSMESHAction( 6030, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3601 createSMESHAction( 6031, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3602 createSMESHAction( 6003, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3603 createSMESHAction( 6004, "CONNECTION", "ICON_CONNECTION", 0, true );
3604 createSMESHAction( 6005, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3605 createSMESHAction( 6011, "AREA", "ICON_AREA", 0, true );
3606 createSMESHAction( 6012, "TAPER", "ICON_TAPER", 0, true );
3607 createSMESHAction( 6013, "ASPECT", "ICON_ASPECT", 0, true );
3608 createSMESHAction( 6014, "MIN_ANG", "ICON_ANGLE", 0, true );
3609 createSMESHAction( 6015, "WARP", "ICON_WARP", 0, true );
3610 createSMESHAction( 6016, "SKEW", "ICON_SKEW", 0, true );
3611 createSMESHAction( 6017, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3612 createSMESHAction( 6018, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3613 createSMESHAction( 6019, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3614 createSMESHAction( 6009, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3615 createSMESHAction( 4000, "NODE", "ICON_DLG_NODE" );
3616 createSMESHAction( 4009, "ELEM0D", "ICON_DLG_ELEM0D" );
3617 createSMESHAction( 4008, "BALL", "ICON_DLG_BALL" );
3618 createSMESHAction( 4010, "EDGE", "ICON_DLG_EDGE" );
3619 createSMESHAction( 4021, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3620 createSMESHAction( 4022, "QUAD", "ICON_DLG_QUADRANGLE" );
3621 createSMESHAction( 4023, "POLYGON", "ICON_DLG_POLYGON" );
3622 createSMESHAction( 4031, "TETRA", "ICON_DLG_TETRAS" );
3623 createSMESHAction( 4032, "HEXA", "ICON_DLG_HEXAS" );
3624 createSMESHAction( 4133, "PENTA", "ICON_DLG_PENTA" );
3625 createSMESHAction( 4134, "PYRAMID", "ICON_DLG_PYRAMID" );
3626 createSMESHAction( 4135, "OCTA", "ICON_DLG_OCTA" );
3627 createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3628 createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3629 createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3630 createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3631 createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3632 createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3633 createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3634 createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3635 createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3636 createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3637 createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3638 createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3639 createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3640 createSMESHAction( 4043, "CLEAR_MESH" , "ICON_CLEAR_MESH" );
3641 createSMESHAction( 4051, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3642 createSMESHAction( 4052, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3643 createSMESHAction( 4061, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3644 createSMESHAction( 4062, "ROT", "ICON_DLG_MESH_ROTATION" );
3645 createSMESHAction( 4063, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3646 createSMESHAction( 4064, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3647 createSMESHAction( 4065, "MERGE", "ICON_SMESH_MERGE_NODES" );
3648 createSMESHAction( 4066, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3649 createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3650 createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" );
3651 createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3652 createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" );
3653 createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" );
3654 createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3655 createSMESHAction( 410, "UNION", "ICON_UNIONTRI" );
3656 createSMESHAction( 411, "CUT", "ICON_CUTQUAD" );
3657 createSMESHAction( 412, "SMOOTH", "ICON_DLG_SMOOTHING" );
3658 createSMESHAction( 413, "EXTRUSION", "ICON_EXTRUSION" );
3659 createSMESHAction( 414, "REVOLUTION", "ICON_REVOLUTION" );
3660 createSMESHAction( 415, "MAP", "ICON_MAP" );
3661 createSMESHAction( 416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3662 createSMESHAction( 417, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3663 createSMESHAction( 418, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3664 createSMESHAction( 419, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3665 createSMESHAction( 420, "REORIENT_2D", "ICON_REORIENT_2D" );
3666 createSMESHAction( 200, "RESET" );
3667 createSMESHAction( 201, "SCALAR_BAR_PROP" );
3668 createSMESHAction( 2021, "SAVE_DISTRIBUTION" );
3669 createSMESHAction( 2022, "SHOW_DISTRIBUTION","",0, true );
3670 #ifndef DISABLE_PLOT2DVIEWER
3671 createSMESHAction( 2023, "PLOT_DISTRIBUTION" );
3673 createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true );
3674 createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true );
3675 createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true );
3676 createSMESHAction( 214, "UPDATE", "ICON_UPDATE" );
3677 createSMESHAction( 215, "NODES", "ICON_POINTS", 0, true );
3678 createSMESHAction( 222, "BALLS", "ICON_DLG_BALL", 0, true );
3679 createSMESHAction( 216, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3680 createSMESHAction( 217, "EDGES", "ICON_DLG_EDGE", 0, true );
3681 createSMESHAction( 218, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3682 createSMESHAction( 219, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3683 createSMESHAction( 220, "ALL" );
3684 createSMESHAction( 221, "FACE_ORIENTATION", "", 0, true );
3686 createSMESHAction( 231, "LINE_REPRESENTATION", "", 0, true );
3687 createSMESHAction( 232, "ARC_REPRESENTATION", "", 0, true );
3689 createSMESHAction( 1100, "EDIT_HYPO" );
3690 createSMESHAction( 1102, "UNASSIGN" );
3691 createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3692 createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3693 createSMESHAction( 1131, "DISPMODE" );
3694 createSMESHAction( 1132, "COLORS" );
3695 createSMESHAction( 1133, "TRANSP" );
3696 createSMESHAction( 1134, "CLIP" );
3697 createSMESHAction( 1135, "DISP_ENT" );
3698 createSMESHAction( 1136, "AUTO_COLOR" );
3699 createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3700 createSMESHAction( 2000, "CTRL" );
3702 createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3703 createSMESHAction( 502, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3705 createSMESHAction( 300, "HIDE" );
3706 createSMESHAction( 301, "SHOW" );
3707 createSMESHAction( 302, "DISPLAY_ONLY" );
3709 // ----- create menu --------------
3710 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3711 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3712 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3713 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3714 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3715 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3716 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3717 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3719 createMenu( separator(), fileId );
3721 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3722 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3723 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3724 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3725 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3726 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3727 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3728 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3729 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3730 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3732 //createMenu( 111, importId, -1 );
3733 createMenu( 112, importId, -1 );
3734 createMenu( 113, importId, -1 );
3735 createMenu( 115, importId, -1 );
3737 createMenu( 116, importId, -1 );
3739 createMenu( 117, importId, -1 );
3740 createMenu( 118, importId, -1 );
3741 createMenu( 121, exportId, -1 );
3742 createMenu( 122, exportId, -1 );
3743 createMenu( 123, exportId, -1 );
3744 createMenu( 140, exportId, -1 ); // export to STL
3746 createMenu( 142, exportId, -1 ); // export to CGNS
3748 createMenu( 144, exportId, -1 ); // export to SAUV
3749 createMenu( 146, exportId, -1 ); // export to GMF
3750 createMenu( separator(), fileId, 10 );
3752 createMenu( 33, editId, -1 );
3754 createMenu( 5105, toolsId, -1 );
3756 createMenu( 702, meshId, -1 ); // "Mesh" menu
3757 createMenu( 703, meshId, -1 );
3758 createMenu( 704, meshId, -1 );
3759 createMenu( 710, meshId, -1 );
3760 createMenu( 705, meshId, -1 );
3761 createMenu( separator(), meshId, -1 );
3762 createMenu( 701, meshId, -1 );
3763 createMenu( 711, meshId, -1 );
3764 createMenu( 712, meshId, -1 );
3765 createMenu( 713, meshId, -1 );
3766 createMenu( separator(), meshId, -1 );
3767 createMenu( 801, meshId, -1 );
3768 createMenu( 806, meshId, -1 );
3769 createMenu( 802, meshId, -1 );
3770 createMenu( 803, meshId, -1 );
3771 createMenu( 815, meshId, -1 );
3772 createMenu( separator(), meshId, -1 );
3773 createMenu( 810, meshId, -1 );
3774 createMenu( 811, meshId, -1 );
3775 createMenu( 812, meshId, -1 );
3776 createMenu( separator(), meshId, -1 );
3777 createMenu( 814, meshId, -1 );
3778 createMenu( separator(), meshId, -1 );
3779 createMenu( 900, meshId, -1 );
3780 //createMenu( 902, meshId, -1 );
3781 //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3782 createMenu( 904, meshId, -1 );
3783 createMenu( separator(), meshId, -1 );
3785 createMenu( 6005, nodeId, -1 );
3786 createMenu( 6028, nodeId, -1 );
3787 createMenu( 6002, edgeId, -1 );
3788 createMenu( 6003, edgeId, -1 );
3789 createMenu( 6001, edgeId, -1 );
3790 createMenu( 6004, edgeId, -1 );
3791 createMenu( 6029, edgeId, -1 );
3792 createMenu( 6021, faceId, -1 );
3793 createMenu( 6025, faceId, -1 );
3794 createMenu( 6027, faceId, -1 );
3795 createMenu( 6018, faceId, -1 );
3796 createMenu( 6019, faceId, -1 );
3797 createMenu( 6011, faceId, -1 );
3798 createMenu( 6012, faceId, -1 );
3799 createMenu( 6013, faceId, -1 );
3800 createMenu( 6014, faceId, -1 );
3801 createMenu( 6015, faceId, -1 );
3802 createMenu( 6016, faceId, -1 );
3803 createMenu( 6022, faceId, -1 );
3804 createMenu( 6030, faceId, -1 );
3805 createMenu( 6017, volumeId, -1 );
3806 createMenu( 6009, volumeId, -1 );
3807 createMenu( 6023, volumeId, -1 );
3808 createMenu( 6024, volumeId, -1 );
3809 createMenu( 6026, volumeId, -1 );
3810 createMenu( 6031, volumeId, -1 );
3812 createMenu( 4000, addId, -1 );
3813 createMenu( 4009, addId, -1 );
3814 createMenu( 4008, addId, -1 );
3815 createMenu( 4010, addId, -1 );
3816 createMenu( 4021, addId, -1 );
3817 createMenu( 4022, addId, -1 );
3818 createMenu( 4023, addId, -1 );
3819 createMenu( 4031, addId, -1 );
3820 createMenu( 4032, addId, -1 );
3821 createMenu( 4133, addId, -1 );
3822 createMenu( 4134, addId, -1 );
3823 createMenu( 4135, addId, -1 );
3824 createMenu( 4033, addId, -1 );
3825 createMenu( separator(), addId, -1 );
3826 createMenu( 4034, addId, -1 );
3827 createMenu( 4035, addId, -1 );
3828 createMenu( 4036, addId, -1 );
3829 createMenu( 4136, addId, -1 );
3830 createMenu( 4037, addId, -1 );
3831 createMenu( 4038, addId, -1 );
3832 createMenu( 4039, addId, -1 );
3833 createMenu( 4040, addId, -1 );
3834 createMenu( 4140, addId, -1 );
3836 createMenu( 4041, removeId, -1 );
3837 createMenu( 4042, removeId, -1 );
3838 createMenu( 4044, removeId, -1 );
3839 createMenu( separator(), removeId, -1 );
3840 createMenu( 813, removeId, -1 );
3841 createMenu( separator(), removeId, -1 );
3842 createMenu( 4043, removeId, -1 );
3844 createMenu( 4051, renumId, -1 );
3845 createMenu( 4052, renumId, -1 );
3847 createMenu( 4061, transfId, -1 );
3848 createMenu( 4062, transfId, -1 );
3849 createMenu( 4063, transfId, -1 );
3850 createMenu( 4068, transfId, -1 );
3851 createMenu( 4064, transfId, -1 );
3852 createMenu( 4065, transfId, -1 );
3853 createMenu( 4066, transfId, -1 );
3854 createMenu( 4069, transfId, -1 );
3856 createMenu( 4067,modifyId, -1 );
3857 createMenu( 407, modifyId, -1 );
3858 createMenu( 408, modifyId, -1 );
3859 createMenu( 409, modifyId, -1 );
3860 createMenu( 420, modifyId, -1 );
3861 createMenu( 410, modifyId, -1 );
3862 createMenu( 411, modifyId, -1 );
3863 createMenu( 419, modifyId, -1 );
3864 createMenu( 412, modifyId, -1 );
3865 createMenu( 413, modifyId, -1 );
3866 createMenu( 416, modifyId, -1 );
3867 createMenu( 414, modifyId, -1 );
3868 createMenu( 415, modifyId, -1 );
3869 createMenu( 417, modifyId, -1 );
3870 createMenu( 418, modifyId, -1 );
3872 createMenu( 501, measureId, -1 );
3873 createMenu( 502, measureId, -1 );
3874 createMenu( 214, viewId, -1 );
3876 // ----- create toolbars --------------
3877 int meshTb = createTool( tr( "TB_MESH" ) ),
3878 ctrlTb = createTool( tr( "TB_CTRL" ) ),
3879 addRemTb = createTool( tr( "TB_ADD_REMOVE" ) ),
3880 modifyTb = createTool( tr( "TB_MODIFY" ) ),
3881 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
3883 createTool( 702, meshTb );
3884 createTool( 703, meshTb );
3885 createTool( 704, meshTb );
3886 createTool( 710, meshTb );
3887 createTool( 705, meshTb );
3888 createTool( separator(), meshTb );
3889 createTool( 701, meshTb );
3890 createTool( 711, meshTb );
3891 createTool( 712, meshTb );
3892 createTool( 713, meshTb );
3893 createTool( separator(), meshTb );
3894 createTool( 801, meshTb );
3895 createTool( 806, meshTb );
3896 createTool( 802, meshTb );
3897 createTool( 803, meshTb );
3898 //createTool( 815, meshTb );
3899 createTool( separator(), meshTb );
3900 createTool( 900, meshTb );
3901 //createTool( 902, meshTb );
3902 //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3903 createTool( 904, meshTb );
3904 createTool( separator(), meshTb );
3906 createTool( 6005, ctrlTb );
3907 createTool( 6028, ctrlTb );
3908 createTool( separator(), ctrlTb );
3909 createTool( 6002, ctrlTb );
3910 createTool( 6003, ctrlTb );
3911 createTool( 6001, ctrlTb );
3912 createTool( 6004, ctrlTb );
3913 createTool( 6029, ctrlTb );
3914 createTool( separator(), ctrlTb );
3915 createTool( 6021, ctrlTb );
3916 createTool( 6025, ctrlTb );
3917 createTool( 6027, ctrlTb );
3918 createTool( 6018, ctrlTb );
3919 createTool( 6019, ctrlTb );
3920 createTool( 6011, ctrlTb );
3921 createTool( 6012, ctrlTb );
3922 createTool( 6013, ctrlTb );
3923 createTool( 6014, ctrlTb );
3924 createTool( 6015, ctrlTb );
3925 createTool( 6016, ctrlTb );
3926 createTool( 6022, ctrlTb );
3927 createTool( 6030, ctrlTb );
3928 createTool( separator(), ctrlTb );
3929 createTool( 6017, ctrlTb );
3930 createTool( 6009, ctrlTb );
3931 createTool( 6023, ctrlTb );
3932 createTool( 6024, ctrlTb );
3933 createTool( 6026, ctrlTb );
3934 createTool( 6031, ctrlTb );
3935 createTool( separator(), ctrlTb );
3937 createTool( 4000, addRemTb );
3938 createTool( 4009, addRemTb );
3939 createTool( 4008, addRemTb );
3940 createTool( 4010, addRemTb );
3941 createTool( 4021, addRemTb );
3942 createTool( 4022, addRemTb );
3943 createTool( 4023, addRemTb );
3944 createTool( 4031, addRemTb );
3945 createTool( 4032, addRemTb );
3946 createTool( 4133, addRemTb );
3947 createTool( 4134, addRemTb );
3948 createTool( 4135, addRemTb );
3949 createTool( 4033, addRemTb );
3950 createTool( separator(), addRemTb );
3951 createTool( 4034, addRemTb );
3952 createTool( 4035, addRemTb );
3953 createTool( 4036, addRemTb );
3954 createTool( 4136, addRemTb );
3955 createTool( 4037, addRemTb );
3956 createTool( 4038, addRemTb );
3957 createTool( 4039, addRemTb );
3958 createTool( 4040, addRemTb );
3959 createTool( 4140, addRemTb );
3960 createTool( separator(), addRemTb );
3961 createTool( 4041, addRemTb );
3962 createTool( 4042, addRemTb );
3963 createTool( 4044, addRemTb );
3964 createTool( 4043, addRemTb );
3965 createTool( separator(), addRemTb );
3966 createTool( 4051, addRemTb );
3967 createTool( 4052, addRemTb );
3968 createTool( separator(), addRemTb );
3969 createTool( 4061, addRemTb );
3970 createTool( 4062, addRemTb );
3971 createTool( 4063, addRemTb );
3972 createTool( 4068, addRemTb );
3973 createTool( 4064, addRemTb );
3974 createTool( 4065, addRemTb );
3975 createTool( 4066, addRemTb );
3976 createTool( 4069, addRemTb );
3977 createTool( separator(), addRemTb );
3979 createTool( 4067,modifyTb );
3980 createTool( 407, modifyTb );
3981 createTool( 408, modifyTb );
3982 createTool( 409, modifyTb );
3983 createTool( 420, modifyTb );
3984 createTool( 410, modifyTb );
3985 createTool( 411, modifyTb );
3986 createTool( 419, modifyTb );
3987 createTool( 412, modifyTb );
3988 createTool( 413, modifyTb );
3989 createTool( 416, modifyTb );
3990 createTool( 414, modifyTb );
3991 createTool( 415, modifyTb );
3992 createTool( 417, modifyTb );
3993 createTool( 418, modifyTb );
3995 createTool( 214, dispModeTb );
3997 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3998 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4001 QString OB = "'ObjectBrowser'",
4002 View = "'" + SVTK_Viewer::Type() + "'",
4004 mesh = pat.arg( SMESHGUI_Selection::typeName( MESH ) ),
4005 group = pat.arg( SMESHGUI_Selection::typeName( GROUP ) ),
4006 hypo = pat.arg( SMESHGUI_Selection::typeName( HYPOTHESIS ) ),
4007 algo = pat.arg( SMESHGUI_Selection::typeName( ALGORITHM ) ),
4008 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4009 arg( SMESHGUI_Selection::typeName( SUBMESH_VERTEX ) ).
4010 arg( SMESHGUI_Selection::typeName( SUBMESH_EDGE ) ).
4011 arg( SMESHGUI_Selection::typeName( SUBMESH_FACE ) ).
4012 arg( SMESHGUI_Selection::typeName( SUBMESH_SOLID ) ).
4013 arg( SMESHGUI_Selection::typeName( SUBMESH_COMPOUND ) ).
4014 arg( SMESHGUI_Selection::typeName( SUBMESH ) ),
4016 mesh_part = mesh + " " + subMesh + " " + group,
4017 mesh_group = mesh + " " + group,
4018 hyp_alg = hypo + " " + algo;
4020 // popup for object browser
4022 isInvisible("not( isVisible )"),
4023 isEmpty("numberOfNodes = 0"),
4024 isNotEmpty("numberOfNodes <> 0"),
4026 // has nodes, edges, etc in VISIBLE! actor
4027 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4028 hasElems("(count( elemTypes ) > 0)"),
4029 hasDifferentElems("(count( elemTypes ) > 1)"),
4030 hasBalls("({'BallElem'} in elemTypes)"),
4031 hasElems0d("({'Elem0d'} in elemTypes)"),
4032 hasEdges("({'Edge'} in elemTypes)"),
4033 hasFaces("({'Face'} in elemTypes)"),
4034 hasVolumes("({'Volume'} in elemTypes)");
4036 createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
4037 createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
4038 createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
4039 createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
4040 createPopupItem( 803, OB, group ); // EDIT_GROUP
4041 createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
4043 popupMgr()->insert( separator(), -1, 0 );
4044 createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
4045 createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
4046 createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
4047 createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
4048 createPopupItem( 214, OB, mesh_part ); // UPDATE
4049 createPopupItem( 900, OB, mesh_part ); // ADV_INFO
4050 createPopupItem( 904, OB, mesh_group ); // FIND_ELEM
4051 popupMgr()->insert( separator(), -1, 0 );
4052 createPopupItem( 801, OB, mesh ); // CREATE_GROUP
4053 createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
4054 createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
4055 popupMgr()->insert( separator(), -1, 0 );
4056 createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
4057 createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4058 popupMgr()->insert( separator(), -1, 0 );
4059 createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
4060 popupMgr()->insert( separator(), -1, 0 );
4061 createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
4062 createPopupItem( 418, OB, mesh + " " + group, // create 2D mesh from 3D
4064 popupMgr()->insert( separator(), -1, 0 );
4066 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4067 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4068 QString only_one_2D = only_one_non_empty + " && dim>1";
4070 createPopupItem( 125, OB, mesh_group, multiple_non_empty ); // EXPORT_MED
4071 createPopupItem( 126, OB, mesh_group, only_one_non_empty ); // EXPORT_UNV
4072 createPopupItem( 141, OB, mesh_group, only_one_2D ); // EXPORT_STL
4074 createPopupItem( 143, OB, mesh_group, multiple_non_empty ); // EXPORT_CGNS
4076 createPopupItem( 145, OB, mesh_group, multiple_non_empty ); // EXPORT_SAUV
4077 createPopupItem( 147, OB, mesh_group, multiple_non_empty ); // EXPORT_GMF
4078 createPopupItem( 33, OB, mesh_part + " " + hyp_alg ); // DELETE
4079 createPopupItem( 813, OB, group ); // DEL_GROUP with contents
4080 popupMgr()->insert( separator(), -1, 0 );
4083 createPopupItem( 803, View, group ); // EDIT_GROUP
4084 createPopupItem( 804, View, elems ); // ADD
4085 createPopupItem( 805, View, elems ); // REMOVE
4087 popupMgr()->insert( separator(), -1, 0 );
4088 createPopupItem( 214, View, mesh_part ); // UPDATE
4089 createPopupItem( 900, View, mesh_part ); // ADV_INFO
4090 createPopupItem( 904, View, mesh ); // FIND_ELEM
4091 popupMgr()->insert( separator(), -1, 0 );
4093 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
4094 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
4095 popupMgr()->insert( separator(), -1, 0 );
4098 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4099 QString aType = QString( "%1type in {%2}" ).arg( lc );
4100 aType = aType.arg( mesh_part );
4101 QString aMeshInVTK = aClient + "&&" + aType;
4103 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4104 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4105 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4107 //-------------------------------------------------
4109 //-------------------------------------------------
4110 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4112 popupMgr()->insert( action( 9010 ), anId, -1 );
4113 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4114 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4116 popupMgr()->insert( action( 9011 ), anId, -1 );
4117 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4118 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4120 popupMgr()->insert( separator(), -1, -1 );
4122 //-------------------------------------------------
4124 //-------------------------------------------------
4125 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4127 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4128 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4129 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4131 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4132 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4133 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4135 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4136 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4137 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4139 popupMgr()->insert( separator(), anId, -1 );
4141 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4142 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4143 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4145 //-------------------------------------------------
4147 //-------------------------------------------------
4148 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4150 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4152 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4153 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4154 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4156 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4157 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4158 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4160 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4161 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4162 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4164 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4165 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4166 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4168 popupMgr()->insert( action( 222 ), anId, -1 ); // BALLS
4169 popupMgr()->setRule( action( 222 ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4170 popupMgr()->setRule( action( 222 ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4172 popupMgr()->insert( separator(), anId, -1 );
4174 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4175 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4178 //-------------------------------------------------
4179 // Representation of the 2D Quadratic elements
4180 //-------------------------------------------------
4181 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4182 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4183 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4184 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4186 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4187 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4188 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4190 //-------------------------------------------------
4191 // Orientation of faces
4192 //-------------------------------------------------
4193 popupMgr()->insert( action( 221 ), -1, -1 );
4194 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4195 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4197 //-------------------------------------------------
4199 //-------------------------------------------------
4200 popupMgr()->insert( action( 1132 ), -1, -1 );
4201 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4203 //-------------------------------------------------
4205 //-------------------------------------------------
4206 popupMgr()->insert( action( 1133 ), -1, -1 );
4207 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4209 //-------------------------------------------------
4211 //-------------------------------------------------
4213 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4214 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4215 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4216 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4218 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4220 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4221 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4223 popupMgr()->insert( separator(), anId, -1 );
4225 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4227 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4228 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4229 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4231 popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4232 popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4233 popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4235 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4237 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4238 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4239 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4241 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4242 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4243 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4245 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4246 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4247 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4249 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4250 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4251 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4252 popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4253 popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4254 popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4256 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4258 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4259 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4260 QtxPopupMgr::VisibleRule );
4261 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4263 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4264 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4265 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4267 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4268 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4269 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4271 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4272 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4273 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4275 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4276 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4277 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4279 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4280 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4281 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4283 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4284 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4285 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4287 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4288 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4289 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4291 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4292 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4293 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4295 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4296 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4297 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4299 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4300 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4301 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4303 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4304 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4305 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4306 popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4307 popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4308 popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4310 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4312 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4313 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4314 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4316 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4317 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4318 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4320 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4321 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4322 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4324 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4325 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4326 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4328 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4329 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4330 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4332 popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4333 popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4334 popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4336 popupMgr()->insert( separator(), anId, -1 );
4338 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4339 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4341 popupMgr()->insert( separator(), anId, -1 );
4343 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4345 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4346 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4348 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4349 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4350 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4352 #ifndef DISABLE_PLOT2DVIEWER
4353 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4354 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4357 //-------------------------------------------------
4359 //-------------------------------------------------
4360 popupMgr()->insert( separator(), -1, -1 );
4361 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4362 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4363 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4364 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4366 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4367 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4369 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4370 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4372 popupMgr()->insert( separator(), -1, -1 );
4374 //-------------------------------------------------
4376 //-------------------------------------------------
4377 popupMgr()->insert( action( 1134 ), -1, -1 );
4378 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4380 popupMgr()->insert( separator(), -1, -1 );
4382 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4383 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4385 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4386 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4389 //================================================================================
4391 * \brief Return true if SMESH or GEOM objects are selected.
4392 * Is called form LightApp_Module::activateModule() which clear selection if
4393 * not isSelectionCompatible()
4395 //================================================================================
4397 bool SMESHGUI::isSelectionCompatible()
4399 bool isCompatible = true;
4400 SALOME_ListIO selected;
4401 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4402 Sel->selectedObjects( selected );
4404 SALOME_ListIteratorOfListIO It( selected );
4405 for ( ; isCompatible && It.More(); It.Next())
4407 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4408 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4410 return isCompatible;
4414 bool SMESHGUI::reusableOperation( const int id )
4416 // compute, evaluate and precompute are not reusable operations
4417 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4420 bool SMESHGUI::activateModule( SUIT_Study* study )
4422 bool res = SalomeApp_Module::activateModule( study );
4424 setMenuShown( true );
4425 setToolShown( true );
4427 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4428 PyGILState_STATE gstate = PyGILState_Ensure();
4429 PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4430 if(pluginsmanager==NULL)
4434 PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4439 PyGILState_Release(gstate);
4440 // end of GEOM plugins loading
4442 // Reset actions accelerator keys
4443 //action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4444 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4445 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4447 action( 33)->setEnabled(true); // Delete: Key_Delete
4449 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4450 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4451 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4452 if ( _PTR(Study) aStudy = s->studyDS()) {
4453 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4454 updateObjBrowser(); // objects can be removed
4457 // get all view currently opened in the study and connect their signals to
4458 // the corresponding slots of the class.
4459 SUIT_Desktop* aDesk = study->application()->desktop();
4461 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4462 SUIT_ViewWindow* wnd;
4463 foreach ( wnd, wndList )
4470 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4472 setMenuShown( false );
4473 setToolShown( false );
4475 EmitSignalCloseAllDialogs();
4477 // Unset actions accelerator keys
4478 //action(111)->setShortcut(QKeySequence()); // Import DAT
4479 action(112)->setShortcut(QKeySequence()); // Import UNV
4480 action(113)->setShortcut(QKeySequence()); // Import MED
4482 action( 33)->setEnabled(false); // Delete: Key_Delete
4484 return SalomeApp_Module::deactivateModule( study );
4487 void SMESHGUI::studyClosed( SUIT_Study* s )
4489 SMESH::RemoveVisuData( s->id() );
4490 SalomeApp_Module::studyClosed( s );
4493 void SMESHGUI::OnGUIEvent()
4495 const QObject* obj = sender();
4496 if ( !obj || !obj->inherits( "QAction" ) )
4498 int id = actionId((QAction*)obj);
4503 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4505 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4506 if ( CORBA::is_nil( myComponentSMESH ) )
4508 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4510 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4511 return aGUI.myComponentSMESH;
4514 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4515 return myComponentSMESH;
4518 QString SMESHGUI::engineIOR() const
4520 CORBA::ORB_var anORB = getApp()->orb();
4521 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4522 return QString( anIOR.in() );
4525 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4527 SalomeApp_Module::contextMenuPopup( client, menu, title );
4529 selectionMgr()->selectedObjects( lst );
4530 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4531 Handle(SALOME_InteractiveObject) io = lst.First();
4532 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4533 _PTR(Study) study = appStudy->studyDS();
4534 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4536 QString aName = QString( obj->GetName().c_str() );
4537 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4538 aName.remove( (aName.length() - 1), 1 );
4544 LightApp_Selection* SMESHGUI::createSelection() const
4546 return new SMESHGUI_Selection();
4549 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4551 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4552 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4555 void SMESHGUI::viewManagers( QStringList& list ) const
4557 list.append( SVTK_Viewer::Type() );
4560 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4562 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4563 SMESH::UpdateSelectionProp( this );
4565 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4566 for(int i = 0; i < aViews.count() ; i++){
4567 SUIT_ViewWindow *sf = aViews[i];
4573 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4575 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4576 myClippingPlaneInfoMap.erase( theViewManager );
4579 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4581 theActor->AddObserver( SMESH::DeleteActorEvent,
4582 myEventCallbackCommand.GetPointer(),
4586 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4587 unsigned long theEvent,
4588 void* theClientData,
4591 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4592 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4593 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4594 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4595 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4596 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4597 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4598 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4599 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4600 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4601 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4602 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4603 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4604 if( anActor == *anIter3 ) {
4605 anActorList.erase( anIter3 );
4616 void SMESHGUI::createPreferences()
4618 // General tab ------------------------------------------------------------------------
4619 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4621 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4622 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4623 setPreferenceProperty( lim, "min", 0 );
4624 setPreferenceProperty( lim, "max", 100000000 );
4625 setPreferenceProperty( lim, "step", 1000 );
4626 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4628 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4629 setPreferenceProperty( qaGroup, "columns", 2 );
4630 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4631 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4632 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4633 setPreferenceProperty( prec, "min", 0 );
4634 setPreferenceProperty( prec, "max", 16 );
4635 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4636 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4637 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4638 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4639 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4641 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4642 setPreferenceProperty( dispgroup, "columns", 2 );
4643 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4645 modes.append( tr("MEN_WIRE") );
4646 modes.append( tr("MEN_SHADE") );
4647 modes.append( tr("MEN_NODES") );
4648 modes.append( tr("MEN_SHRINK") );
4649 QList<QVariant> indices;
4650 indices.append( 0 );
4651 indices.append( 1 );
4652 indices.append( 2 );
4653 indices.append( 3 );
4654 setPreferenceProperty( dispmode, "strings", modes );
4655 setPreferenceProperty( dispmode, "indexes", indices );
4657 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4658 setPreferenceProperty( arcgroup, "columns", 2 );
4659 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4660 QStringList quadraticModes;
4661 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4662 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4664 indices.append( 0 );
4665 indices.append( 1 );
4666 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4667 setPreferenceProperty( quadraticmode, "indexes", indices );
4669 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4670 "SMESH", "max_angle" );
4671 setPreferenceProperty( maxAngle, "min", 1 );
4672 setPreferenceProperty( maxAngle, "max", 90 );
4676 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4677 setPreferenceProperty( exportgroup, "columns", 2 );
4678 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4679 addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4681 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4682 setPreferenceProperty( computeGroup, "columns", 2 );
4683 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4685 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4686 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4687 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4689 indices.append( 0 );
4690 indices.append( 1 );
4691 indices.append( 2 );
4692 setPreferenceProperty( notifyMode, "strings", modes );
4693 setPreferenceProperty( notifyMode, "indexes", indices );
4695 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4696 setPreferenceProperty( infoGroup, "columns", 4 );
4697 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4699 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4700 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4702 indices.append( 0 );
4703 indices.append( 1 );
4704 setPreferenceProperty( elemInfo, "strings", modes );
4705 setPreferenceProperty( elemInfo, "indexes", indices );
4706 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4707 setPreferenceProperty( nodesLim, "min", 0 );
4708 setPreferenceProperty( nodesLim, "max", 10000000 );
4709 setPreferenceProperty( nodesLim, "step", 10000 );
4710 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4712 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4713 setPreferenceProperty( segGroup, "columns", 2 );
4714 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4715 "SMESH", "segmentation" );
4716 setPreferenceProperty( segLen, "min", 1 );
4717 setPreferenceProperty( segLen, "max", 10000000 );
4718 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4719 "SMESH", "nb_segments_per_edge" );
4720 setPreferenceProperty( nbSeg, "min", 1 );
4721 setPreferenceProperty( nbSeg, "max", 10000000 );
4723 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4724 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4725 "SMESH", "forget_mesh_on_hyp_modif" );
4728 // Quantities with individual precision settings
4729 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4730 setPreferenceProperty( precGroup, "columns", 2 );
4732 const int nbQuantities = 6;
4733 int precs[nbQuantities], ii = 0;
4734 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4735 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4736 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4737 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4738 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4739 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4740 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4741 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4742 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4743 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4744 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4745 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4747 // Set property for precision value for spinboxes
4748 for ( ii = 0; ii < nbQuantities; ii++ ){
4749 setPreferenceProperty( precs[ii], "min", -14 );
4750 setPreferenceProperty( precs[ii], "max", 14 );
4751 setPreferenceProperty( precs[ii], "precision", 2 );
4754 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4755 setPreferenceProperty( previewGroup, "columns", 2 );
4756 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4757 setPreferenceProperty( chunkSize, "min", 0 );
4758 setPreferenceProperty( chunkSize, "max", 1000 );
4759 setPreferenceProperty( chunkSize, "step", 50 );
4761 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4762 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4764 // Mesh tab ------------------------------------------------------------------------
4765 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4766 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4767 setPreferenceProperty( nodeGroup, "columns", 3 );
4769 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4771 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4773 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4774 QList<QVariant> aMarkerTypeIndicesList;
4775 QList<QVariant> aMarkerTypeIconsList;
4776 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4777 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4778 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4779 aMarkerTypeIndicesList << i;
4780 aMarkerTypeIconsList << pixmap;
4782 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4783 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4785 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4787 QList<QVariant> aMarkerScaleIndicesList;
4788 QStringList aMarkerScaleValuesList;
4789 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4790 aMarkerScaleIndicesList << i;
4791 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4793 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4794 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4796 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4797 //setPreferenceProperty( elemGroup, "columns", 2 );
4799 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4800 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4801 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
4802 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
4803 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4804 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
4805 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4806 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4809 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4810 setPreferenceProperty( grpGroup, "columns", 2 );
4812 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4813 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
4815 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4816 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4817 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
4818 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
4819 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4820 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4821 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
4822 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
4823 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4824 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4826 setPreferenceProperty( size0d, "min", 1 );
4827 setPreferenceProperty( size0d, "max", 10 );
4829 setPreferenceProperty( ballSize, "min", 1 );
4830 setPreferenceProperty( ballSize, "max", 10 );
4832 setPreferenceProperty( elemW, "min", 1 );
4833 setPreferenceProperty( elemW, "max", 5 );
4835 setPreferenceProperty( outW, "min", 1 );
4836 setPreferenceProperty( outW, "max", 5 );
4838 setPreferenceProperty( shrink, "min", 0 );
4839 setPreferenceProperty( shrink, "max", 100 );
4841 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4842 setPreferenceProperty( orientGroup, "columns", 1 );
4844 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4845 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4847 setPreferenceProperty( orientScale, "min", 0.05 );
4848 setPreferenceProperty( orientScale, "max", 0.5 );
4849 setPreferenceProperty( orientScale, "step", 0.05 );
4851 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4853 // Selection tab ------------------------------------------------------------------------
4854 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4856 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4857 setPreferenceProperty( selGroup, "columns", 2 );
4859 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4860 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4862 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4863 setPreferenceProperty( preGroup, "columns", 2 );
4865 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4867 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4868 setPreferenceProperty( precSelGroup, "columns", 2 );
4870 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4871 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4872 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4874 // Scalar Bar tab ------------------------------------------------------------------------
4875 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4876 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4877 setPreferenceProperty( fontGr, "columns", 2 );
4879 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4880 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4882 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4883 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4885 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4886 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4888 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4889 setPreferenceProperty( numcol, "min", 2 );
4890 setPreferenceProperty( numcol, "max", 256 );
4892 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4893 setPreferenceProperty( numlab, "min", 2 );
4894 setPreferenceProperty( numlab, "max", 65 );
4896 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4897 setPreferenceProperty( orientGr, "columns", 2 );
4898 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4899 QStringList orients;
4900 orients.append( tr( "SMESH_VERTICAL" ) );
4901 orients.append( tr( "SMESH_HORIZONTAL" ) );
4902 indices.clear(); indices.append( 0 ); indices.append( 1 );
4903 setPreferenceProperty( orient, "strings", orients );
4904 setPreferenceProperty( orient, "indexes", indices );
4906 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4907 setPreferenceProperty( posVSizeGr, "columns", 2 );
4908 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4909 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4910 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4911 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4912 setPreferenceProperty( xv, "step", 0.1 );
4913 setPreferenceProperty( xv, "min", 0.0 );
4914 setPreferenceProperty( xv, "max", 1.0 );
4915 setPreferenceProperty( yv, "step", 0.1 );
4916 setPreferenceProperty( yv, "min", 0.0 );
4917 setPreferenceProperty( yv, "max", 1.0 );
4918 setPreferenceProperty( wv, "step", 0.1 );
4919 setPreferenceProperty( wv, "min", 0.0 );
4920 setPreferenceProperty( wv, "max", 1.0 );
4921 setPreferenceProperty( hv, "min", 0.0 );
4922 setPreferenceProperty( hv, "max", 1.0 );
4923 setPreferenceProperty( hv, "step", 0.1 );
4925 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
4926 setPreferenceProperty( posHSizeGr, "columns", 2 );
4927 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
4928 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
4929 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
4930 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
4931 setPreferenceProperty( xv, "min", 0.0 );
4932 setPreferenceProperty( xv, "max", 1.0 );
4933 setPreferenceProperty( xv, "step", 0.1 );
4934 setPreferenceProperty( xh, "min", 0.0 );
4935 setPreferenceProperty( xh, "max", 1.0 );
4936 setPreferenceProperty( xh, "step", 0.1 );
4937 setPreferenceProperty( yh, "min", 0.0 );
4938 setPreferenceProperty( yh, "max", 1.0 );
4939 setPreferenceProperty( yh, "step", 0.1 );
4940 setPreferenceProperty( wh, "min", 0.0 );
4941 setPreferenceProperty( wh, "max", 1.0 );
4942 setPreferenceProperty( wh, "step", 0.1 );
4943 setPreferenceProperty( hh, "min", 0.0 );
4944 setPreferenceProperty( hh, "max", 1.0 );
4945 setPreferenceProperty( hh, "step", 0.1 );
4947 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
4948 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
4949 setPreferenceProperty( distributionGr, "columns", 3 );
4951 types.append( tr( "SMESH_MONOCOLOR" ) );
4952 types.append( tr( "SMESH_MULTICOLOR" ) );
4953 indices.clear(); indices.append( 0 ); indices.append( 1 );
4954 setPreferenceProperty( coloringType, "strings", types );
4955 setPreferenceProperty( coloringType, "indexes", indices );
4956 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
4960 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
4962 if( sect=="SMESH" ) {
4963 float sbX1,sbY1,sbW,sbH;
4964 float aTol = 1.00000009999999;
4965 std::string aWarning;
4966 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4967 if( name=="selection_object_color" || name=="selection_element_color" ||
4968 name=="highlight_color" ||
4969 name=="selection_precision_node" || name=="selection_precision_element" ||
4970 name=="selection_precision_object")
4971 SMESH::UpdateSelectionProp( this );
4972 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
4973 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
4974 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
4975 if(sbX1+sbW > aTol){
4976 aWarning = "Origin and Size Vertical: X+Width > 1\n";
4979 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
4980 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
4983 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
4984 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
4985 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
4986 if(sbY1+sbH > aTol){
4987 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
4988 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
4989 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
4992 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
4993 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4994 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
4995 if(sbX1+sbW > aTol){
4996 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
4999 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5000 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5003 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5004 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5005 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5006 if(sbY1+sbH > aTol){
5007 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5010 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5011 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5014 else if ( name == "segmentation" ) {
5015 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5016 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5018 else if ( name == "nb_segments_per_edge" ) {
5019 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5020 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5022 else if ( name == "historical_python_dump" ||
5023 name == "forget_mesh_on_hyp_modif") {
5024 QString val = aResourceMgr->stringValue( "SMESH", name );
5025 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5028 if(aWarning.size() != 0){
5029 aWarning += "The default values are applied instead.";
5030 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5031 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5032 QObject::tr(aWarning.c_str()));
5037 //================================================================================
5039 * \brief Update something in accordance with update flags
5040 * \param theFlags - update flags
5042 * Update viewer or/and object browser etc. in accordance with update flags ( see
5043 * LightApp_UpdateFlags enumeration ).
5045 //================================================================================
5046 void SMESHGUI::update( const int flags )
5048 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5049 SMESH::UpdateView();
5051 SalomeApp_Module::update( flags );
5054 //================================================================================
5056 * \brief Set default selection mode
5058 * SLOT called when operation commited. Sets default selection mode
5060 //================================================================================
5061 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5063 SVTK_ViewWindow* vtkWnd =
5064 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5066 vtkWnd->SetSelectionMode( ActorSelection );
5069 //================================================================================
5071 * \brief Set default selection mode
5073 * SLOT called when operation aborted. Sets default selection mode
5075 //================================================================================
5076 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5078 SVTK_ViewWindow* vtkWnd =
5079 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5081 vtkWnd->SetSelectionMode( ActorSelection );
5084 //================================================================================
5086 * \brief Creates operation with given identifier
5087 * \param id - identifier of operation to be started
5088 * \return Pointer on created operation or NULL if operation is not created
5090 * Virtual method redefined from the base class creates operation with given id.
5091 * It is called called automatically from startOperation method of base class.
5093 //================================================================================
5094 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5096 LightApp_Operation* op = 0;
5097 // to do : create operation here
5100 case 417: //convert to quadratic
5101 op = new SMESHGUI_ConvToQuadOp();
5103 case 418: // create 2D mesh as boundary on 3D
5104 op = new SMESHGUI_Make2DFrom3DOp();
5106 case 420: // Reorient faces
5107 op = new SMESHGUI_ReorientFacesOp();
5109 case 701: // Compute mesh
5110 op = new SMESHGUI_ComputeOp();
5112 case 702: // Create mesh
5113 op = new SMESHGUI_MeshOp( true, true );
5115 case 703: // Create sub-mesh
5116 op = new SMESHGUI_MeshOp( true, false );
5118 case 704: // Edit mesh/sub-mesh
5119 op = new SMESHGUI_MeshOp( false );
5121 case 711: // Precompute mesh
5122 op = new SMESHGUI_PrecomputeOp();
5124 case 712: // Evaluate mesh
5125 op = new SMESHGUI_EvaluateOp();
5127 case 713: // Evaluate mesh
5128 op = new SMESHGUI_MeshOrderOp();
5130 case 806: // Create group on geom
5131 op = new SMESHGUI_GroupOnShapeOp();
5133 case 904: // Find element
5134 op = new SMESHGUI_FindElemByPointOp();
5136 case 4067: // make mesh pass through point
5137 op = new SMESHGUI_MakeNodeAtPointOp();
5144 op = SalomeApp_Module::createOperation( id );
5148 //================================================================================
5150 * \brief Stops current operations and starts a given one
5151 * \param id - The id of the operation to start
5153 //================================================================================
5155 void SMESHGUI::switchToOperation(int id)
5157 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5158 activeStudy()->abortAllOperations();
5159 startOperation( id );
5162 LightApp_Displayer* SMESHGUI::displayer()
5165 myDisplayer = new SMESHGUI_Displayer( getApp() );
5169 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5172 int aTolerance = 64;
5173 int anIterations = 0;
5179 if( anIterations % aPeriod == 0 )
5182 if( aTolerance < 1 )
5186 aHue = (int)( 360.0 * rand() / RAND_MAX );
5189 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5190 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5191 for( ; it != itEnd; ++it )
5193 SALOMEDS::Color anAutoColor = *it;
5194 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5197 aQColor.getHsv( &h, &s, &v );
5198 if( abs( h - aHue ) < aTolerance )
5210 aColor.setHsv( aHue, 255, 255 );
5212 SALOMEDS::Color aSColor;
5213 aSColor.R = aColor.redF();
5214 aSColor.G = aColor.greenF();
5215 aSColor.B = aColor.blueF();
5220 const char* gSeparator = "_"; // character used to separate parameter names
5221 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5222 const char* gPathSep = "|"; // character used to separate paths
5225 * \brief Store visual parameters
5227 * This method is called just before the study document is saved.
5228 * Store visual parameters in AttributeParameter attribue(s)
5230 void SMESHGUI::storeVisualParameters (int savePoint)
5233 Kernel_Utils::Localizer loc;
5235 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5236 if (!appStudy || !appStudy->studyDS())
5238 _PTR(Study) studyDS = appStudy->studyDS();
5240 // componentName is used for encoding of entries when storing them in IParameters
5241 std::string componentName = myComponentSMESH->ComponentDataType();
5242 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5243 //if (!aSComponent) return;
5246 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5247 componentName.c_str(),
5249 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5251 // store map of custom markers
5252 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5253 if( !aMarkerMap.empty() )
5255 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5256 for( ; anIter != aMarkerMap.end(); anIter++ )
5258 int anId = anIter->first;
5259 VTK::MarkerData aMarkerData = anIter->second;
5260 std::string aMarkerFileName = aMarkerData.first;
5261 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5262 if( aMarkerTexture.size() < 3 )
5263 continue; // should contain at least width, height and the first value
5265 QString aPropertyName( "texture" );
5266 aPropertyName += gSeparator;
5267 aPropertyName += QString::number( anId );
5269 QString aPropertyValue = aMarkerFileName.c_str();
5270 aPropertyValue += gPathSep;
5272 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5273 ushort aWidth = *aTextureIter++;
5274 ushort aHeight = *aTextureIter++;
5275 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5276 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5277 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5278 aPropertyValue += QString::number( *aTextureIter );
5280 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5284 // viewers counters are used for storing view_numbers in IParameters
5287 // main cycle to store parameters of displayed objects
5288 QList<SUIT_ViewManager*> lst;
5289 QList<SUIT_ViewManager*>::Iterator it;
5290 getApp()->viewManagers(lst);
5291 for (it = lst.begin(); it != lst.end(); it++)
5293 SUIT_ViewManager* vman = *it;
5294 QString vType = vman->getType();
5296 // saving VTK actors properties
5297 if (vType == SVTK_Viewer::Type())
5299 // store the clipping planes attached to the view manager
5300 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5301 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5302 if( anIter != myClippingPlaneInfoMap.end() )
5303 aClippingPlaneInfoList = anIter->second;
5305 if( !aClippingPlaneInfoList.empty() ) {
5306 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5307 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5309 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5310 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5312 QString aPropertyName( "ClippingPlane" );
5313 aPropertyName += gSeparator;
5314 aPropertyName += QString::number( vtkViewers );
5315 aPropertyName += gSeparator;
5316 aPropertyName += QString::number( anId );
5318 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5319 aPropertyValue += gDigitsSep;
5320 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5321 aPropertyValue += gDigitsSep;
5322 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5323 aPropertyValue += gDigitsSep;
5324 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5326 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5330 QVector<SUIT_ViewWindow*> views = vman->getViews();
5331 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5333 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5335 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5336 vtkActorCollection* allActors = aCopy.GetActors();
5337 allActors->InitTraversal();
5338 while (vtkActor* actor = allActors->GetNextActor())
5340 if (actor->GetVisibility()) // store only visible actors
5342 SMESH_Actor* aSmeshActor = 0;
5343 if (actor->IsA("SMESH_Actor"))
5344 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5345 if (aSmeshActor && aSmeshActor->hasIO())
5347 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5350 // entry is "encoded" = it does NOT contain component adress,
5351 // since it is a subject to change on next component loading
5352 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5354 std::string param, vtkParam = vType.toLatin1().data();
5355 vtkParam += gSeparator;
5356 vtkParam += QString::number(vtkViewers).toLatin1().data();
5357 vtkParam += gSeparator;
5360 param = vtkParam + "Visibility";
5361 ip->setParameter(entry, param, "On");
5364 param = vtkParam + "Representation";
5365 ip->setParameter(entry, param, QString::number
5366 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5369 param = vtkParam + "IsShrunk";
5370 ip->setParameter(entry, param, QString::number
5371 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5373 // Displayed entities
5374 unsigned int aMode = aSmeshActor->GetEntityMode();
5375 bool isE = aMode & SMESH_Actor::eEdges;
5376 bool isF = aMode & SMESH_Actor::eFaces;
5377 bool isV = aMode & SMESH_Actor::eVolumes;
5378 bool is0d = aMode & SMESH_Actor::e0DElements;
5379 bool isB = aMode & SMESH_Actor::eBallElem;
5381 QString modeStr ("e");
5382 modeStr += gDigitsSep; modeStr += QString::number(isE);
5383 modeStr += gDigitsSep; modeStr += "f";
5384 modeStr += gDigitsSep; modeStr += QString::number(isF);
5385 modeStr += gDigitsSep; modeStr += "v";
5386 modeStr += gDigitsSep; modeStr += QString::number(isV);
5387 modeStr += gDigitsSep; modeStr += "0d";
5388 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5389 modeStr += gDigitsSep; modeStr += "b";
5390 modeStr += gDigitsSep; modeStr += QString::number(isB);
5392 param = vtkParam + "Entities";
5393 ip->setParameter(entry, param, modeStr.toLatin1().data());
5396 vtkFloatingPointType r, g, b;
5399 aSmeshActor->GetSufaceColor(r, g, b, delta);
5400 QStringList colorStr;
5401 colorStr << "surface";
5402 colorStr << QString::number(r);
5403 colorStr << QString::number(g);
5404 colorStr << QString::number(b);
5406 colorStr << "backsurface";
5407 colorStr << QString::number(delta);
5409 aSmeshActor->GetVolumeColor(r, g, b, delta);
5410 colorStr << "volume";
5411 colorStr << QString::number(r);
5412 colorStr << QString::number(g);
5413 colorStr << QString::number(b);
5414 colorStr << QString::number(delta);
5416 aSmeshActor->GetEdgeColor(r, g, b);
5418 colorStr << QString::number(r);
5419 colorStr << QString::number(g);
5420 colorStr << QString::number(b);
5422 aSmeshActor->GetNodeColor(r, g, b);
5424 colorStr << QString::number(r);
5425 colorStr << QString::number(g);
5426 colorStr << QString::number(b);
5428 aSmeshActor->GetOutlineColor(r, g, b);
5429 colorStr << "outline";
5430 colorStr << QString::number(r);
5431 colorStr << QString::number(g);
5432 colorStr << QString::number(b);
5434 aSmeshActor->Get0DColor(r, g, b);
5435 colorStr << "elem0d";
5436 colorStr << QString::number(r);
5437 colorStr << QString::number(g);
5438 colorStr << QString::number(b);
5440 aSmeshActor->GetBallColor(r, g, b);
5442 colorStr << QString::number(r);
5443 colorStr << QString::number(g);
5444 colorStr << QString::number(b);
5446 aSmeshActor->GetFacesOrientationColor(r, g, b);
5447 colorStr << "orientation";
5448 colorStr << QString::number(r);
5449 colorStr << QString::number(g);
5450 colorStr << QString::number(b);
5452 param = vtkParam + "Colors";
5453 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5456 QStringList sizeStr;
5458 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5459 sizeStr << "outline";
5460 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5461 sizeStr << "elem0d";
5462 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5464 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5465 sizeStr << "shrink";
5466 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5467 sizeStr << "orientation";
5468 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5469 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5471 param = vtkParam + "Sizes";
5472 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5477 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5478 if( aMarkerType == VTK::MT_USER ) {
5479 markerStr += "custom";
5480 markerStr += gDigitsSep;
5481 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5485 markerStr += gDigitsSep;
5486 markerStr += QString::number( (int)aMarkerType );
5487 markerStr += gDigitsSep;
5488 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5491 param = vtkParam + "PointMarker";
5492 ip->setParameter(entry, param, markerStr.toLatin1().data());
5495 param = vtkParam + "Opacity";
5496 ip->setParameter(entry, param,
5497 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5500 param = vtkParam + "ClippingPlane";
5502 if( !aClippingPlaneInfoList.empty() ) {
5503 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5504 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5506 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5507 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5508 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5509 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5510 if( aSmeshActor == *anIter2 ) {
5511 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5512 QString::number( anId ).toLatin1().constData() );
5519 ip->setParameter( entry, param, "Off" );
5520 } // if (io->hasEntry())
5521 } // SMESH_Actor && hasIO
5523 } // while.. actors traversal
5527 } // if (SVTK view model)
5528 } // for (viewManagers)
5531 // data structures for clipping planes processing
5534 vtkIdType Orientation;
5535 vtkFloatingPointType Distance;
5536 vtkFloatingPointType Angle[2];
5538 typedef std::list<TPlaneData> TPlaneDataList;
5539 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5541 typedef std::list<vtkActor*> TActorList;
5544 TActorList ActorList;
5545 SUIT_ViewManager* ViewManager;
5547 typedef std::list<TPlaneInfo> TPlaneInfoList;
5548 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5551 * \brief Restore visual parameters
5553 * This method is called after the study document is opened.
5554 * Restore visual parameters from AttributeParameter attribue(s)
5556 void SMESHGUI::restoreVisualParameters (int savePoint)
5559 Kernel_Utils::Localizer loc;
5561 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5562 if (!appStudy || !appStudy->studyDS())
5564 _PTR(Study) studyDS = appStudy->studyDS();
5566 // componentName is used for encoding of entries when storing them in IParameters
5567 std::string componentName = myComponentSMESH->ComponentDataType();
5568 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5569 //if (!aSComponent) return;
5572 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5573 componentName.c_str(),
5575 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5577 // restore map of custom markers and map of clipping planes
5578 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5579 TPlaneDataMap aPlaneDataMap;
5581 std::vector<std::string> properties = ip->getProperties();
5582 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5584 std::string property = *propIt;
5585 QString aPropertyName( property.c_str() );
5586 QString aPropertyValue( ip->getProperty( property ).c_str() );
5588 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5589 if( aPropertyNameList.isEmpty() )
5592 QString aPropertyType = aPropertyNameList[0];
5593 if( aPropertyType == "texture" )
5595 if( aPropertyNameList.size() != 2 )
5599 int anId = aPropertyNameList[1].toInt( &ok );
5600 if( !ok || anId < 1 )
5603 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5604 if( aPropertyValueList.size() != 2 )
5607 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5608 QString aMarkerTextureString = aPropertyValueList[1];
5609 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5610 if( aMarkerTextureStringList.size() != 3 )
5614 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5619 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5623 VTK::MarkerTexture aMarkerTexture;
5624 aMarkerTexture.push_back( aWidth );
5625 aMarkerTexture.push_back( aHeight );
5627 QString aMarkerTextureData = aMarkerTextureStringList[2];
5628 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5630 QChar aChar = aMarkerTextureData.at( i );
5631 if( aChar.isDigit() )
5632 aMarkerTexture.push_back( aChar.digitValue() );
5635 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5637 else if( aPropertyType == "ClippingPlane" )
5639 if( aPropertyNameList.size() != 3 )
5643 int aViewId = aPropertyNameList[1].toInt( &ok );
5644 if( !ok || aViewId < 0 )
5648 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5649 if( !ok || aClippingPlaneId < 0 )
5652 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5653 if( aPropertyValueList.size() != 4 )
5656 TPlaneData aPlaneData;
5657 aPlaneData.Id = aClippingPlaneId;
5660 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5665 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5670 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5675 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5679 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5680 aPlaneDataList.push_back( aPlaneData );
5684 TPlaneInfoMap aPlaneInfoMap;
5686 std::vector<std::string> entries = ip->getEntries();
5688 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5690 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5691 QString entry (ip->decodeEntry(*entIt).c_str());
5693 // Check that the entry corresponds to a real object in the Study
5694 // as the object may be deleted or modified after the visual state is saved.
5695 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5696 if (!so) continue; //Skip the not existent entry
5698 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5699 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5701 std::vector<std::string>::iterator namesIt = paramNames.begin();
5702 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5704 // actors are stored in a map after displaying of them for
5705 // quicker access in the future: map < viewID to actor >
5706 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5708 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5710 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5711 // '_' is used as separator and should not be used in viewer type or parameter names.
5712 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5713 if (lst.size() != 3)
5716 QString viewerTypStr = lst[0];
5717 QString viewIndexStr = lst[1];
5718 QString paramNameStr = lst[2];
5721 int viewIndex = viewIndexStr.toUInt(&ok);
5722 if (!ok) // bad conversion of view index to integer
5726 if (viewerTypStr == SVTK_Viewer::Type())
5728 SMESH_Actor* aSmeshActor = 0;
5729 if (vtkActors.IsBound(viewIndex))
5730 aSmeshActor = vtkActors.Find(viewIndex);
5732 QList<SUIT_ViewManager*> lst;
5733 getApp()->viewManagers(viewerTypStr, lst);
5735 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5736 SUIT_ViewManager* vman = NULL;
5737 if (viewIndex >= 0 && viewIndex < lst.count())
5738 vman = lst.at(viewIndex);
5740 if (paramNameStr == "Visibility")
5742 if (!aSmeshActor && displayer() && vman)
5744 SUIT_ViewModel* vmodel = vman->getViewModel();
5745 // SVTK view model can be casted to SALOME_View
5746 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5748 // store displayed actor in a temporary map for quicker
5749 // access later when restoring other parameters
5750 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5751 vtkRenderer* Renderer = vtkView->getRenderer();
5752 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5753 vtkActorCollection* theActors = aCopy.GetActors();
5754 theActors->InitTraversal();
5755 bool isFound = false;
5756 vtkActor *ac = theActors->GetNextActor();
5757 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5758 if (ac->IsA("SMESH_Actor")) {
5759 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5760 if (aGeomAc->hasIO()) {
5761 Handle(SALOME_InteractiveObject) io =
5762 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5763 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5765 vtkActors.Bind(viewIndex, aGeomAc);
5771 } // if (paramNameStr == "Visibility")
5774 // the rest properties "work" with SMESH_Actor
5777 QString val ((*valuesIt).c_str());
5780 if (paramNameStr == "Representation") {
5781 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5784 else if (paramNameStr == "IsShrunk") {
5786 if (!aSmeshActor->IsShrunk())
5787 aSmeshActor->SetShrink();
5790 if (aSmeshActor->IsShrunk())
5791 aSmeshActor->UnShrink();
5794 // Displayed entities
5795 else if (paramNameStr == "Entities") {
5796 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5797 int aEntityMode = SMESH_Actor::eAllEntity;
5798 for ( int i = 0; i < mode.count(); i+=2 ) {
5799 if ( i < mode.count()-1 ) {
5800 QString type = mode[i];
5801 bool val = mode[i+1].toInt();
5802 if ( type == "e" && !val )
5803 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
5804 else if ( type == "f" && !val )
5805 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
5806 else if ( type == "v" && !val )
5807 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
5808 else if ( type == "0d" && !val )
5809 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
5810 else if ( type == "b" && !val )
5811 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
5814 aSmeshActor->SetEntityMode( aEntityMode );
5817 else if (paramNameStr == "Colors") {
5818 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5825 QColor outlineColor;
5826 QColor orientationColor;
5832 // below lines are required to get default values for delta coefficients
5833 // of backface color for faces and color of reversed volumes
5834 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
5835 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
5836 for ( int i = 0; i < colors.count(); i++ ) {
5837 QString type = colors[i];
5838 if ( type == "surface" ) {
5839 // face color is set by 3 values r:g:b, where
5840 // - r,g,b - is rgb color components
5841 if ( i+1 >= colors.count() ) break; // format error
5842 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5843 if ( i+2 >= colors.count() ) break; // format error
5844 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5845 if ( i+3 >= colors.count() ) break; // format error
5846 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5847 faceColor.setRgbF( r, g, b );
5850 else if ( type == "backsurface" ) {
5851 // backface color can be defined in several ways
5852 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
5853 // - in latest versions, it is set as delta coefficient
5854 bool rgbOk = false, deltaOk;
5855 if ( i+1 >= colors.count() ) break; // format error
5856 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5857 int delta = colors[i+1].toInt( &deltaOk );
5859 if ( i+1 < colors.count() ) // index is shifted to 1
5860 g = colors[i+1].toDouble( &rgbOk );
5861 if ( rgbOk ) i++; // shift index
5862 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
5863 b = colors[i+1].toDouble( &rgbOk );
5865 // - as currently there's no way to set directly backsurface color as it was before,
5866 // we ignore old dump where r,g,b triple was set
5867 // - also we check that delta parameter is set properly
5868 if ( !rgbOk && deltaOk )
5871 else if ( type == "volume" ) {
5872 // volume color is set by 4 values r:g:b:delta, where
5873 // - r,g,b - is a normal volume rgb color components
5874 // - delta - is a reversed volume color delta coefficient
5875 if ( i+1 >= colors.count() ) break; // format error
5876 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5877 if ( i+2 >= colors.count() ) break; // format error
5878 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5879 if ( i+3 >= colors.count() ) break; // format error
5880 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5881 if ( i+4 >= colors.count() ) break; // format error
5882 int delta = colors[i+4].toInt( &bOk );
5883 if ( !bOk ) break; // format error
5884 volumeColor.setRgbF( r, g, b );
5888 else if ( type == "edge" ) {
5889 // edge color is set by 3 values r:g:b, where
5890 // - r,g,b - is rgb color components
5891 if ( i+1 >= colors.count() ) break; // format error
5892 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5893 if ( i+2 >= colors.count() ) break; // format error
5894 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5895 if ( i+3 >= colors.count() ) break; // format error
5896 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5897 edgeColor.setRgbF( r, g, b );
5900 else if ( type == "node" ) {
5901 // node color is set by 3 values r:g:b, where
5902 // - r,g,b - is rgb color components
5903 if ( i+1 >= colors.count() ) break; // format error
5904 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5905 if ( i+2 >= colors.count() ) break; // format error
5906 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5907 if ( i+3 >= colors.count() ) break; // format error
5908 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5909 nodeColor.setRgbF( r, g, b );
5912 else if ( type == "elem0d" ) {
5913 // 0d element color is set by 3 values r:g:b, where
5914 // - r,g,b - is rgb color components
5915 if ( i+1 >= colors.count() ) break; // format error
5916 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5917 if ( i+2 >= colors.count() ) break; // format error
5918 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5919 if ( i+3 >= colors.count() ) break; // format error
5920 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5921 elem0dColor.setRgbF( r, g, b );
5924 else if ( type == "ball" ) {
5925 // ball color is set by 3 values r:g:b, where
5926 // - r,g,b - is rgb color components
5927 if ( i+1 >= colors.count() ) break; // format error
5928 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5929 if ( i+2 >= colors.count() ) break; // format error
5930 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5931 if ( i+3 >= colors.count() ) break; // format error
5932 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5933 ballColor.setRgbF( r, g, b );
5936 else if ( type == "outline" ) {
5937 // outline color is set by 3 values r:g:b, where
5938 // - r,g,b - is rgb color components
5939 if ( i+1 >= colors.count() ) break; // format error
5940 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5941 if ( i+2 >= colors.count() ) break; // format error
5942 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5943 if ( i+3 >= colors.count() ) break; // format error
5944 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5945 outlineColor.setRgbF( r, g, b );
5948 else if ( type == "orientation" ) {
5949 // orientation color is set by 3 values r:g:b, where
5950 // - r,g,b - is rgb color components
5951 if ( i+1 >= colors.count() ) break; // format error
5952 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5953 if ( i+2 >= colors.count() ) break; // format error
5954 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5955 if ( i+3 >= colors.count() ) break; // format error
5956 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5957 orientationColor.setRgbF( r, g, b );
5962 if ( nodeColor.isValid() )
5963 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
5965 if ( edgeColor.isValid() )
5966 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
5968 if ( faceColor.isValid() )
5969 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
5971 if ( volumeColor.isValid() )
5972 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
5973 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
5974 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
5976 if ( elem0dColor.isValid() )
5977 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
5979 if ( ballColor.isValid() )
5980 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
5982 if ( outlineColor.isValid() )
5983 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
5984 // orientation color
5985 if ( orientationColor.isValid() )
5986 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
5989 else if (paramNameStr == "Sizes") {
5990 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
5993 int outlineWidth = -1;
5994 int elem0dSize = -1;
5996 double shrinkSize = -1;
5997 double orientationSize = -1;
5998 bool orientation3d = false;
5999 for ( int i = 0; i < sizes.count(); i++ ) {
6000 QString type = sizes[i];
6001 if ( type == "line" ) {
6002 // line (wireframe) width is given as single integer value
6003 if ( i+1 >= sizes.count() ) break; // format error
6004 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6008 if ( type == "outline" ) {
6009 // outline width is given as single integer value
6010 if ( i+1 >= sizes.count() ) break; // format error
6011 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6015 else if ( type == "elem0d" ) {
6016 // 0d element size is given as single integer value
6017 if ( i+1 >= sizes.count() ) break; // format error
6018 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6022 else if ( type == "ball" ) {
6023 // ball size is given as single integer value
6024 if ( i+1 >= sizes.count() ) break; // format error
6025 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6029 else if ( type == "shrink" ) {
6030 // shrink factor is given as single floating point value
6031 if ( i+1 >= sizes.count() ) break; // format error
6032 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6036 else if ( type == "orientation" ) {
6037 // orientation vectors are specified by two values size:3d, where
6038 // - size - is a floating point value specifying scale factor
6039 // - 3d - is a boolean
6040 if ( i+1 >= sizes.count() ) break; // format error
6041 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6042 if ( i+2 >= sizes.count() ) break; // format error
6043 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6044 orientationSize = v1;
6045 orientation3d = (bool)v2;
6049 // line (wireframe) width
6050 if ( lineWidth > 0 )
6051 aSmeshActor->SetLineWidth( lineWidth );
6053 if ( outlineWidth > 0 )
6054 aSmeshActor->SetOutlineWidth( outlineWidth );
6055 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6056 aSmeshActor->SetOutlineWidth( lineWidth );
6058 if ( elem0dSize > 0 )
6059 aSmeshActor->Set0DSize( elem0dSize );
6062 aSmeshActor->SetBallSize( ballSize );
6064 if ( shrinkSize > 0 )
6065 aSmeshActor->SetShrinkFactor( shrinkSize );
6066 // orientation vectors
6067 if ( orientationSize > 0 ) {
6068 aSmeshActor->SetFacesOrientationScale( orientationSize );
6069 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6073 else if (paramNameStr == "PointMarker") {
6074 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6075 if( data.count() >= 2 ) {
6077 int aParam1 = data[1].toInt( &ok );
6079 if( data[0] == "std" && data.count() == 3 ) {
6080 int aParam2 = data[2].toInt( &ok );
6081 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6083 else if( data[0] == "custom" ) {
6084 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6085 if( markerIt != aMarkerMap.end() ) {
6086 VTK::MarkerData aMarkerData = markerIt->second;
6087 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6094 else if (paramNameStr == "Opacity") {
6095 aSmeshActor->SetOpacity(val.toFloat());
6098 else if (paramNameStr.startsWith("ClippingPlane")) {
6099 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6100 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
6101 // new format - val looks like "Off" or "0" (plane id)
6102 // (note: in new format "Off" value is used only for consistency,
6103 // so it is processed together with values in old format)
6104 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
6105 if( anIsOldFormat ) {
6106 if (paramNameStr == "ClippingPlane1" || val == "Off")
6107 aSmeshActor->RemoveAllClippingPlanes();
6109 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
6110 double aDistance = vals[1].toFloat();
6111 vtkFloatingPointType anAngle[2];
6112 anAngle[0] = vals[2].toFloat();
6113 anAngle[1] = vals[3].toFloat();
6115 QList<SUIT_ViewManager*> lst;
6116 getApp()->viewManagers(viewerTypStr, lst);
6117 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6118 if (viewIndex >= 0 && viewIndex < lst.count()) {
6119 SUIT_ViewManager* vman = lst.at(viewIndex);
6120 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6122 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6124 SMESH::TActorList anActorList;
6125 anActorList.push_back( aSmeshActor );
6126 SMESH::OrientedPlane* aPlane =
6127 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
6129 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6130 aClippingPlaneInfo.Plane = aPlane;
6131 aClippingPlaneInfo.ActorList = anActorList;
6132 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6139 int aPlaneId = val.toInt( &ok );
6140 if( ok && aPlaneId >= 0 ) {
6141 bool anIsDefinedPlane = false;
6142 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6143 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6144 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6145 TPlaneInfo& aPlaneInfo = *anIter;
6146 if( aPlaneInfo.PlaneId == aPlaneId ) {
6147 aPlaneInfo.ActorList.push_back( aSmeshActor );
6148 anIsDefinedPlane = true;
6152 if( !anIsDefinedPlane ) {
6153 TPlaneInfo aPlaneInfo;
6154 aPlaneInfo.PlaneId = aPlaneId;
6155 aPlaneInfo.ActorList.push_back( aSmeshActor );
6156 aPlaneInfo.ViewManager = vman;
6158 // to make the list sorted by plane id
6159 anIter = aPlaneInfoList.begin();
6160 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6161 const TPlaneInfo& aPlaneInfoRef = *anIter;
6162 if( aPlaneInfoRef.PlaneId > aPlaneId )
6165 aPlaneInfoList.insert( anIter, aPlaneInfo );
6170 } // if (aSmeshActor)
6171 } // other parameters than Visibility
6173 } // for names/parameters iterator
6174 } // for entries iterator
6176 // take into account planes with empty list of actors referred to them
6177 QList<SUIT_ViewManager*> aVMList;
6178 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6180 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6181 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6182 int aViewId = aPlaneDataIter->first;
6183 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6184 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6186 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6188 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6189 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6190 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6191 const TPlaneData& aPlaneData = *anIter2;
6192 int aPlaneId = aPlaneData.Id;
6194 bool anIsFound = false;
6195 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6196 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6197 const TPlaneInfo& aPlaneInfo = *anIter3;
6198 if( aPlaneInfo.PlaneId == aPlaneId ) {
6205 TPlaneInfo aPlaneInfo; // ActorList field is empty
6206 aPlaneInfo.PlaneId = aPlaneId;
6207 aPlaneInfo.ViewManager = aViewManager;
6209 // to make the list sorted by plane id
6210 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6211 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6212 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6213 if( aPlaneInfoRef.PlaneId > aPlaneId )
6216 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6222 // add clipping planes to actors according to the restored parameters
6223 // and update the clipping plane map
6224 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6225 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6226 int aViewId = anIter1->first;
6227 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6229 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6230 if( anIter2 == aPlaneDataMap.end() )
6232 const TPlaneDataList& aPlaneDataList = anIter2->second;
6234 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6235 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6236 const TPlaneInfo& aPlaneInfo = *anIter3;
6237 int aPlaneId = aPlaneInfo.PlaneId;
6238 const TActorList& anActorList = aPlaneInfo.ActorList;
6239 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6243 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6247 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6249 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6250 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6251 const TPlaneData& aPlaneData = *anIter4;
6252 if( aPlaneData.Id == aPlaneId ) {
6253 SMESH::OrientedPlane* aPlane =
6254 SMESHGUI_ClippingDlg::AddPlane( anActorList,
6256 (SMESH::Orientation)aPlaneData.Orientation,
6257 aPlaneData.Distance,
6260 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6261 aClippingPlaneInfo.Plane = aPlane;
6262 aClippingPlaneInfo.ActorList = anActorList;
6263 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6271 // update all VTK views
6272 QList<SUIT_ViewManager*> lst;
6273 getApp()->viewManagers(lst);
6274 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6275 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6276 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6277 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6278 vtkView->getRenderer()->ResetCameraClippingRange();
6285 \brief Adds preferences for dfont of VTK viewer
6287 \param pIf group identifier
6288 \param param parameter
6289 \return identifier of preferences
6291 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
6293 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6295 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6298 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6299 fam.append( tr( "SMESH_FONT_COURIER" ) );
6300 fam.append( tr( "SMESH_FONT_TIMES" ) );
6302 setPreferenceProperty( tfont, "fonts", fam );
6304 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6305 setPreferenceProperty( tfont, "features", f );
6311 \brief Actions after hypothesis edition
6312 Updates object browser after hypothesis edition
6314 void SMESHGUI::onHypothesisEdit( int result )
6317 SMESHGUI::Modified();
6318 updateObjBrowser( true );
6323 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6324 \param pview view being closed
6326 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6327 #ifndef DISABLE_PLOT2DVIEWER
6328 //Crear all Plot2d Viewers if need.
6329 SMESH::ClearPlot2Viewers(pview);
6333 void SMESHGUI::message( const QString& msg )
6336 QStringList data = msg.split("/");
6337 if ( data.count() > 0 ) {
6338 if ( data.first() == "mesh_loading" ) {
6340 QString entry = data.count() > 1 ? data[1] : QString();
6341 if ( entry.isEmpty() )
6344 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6346 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6349 name = obj->GetName().c_str();
6350 if ( name.isEmpty() )
6353 if ( data.last() == "stop" )
6354 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6356 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6357 QApplication::processEvents();
6363 \brief Connects or disconnects signals about activating and cloning view on the module slots
6364 \param pview view which is connected/disconnected
6366 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6370 SUIT_ViewManager* viewMgr = pview->getViewManager();
6372 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6373 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6375 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6376 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6381 \brief Return \c true if object can be renamed
6383 bool SMESHGUI::renameAllowed( const QString& entry) const {
6384 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6388 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6392 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6397 if(appStudy->isComponent(entry) || obj->isReference())
6400 // check type to prevent renaming of inappropriate objects
6401 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6402 if (aType == MESH || aType == GROUP ||
6403 aType == SUBMESH || aType == SUBMESH_COMPOUND ||
6404 aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
6405 aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
6406 aType == HYPOTHESIS || aType == ALGORITHM)
6413 Rename object by entry.
6414 \param entry entry of the object
6415 \param name new name of the object
6416 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6418 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6420 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6424 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6429 _PTR(Study) aStudy = appStudy->studyDS();
6434 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6436 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6441 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6442 _PTR(GenericAttribute) anAttr;
6443 _PTR(AttributeName) aName;
6445 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6447 // check type to prevent renaming of inappropriate objects
6448 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6449 if (aType == MESH || aType == GROUP ||
6450 aType == SUBMESH || aType == SUBMESH_COMPOUND ||
6451 aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
6452 aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
6453 aType == HYPOTHESIS || aType == ALGORITHM) {
6454 if ( !name.isEmpty() ) {
6455 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6457 // update name of group object and its actor
6458 Handle(SALOME_InteractiveObject) IObject =
6459 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6461 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6462 if( !aGroupObject->_is_nil() ) {
6463 aGroupObject->SetName( qPrintable(name) );
6464 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6465 anActor->setName( qPrintable(name) );