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
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FileInfoDlg.h"
48 #include "SMESHGUI_FileValidator.h"
49 #include "SMESHGUI_FilterDlg.h"
50 #include "SMESHGUI_FilterLibraryDlg.h"
51 #include "SMESHGUI_FindElemByPointDlg.h"
52 #include "SMESHGUI_GroupDlg.h"
53 #include "SMESHGUI_GroupOnShapeDlg.h"
54 #include "SMESHGUI_GroupOpDlg.h"
55 #include "SMESHGUI_Hypotheses.h"
56 #include "SMESHGUI_Make2DFrom3DOp.h"
57 #include "SMESHGUI_MakeNodeAtPointDlg.h"
58 #include "SMESHGUI_Measurements.h"
59 #include "SMESHGUI_MergeDlg.h"
60 #include "SMESHGUI_MeshInfo.h"
61 #include "SMESHGUI_MeshOp.h"
62 #include "SMESHGUI_MeshOrderOp.h"
63 #include "SMESHGUI_MeshPatternDlg.h"
64 #include "SMESHGUI_MultiEditDlg.h"
65 #include "SMESHGUI_NodesDlg.h"
66 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
67 #include "SMESHGUI_PropertiesDlg.h"
68 #include "SMESHGUI_RemoveElementsDlg.h"
69 #include "SMESHGUI_RemoveNodesDlg.h"
70 #include "SMESHGUI_RenumberingDlg.h"
71 #include "SMESHGUI_ReorientFacesDlg.h"
72 #include "SMESHGUI_RevolutionDlg.h"
73 #include "SMESHGUI_RotationDlg.h"
74 #include "SMESHGUI_ScaleDlg.h"
75 #include "SMESHGUI_Selection.h"
76 #include "SMESHGUI_SewingDlg.h"
77 #include "SMESHGUI_SingleEditDlg.h"
78 #include "SMESHGUI_SmoothingDlg.h"
79 #include "SMESHGUI_SymmetryDlg.h"
80 #include "SMESHGUI_TranslationDlg.h"
81 #include "SMESHGUI_TransparencyDlg.h"
83 #include "SMESHGUI_FilterUtils.h"
84 #include "SMESHGUI_GroupUtils.h"
85 #include "SMESHGUI_HypothesesUtils.h"
86 #include "SMESHGUI_MeshUtils.h"
87 #include "SMESHGUI_PatternUtils.h"
88 #include "SMESHGUI_Utils.h"
89 #include "SMESHGUI_VTKUtils.h"
91 #include <SMESH_version.h>
93 #include "SMESH_ControlsDef.hxx"
94 #include <SMESH_Actor.h>
95 #include <SMESH_ActorUtils.h>
96 #include <SMESH_Client.hxx>
97 #include <SMESH_ScalarBarActor.h>
98 #include <SMESH_TypeFilter.hxx>
100 // SALOME GUI includes
101 #include <SalomeApp_Application.h>
102 #include <SalomeApp_CheckFileDlg.h>
103 #include <SalomeApp_DataObject.h>
104 #include <SalomeApp_Study.h>
105 #include <SalomeApp_Tools.h>
107 #include <LightApp_DataOwner.h>
108 #include <LightApp_NameDlg.h>
109 #include <LightApp_Preferences.h>
110 #include <LightApp_SelectionMgr.h>
111 #include <LightApp_UpdateFlags.h>
113 #include <SVTK_ViewManager.h>
114 #include <SVTK_ViewModel.h>
115 #include <SVTK_ViewWindow.h>
117 #include <VTKViewer_Algorithm.h>
119 #include <SUIT_Desktop.h>
120 #include <SUIT_FileDlg.h>
121 #include <SUIT_MessageBox.h>
122 #include <SUIT_OverrideCursor.h>
123 #include <SUIT_ResourceMgr.h>
124 #include <SUIT_Session.h>
126 #include <QtxPopupMgr.h>
127 #include <QtxFontEdit.h>
129 #include <SALOME_ListIO.hxx>
130 #include <SALOME_ListIteratorOfListIO.hxx>
132 #ifndef DISABLE_PLOT2DVIEWER
133 #include <SPlot2d_ViewModel.h>
134 #include <SPlot2d_Histogram.h>
138 #include <SALOMEconfig.h>
139 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
140 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
141 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
144 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
145 #include <QApplication>
147 #include <QTextStream>
150 #include <boost/shared_ptr.hpp>
153 #include <vtkCallbackCommand.h>
154 #include <vtkCamera.h>
155 #include <vtkLookupTable.h>
156 #include <vtkPlane.h>
157 #include <vtkRenderer.h>
159 // SALOME KERNEL includes
160 #include <SALOMEDSClient_ClientFactory.hxx>
161 #include <SALOMEDSClient_IParameters.hxx>
162 #include <SALOMEDSClient_SComponent.hxx>
163 #include <SALOMEDSClient_StudyBuilder.hxx>
164 #include <SALOMEDS_Study.hxx>
167 #include <Standard_ErrorHandler.hxx>
168 #include <NCollection_DataMap.hxx>
170 #include <Basics_Utils.hxx>
172 //To disable automatic genericobj management, the following line should be commented.
173 //Otherwise, it should be uncommented.
174 //Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
175 #define WITHGENERICOBJ
179 //=============================================================
180 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
183 void ExportMeshToFile(int theCommandID);
185 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
187 void SetDisplayEntity(int theCommandID);
189 void Control( int theCommandID );
193 //=============================================================
194 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
198 std::string myExtension;
200 if ( theCommandID == 113 ) {
201 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
202 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
204 else if ( theCommandID == 112 ) {
205 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
207 else if ( theCommandID == 111 ) {
208 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
210 else if ( theCommandID == 115 ) {
211 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
213 else if ( theCommandID == 116 ) {
214 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
216 else if ( theCommandID == 117 ) {
217 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
218 filter.append( QObject::tr( "All files (*)" ) );
220 else if ( theCommandID == 118 ) {
221 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
222 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
225 QString anInitialPath = "";
226 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
227 anInitialPath = QDir::currentPath();
229 QStringList filenames;
230 bool toCreateGroups = true;
232 // if ( theCommandID == 118 ) { // GMF
233 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
234 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
235 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
236 // fd->setNameFilters( filter );
237 // fd->SetChecked( true );
239 // filenames << fd->selectedFile();
240 // toCreateGroups = fd->IsChecked();
246 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
249 QObject::tr( "SMESH_IMPORT_MESH" ) );
251 if ( filenames.count() > 0 ) {
252 SUIT_OverrideCursor wc;
253 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
256 QStringList anEntryList;
257 bool isEmpty = false;
258 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
259 QString filename = *it;
260 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
262 switch ( theCommandID ) {
265 // DAT format (currently unsupported)
266 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
267 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
273 aMeshes->length( 1 );
274 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( 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" ) ) );
283 SMESH::DriverMED_ReadStatus res;
284 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toLatin1().constData(), res );
285 if ( res != SMESH::DRS_OK ) {
286 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
287 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
294 aMeshes->length( 1 );
295 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toLatin1().constData() );
296 if ( aMeshes[0]->_is_nil() ) {
297 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
298 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
305 SMESH::DriverMED_ReadStatus res;
306 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toLatin1().constData(), res );
307 if ( res != SMESH::DRS_OK ) {
308 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
309 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
316 SMESH::DriverMED_ReadStatus res;
317 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toLatin1().constData(), res );
318 if ( res != SMESH::DRS_OK ) {
319 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
320 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
327 SMESH::ComputeError_var res;
328 aMeshes->length( 1 );
329 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toLatin1().constData(),
332 if ( res->code != SMESH::DRS_OK ) {
333 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
334 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
335 if ( strlen( res->comment.in() ) > 0 ) {
336 errors.back() += ": ";
337 errors.back() += res->comment.in();
344 catch ( const SALOME::SALOME_Exception& S_ex ) {
345 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
346 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
349 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
350 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
352 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
353 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
354 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
355 if ( theCommandID == 112 ) // mesh names aren't taken from the file for UNV import
356 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
358 anEntryList.append( aMeshSO->GetID().c_str() );
360 // obj has been published in study. Its refcount has been incremented.
361 // It is safe to decrement its refcount
362 // so that it will be destroyed when the entry in study will be removed
363 aMeshes[i]->UnRegister();
371 // update Object browser
372 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
374 // browse to the published meshes
375 if( LightApp_Application* anApp =
376 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
377 anApp->browseObjects( anEntryList );
379 // show Error message box if there were errors
380 if ( errors.count() > 0 ) {
381 SUIT_MessageBox::critical( SMESHGUI::desktop(),
382 QObject::tr( "SMESH_ERROR" ),
383 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
386 // show warning message box, if some imported mesh is empty
388 SUIT_MessageBox::warning( SMESHGUI::desktop(),
389 QObject::tr( "SMESH_WRN_WARNING" ),
390 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
395 //================================================================================
397 * \brief Export selected meshes or groups into a file
399 //================================================================================
401 void ExportMeshToFile( int theCommandID )
403 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
404 SALOME_ListIO selected;
406 aSel->selectedObjects( selected );
408 const bool isMED = ( theCommandID == 122 || theCommandID == 125 );
409 const bool isDAT = ( theCommandID == 121 || theCommandID == 124 );
410 const bool isUNV = ( theCommandID == 123 || theCommandID == 126 );
411 const bool isSTL = ( theCommandID == 140 || theCommandID == 141 );
412 const bool isCGNS= ( theCommandID == 142 || theCommandID == 143 );
413 const bool isSAUV= ( theCommandID == 144 || theCommandID == 145 );
414 const bool isGMF = ( theCommandID == 146 || theCommandID == 147 );
416 // actually, the following condition can't be met (added for insurance)
417 if( selected.Extent() == 0 ||
418 ( selected.Extent() > 1 && !isMED && !isSTL ))
421 // get mesh object from selection and check duplication of their names
422 bool hasDuplicatedMeshNames = false;
423 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
424 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
425 SALOME_ListIteratorOfListIO It( selected );
426 for( ; It.More(); It.Next() )
428 Handle(SALOME_InteractiveObject) anIObject = It.Value();
429 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
430 if ( aMeshItem->_is_nil() ) {
431 SUIT_MessageBox::warning( SMESHGUI::desktop(),
432 QObject::tr( "SMESH_WRN_WARNING" ),
433 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
437 QString aMeshName = anIObject->getName();
439 // check for name duplications
440 if ( !hasDuplicatedMeshNames )
441 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
442 if( aMeshName == (*aMeshIter).second ) {
443 hasDuplicatedMeshNames = true;
448 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
451 if( hasDuplicatedMeshNames && isMED ) {
452 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
453 QObject::tr("SMESH_WRN_WARNING"),
454 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
455 QObject::tr("SMESH_BUT_YES"),
456 QObject::tr("SMESH_BUT_NO"), 0, 1);
461 aMeshIter = aMeshList.begin();
462 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
463 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
464 QString aMeshName = (*aMeshIter).second;
466 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
468 // check for equal group names within each mesh
469 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
470 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
471 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
472 int aRet = SUIT_MessageBox::warning
473 (SMESHGUI::desktop(),
474 QObject::tr("SMESH_WRN_WARNING"),
475 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
476 QObject::tr("SMESH_BUT_YES"),
477 QObject::tr("SMESH_BUT_NO"), 0, 1);
484 // Warn the user about presence of not supported elements
486 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
490 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Quadrangle );
491 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
492 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
493 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
494 notSupportedElemTypes.push_back( SMESH::Entity_Tetra );
495 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Tetra );
496 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
497 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
498 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Hexa );
499 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
500 notSupportedElemTypes.push_back( SMESH::Entity_Penta );
501 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
502 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
503 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
504 notSupportedElemTypes.push_back( SMESH::Entity_0D );
505 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
510 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
511 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
512 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
513 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
514 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
515 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
516 notSupportedElemTypes.push_back( SMESH::Entity_0D );
517 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
522 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
523 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
524 notSupportedElemTypes.push_back( SMESH::Entity_0D );
525 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
530 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
535 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
536 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
537 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
538 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
539 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
540 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
545 notSupportedElemTypes.push_back( SMESH::Entity_0D );
546 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Quadrangle );
547 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
548 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
549 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
550 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Hexa );
551 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
552 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
553 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
554 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
555 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
557 if ( ! notSupportedElemTypes.empty() )
559 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
560 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
561 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
562 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
564 if ( !presentNotSupported.empty() )
567 const char* typeMsg[SMESH::Entity_Last] = { "SMESH_NODES",
568 "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES","SMESH_TRIANGLES",
569 "SMESH_QUADRATIC_TRIANGLES","SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES",
570 "SMESH_BIQUADRATIC_QUADRANGLES","SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
571 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
572 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
573 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
574 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
576 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
577 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
578 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
579 if ( iType != presentNotSupported.size() - 1 )
580 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
582 int aRet = SUIT_MessageBox::warning
583 (SMESHGUI::desktop(),
584 QObject::tr("SMESH_WRN_WARNING"),
585 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
586 QObject::tr("SMESH_BUT_YES"),
587 QObject::tr("SMESH_BUT_NO"), 0, 1);
592 // Get parameters of export operation
595 SMESH::MED_VERSION aFormat;
596 // Init the parameters with the default values
597 bool aIsASCII_STL = true;
598 bool toCreateGroups = false;
599 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
601 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
602 bool toOverwrite = true;
604 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
605 QString anInitialPath = "";
606 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
607 anInitialPath = QDir::currentPath();
609 // Get a file name to write in and additional otions
610 if ( isUNV || isDAT || isGMF ) // Export w/o options
613 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
615 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
617 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
618 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
619 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
620 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
621 anInitialPath + QString("/") + aMeshName,
622 aFilter, aTitle, false);
624 // else if ( isGMF )// Export to GMF
626 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
627 // ( SMESHGUI::desktop(), false, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
628 // QStringList filters;
629 // filters << QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)"
630 // << QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
631 // fd->setWindowTitle( aTitle );
632 // fd->setNameFilters( filters );
634 // if ( !aMeshOrGroup->_is_equivalent( aMesh ))
635 // toCreateGroups = false;
637 // toCreateGroups = ( aMesh->NbGroups() > 0 );
639 // fd->SetChecked( true );
640 // if ( !anInitialPath.isEmpty() )
641 // fd->setDirectory( anInitialPath );
642 // fd->selectFile(aMeshName);
645 // aFilename = fd->selectedFile();
646 // toCreateGroups = fd->IsChecked();
650 else if ( isCGNS )// Export to CGNS
652 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
653 fd->setWindowTitle( aTitle );
654 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
655 if ( !anInitialPath.isEmpty() )
656 fd->setDirectory( anInitialPath );
657 fd->selectFile(aMeshName);
658 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
659 fd->setValidator( fv );
662 aFilename = fd->selectedFile();
663 toOverwrite = fv->isOverwrite();
667 else if ( isSTL ) // Export to STL
669 QMap<QString, int> aFilterMap;
670 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
671 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
674 QMap<QString, int>::const_iterator it = aFilterMap.begin();
675 for ( ; it != aFilterMap.end(); ++it )
676 filters.push_back( it.key() );
678 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
679 fd->setWindowTitle( aTitle );
680 fd->setNameFilters( filters );
681 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
682 if ( !anInitialPath.isEmpty() )
683 fd->setDirectory( anInitialPath );
684 fd->selectFile(aMeshName);
688 aFilename = fd->selectedFile();
689 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
694 else if ( isMED || isSAUV ) // Export to MED or SAUV
696 QMap<QString, SMESH::MED_VERSION> aFilterMap;
697 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
699 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
700 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
701 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
704 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
705 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
706 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
710 QString aDefaultFilter;
711 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
712 for ( ; it != aFilterMap.end(); ++it ) {
713 filters.push_back( it.key() );
714 if (it.value() == SMESH::MED_V2_2)
715 aDefaultFilter = it.key();
718 SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
719 ( SMESHGUI::desktop(), false, QObject::tr("SMESH_AUTO_GROUPS"), true, true );
720 fd->setWindowTitle( aTitle );
721 fd->setNameFilters( filters );
722 fd->selectNameFilter(aDefaultFilter);
723 fd->SetChecked(toCreateGroups);
724 if ( !anInitialPath.isEmpty() )
725 fd->setDirectory( anInitialPath );
726 fd->selectFile(aMeshName);
728 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
729 fd->setValidator( fv );
734 aFilename = fd->selectedFile();
736 aFilename = QString::null;
739 aFormat = aFilterMap[fd->selectedNameFilter()];
740 toOverwrite = fv->isOverwrite();
742 if ( !aFilename.isEmpty() ) {
743 // med-2.1 does not support poly elements
744 if ( aFormat==SMESH::MED_V2_1 )
745 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
746 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
747 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
748 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
749 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
751 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
752 QObject::tr("SMESH_WRN_WARNING"),
753 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
754 QObject::tr("SMESH_BUT_YES"),
755 QObject::tr("SMESH_BUT_NO"), 0, 1);
763 // can't append to an existing using other format
764 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
765 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toLatin1().constData(), aVersion );
766 if( !isVersionOk || aVersion != aFormat ) {
767 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
768 QObject::tr("SMESH_WRN_WARNING"),
769 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
770 QObject::tr("SMESH_BUT_YES"),
771 QObject::tr("SMESH_BUT_NO"), 0, 1);
778 QStringList aMeshNamesCollisionList;
779 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toLatin1().constData() );
780 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
781 QString anExistingMeshName( aMeshNames[ i ] );
782 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
783 QString anExportMeshName = (*aMeshIter).second;
784 if( anExportMeshName == anExistingMeshName ) {
785 aMeshNamesCollisionList.append( anExportMeshName );
790 if( !aMeshNamesCollisionList.isEmpty() ) {
791 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
792 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
793 QObject::tr("SMESH_WRN_WARNING"),
794 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
795 QObject::tr("SMESH_BUT_YES"),
796 QObject::tr("SMESH_BUT_NO"),
797 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
806 toCreateGroups = fd->IsChecked();
816 if ( !aFilename.isEmpty() ) {
817 // Check whether the file already exists and delete it if yes
818 QFile aFile( aFilename );
819 if ( aFile.exists() && toOverwrite )
821 SUIT_OverrideCursor wc;
824 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
825 // bool Renumber = false;
826 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
828 // Renumber= resMgr->booleanValue("renumbering");
830 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
831 // aMeshEditor->RenumberNodes();
832 // aMeshEditor->RenumberElements();
833 // if ( SMESHGUI::automaticUpdate() )
834 // SMESH::UpdateView();
838 aMeshIter = aMeshList.begin();
839 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
841 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
842 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
843 if ( aMeshOrGroup->_is_equivalent( aMeshItem ))
844 aMeshItem->ExportToMEDX( aFilename.toLatin1().data(), toCreateGroups,
845 aFormat, toOverwrite && aMeshIndex == 0 );
847 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups,
848 aFormat, toOverwrite && aMeshIndex == 0 );
853 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
855 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
856 if( !aMeshItem->_is_nil() )
857 aMeshItem->ExportSAUV( aFilename.toLatin1().data(), toCreateGroups );
862 if ( aMeshOrGroup->_is_equivalent( aMesh ))
863 aMesh->ExportDAT( aFilename.toLatin1().data() );
865 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toLatin1().data() );
869 if ( aMeshOrGroup->_is_equivalent( aMesh ))
870 aMesh->ExportUNV( aFilename.toLatin1().data() );
872 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toLatin1().data() );
876 if ( aMeshOrGroup->_is_equivalent( aMesh ))
877 aMesh->ExportSTL( aFilename.toLatin1().data(), aIsASCII_STL );
879 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toLatin1().data(), aIsASCII_STL );
883 aMeshIter = aMeshList.begin();
884 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
886 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
887 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
888 aMeshItem->ExportCGNS( aMeshOrGroup,
889 aFilename.toLatin1().data(),
890 toOverwrite && aMeshIndex == 0 );
895 toCreateGroups = true;
896 aMesh->ExportGMF( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups );
899 catch (const SALOME::SALOME_Exception& S_ex){
901 SUIT_MessageBox::warning(SMESHGUI::desktop(),
902 QObject::tr("SMESH_WRN_WARNING"),
903 QObject::tr("SMESH_EXPORT_FAILED"));
909 inline void InverseEntityMode(unsigned int& theOutputMode,
910 unsigned int theMode)
912 bool anIsNotPresent = ~theOutputMode & theMode;
914 theOutputMode |= theMode;
916 theOutputMode &= ~theMode;
919 void SetDisplayEntity(int theCommandID){
920 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
921 SALOME_ListIO selected;
923 aSel->selectedObjects( selected );
925 if(selected.Extent() >= 1){
926 SALOME_ListIteratorOfListIO It( selected );
927 for( ; It.More(); It.Next()){
928 Handle(SALOME_InteractiveObject) IObject = It.Value();
929 if(IObject->hasEntry()){
930 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
931 unsigned int aMode = anActor->GetEntityMode();
932 switch(theCommandID){
934 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
937 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
940 InverseEntityMode(aMode,SMESH_Actor::eEdges);
943 InverseEntityMode(aMode,SMESH_Actor::eFaces);
946 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
949 aMode = SMESH_Actor::eAllEntity;
953 anActor->SetEntityMode(aMode);
961 SALOME_ListIO selected;
962 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
966 LightApp_SelectionMgr* aSel = app->selectionMgr();
967 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
968 if( !aSel || !appStudy )
971 aSel->selectedObjects( selected );
972 if( selected.IsEmpty() )
975 Handle(SALOME_InteractiveObject) anIObject = selected.First();
977 _PTR(Study) aStudy = appStudy->studyDS();
978 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
979 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
980 if( aMainObject->_is_nil() )
983 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
985 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
986 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
988 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
989 SALOMEDS::Color aColor = aGroupObject->GetColor();
990 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
994 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
995 switch ( aGroupObject->GetType ()) {
997 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
999 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1001 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1003 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1005 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1006 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1009 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1010 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1016 SMESH::RepaintCurrentView();
1019 QString functorToString( SMESH::Controls::FunctorPtr f )
1021 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1022 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1023 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1024 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1025 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1026 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1027 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1028 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1029 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1030 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1031 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1032 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1033 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1034 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1035 type = QObject::tr( "WARP_ELEMENTS" );
1036 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1037 type = QObject::tr( "TAPER_ELEMENTS" );
1038 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1039 type = QObject::tr( "SKEW_ELEMENTS" );
1040 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1041 type = QObject::tr( "AREA_ELEMENTS" );
1042 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1043 type = QObject::tr( "LENGTH_EDGES" );
1044 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1045 type = QObject::tr( "LENGTH2D_EDGES" );
1046 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1047 type = QObject::tr( "MULTI_BORDERS" );
1048 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1049 type = QObject::tr( "MULTI2D_BORDERS" );
1050 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1051 type = QObject::tr( "FREE_NODES" );
1052 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1053 type = QObject::tr( "FREE_EDGES" );
1054 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1055 type = QObject::tr( "FREE_BORDERS" );
1056 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1057 type = QObject::tr( "FREE_FACES" );
1058 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1059 type = QObject::tr( "BARE_BORDER_VOLUME" );
1060 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1061 type = QObject::tr( "BARE_BORDER_FACE" );
1062 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1063 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1064 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1065 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1066 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1067 type = QObject::tr( "EQUAL_NODE" );
1068 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1069 type = QObject::tr( "EQUAL_EDGE" );
1070 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1071 type = QObject::tr( "EQUAL_FACE" );
1072 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1073 type = QObject::tr( "EQUAL_VOLUME" );
1077 void SaveDistribution()
1079 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1080 SALOME_ListIO selected;
1082 aSel->selectedObjects( selected );
1084 if ( selected.Extent() == 1 ) {
1085 Handle(SALOME_InteractiveObject) anIO = selected.First();
1086 if ( anIO->hasEntry() ) {
1087 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1088 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1089 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1090 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1091 if ( aScalarBarActor && aFunctor ) {
1092 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1094 std::vector<int> elements;
1095 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1096 if ( mesh->_is_nil() ) {
1097 SMESH::SMESH_IDSource_var idSource =
1098 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1099 if ( !idSource->_is_nil() )
1101 SMESH::long_array_var ids = idSource->GetIDs();
1102 elements.resize( ids->length() );
1103 for ( unsigned i = 0; i < elements.size(); ++i )
1104 elements[i] = ids[i];
1107 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1108 vtkLookupTable* lookupTable =
1109 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1110 double * minmax = lookupTable->GetRange();
1111 std::vector<int> nbEvents;
1112 std::vector<double> funValues;
1113 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax );
1114 QString anInitialPath = "";
1115 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1116 anInitialPath = QDir::currentPath();
1117 QString aMeshName = anIO->getName();
1119 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1120 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1121 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1122 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1123 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1126 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1128 if ( !aFilename.isEmpty() ) {
1129 QFile f( aFilename );
1130 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1131 QTextStream out( &f );
1132 out << "# Mesh: " << aMeshName << endl;
1133 out << "# Control: " << functorToString( aFunctor ) << endl;
1135 out.setFieldWidth( 10 );
1136 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1137 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1148 void ShowDistribution() {
1149 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1150 SALOME_ListIO selected;
1152 aSel->selectedObjects( selected );
1154 if ( selected.Extent() == 1 ) {
1155 Handle(SALOME_InteractiveObject) anIO = selected.First();
1156 if ( anIO->hasEntry() ) {
1157 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1158 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1159 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1160 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1166 #ifndef DISABLE_PLOT2DVIEWER
1167 void PlotDistribution() {
1168 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1172 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1173 SALOME_ListIO selected;
1175 aSel->selectedObjects( selected );
1177 if ( selected.Extent() == 1 ) {
1178 Handle(SALOME_InteractiveObject) anIO = selected.First();
1179 if ( anIO->hasEntry() ) {
1180 //Find Actor by entry before getting Plot2d viewer,
1181 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1182 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1184 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1189 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1193 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1197 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1198 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1199 QString functorName = functorToString( anActor->GetFunctor());
1200 QString aHistogramName("%1 : %2");
1201 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1202 aHistogram->setName(aHistogramName);
1203 aHistogram->setHorTitle(functorName);
1204 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1205 aPlot->displayObject(aHistogram, true);
1210 #endif //DISABLE_PLOT2DVIEWER
1212 void DisableAutoColor(){
1213 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1214 SALOME_ListIO selected;
1216 aSel->selectedObjects( selected );
1218 if(selected.Extent()){
1219 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1220 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1221 if ( !aMesh->_is_nil() ) {
1222 aMesh->SetAutoColor( false );
1227 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1229 SALOME_ListIO selected;
1230 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1234 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1235 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1236 if( !aSel || !appStudy )
1239 if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection
1240 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1241 aModule->EmitSignalDeactivateDialog();
1242 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1243 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1248 _PTR(Study) aStudy = appStudy->studyDS();
1250 aSel->selectedObjects( selected );
1252 if(selected.Extent() >= 1){
1253 switch(theCommandID){
1255 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1256 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1260 vtkFloatingPointType color[3];
1261 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1262 QColor orientationColor, outlineColor, volumeColor;
1263 int deltaF = 0, deltaV = 0;
1267 int outlineWidth = 1;
1268 vtkFloatingPointType shrinkCoef = 0.0;
1269 vtkFloatingPointType orientationScale = 0.0;
1270 bool orientation3d = false;
1271 VTK::MarkerType markerType = VTK::MT_NONE;
1272 VTK::MarkerScale markerScale = VTK::MS_NONE;
1274 bool hasNodes = false;
1275 int presentEntities = 0;
1276 bool firstTime = true;
1278 SALOME_ListIteratorOfListIO It( selected );
1279 for ( ; It.More(); It.Next() ) {
1280 Handle(SALOME_InteractiveObject) IObject = It.Value();
1281 if ( !IObject->hasEntry() ) continue;
1282 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1283 if ( !anActor || !anActor->GetObject() ) continue;
1286 // nodes: color, marker
1287 anActor->GetNodeColor( color[0], color[1], color[2] );
1288 nodeColor.setRgbF( color[0], color[1], color[2] );
1289 markerType = anActor->GetMarkerType();
1290 markerScale = anActor->GetMarkerScale();
1291 markerId = anActor->GetMarkerTexture();
1292 // edges: color, width
1293 anActor->GetEdgeColor( color[0], color[1], color[2] );
1294 edgeColor.setRgbF( color[0], color[1], color[2] );
1295 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1296 // faces: front color, back color (delta)
1297 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1298 faceColor.setRgbF( color[0], color[1], color[2] );
1299 // faces: front color, back color (delta)
1300 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1301 volumeColor.setRgbF( color[0], color[1], color[2] );
1302 // 0d elements: color, size
1303 anActor->Get0DColor( color[0], color[1], color[2] );
1304 elem0dColor.setRgbF( color[0], color[1], color[2] );
1305 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1306 // balls: color, size
1307 anActor->GetBallColor( color[0], color[1], color[2] );
1308 ballColor.setRgbF( color[0], color[1], color[2] );
1309 ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1311 anActor->GetOutlineColor( color[0], color[1], color[2] );
1312 outlineColor.setRgbF( color[0], color[1], color[2] );
1313 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1314 // orientation vectors: color, scale, 3d flag
1315 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1316 orientationColor.setRgbF( color[0], color[1], color[2] );
1317 orientationScale = anActor->GetFacesOrientationScale();
1318 orientation3d = anActor->GetFacesOrientation3DVectors();
1320 shrinkCoef = anActor->GetShrinkFactor();
1323 firstTime = false; // we only take properties from first object (for performance reasons)
1326 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1327 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1328 presentEntities = presentEntities | SMESH_Actor::eEdges;
1329 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1330 presentEntities = presentEntities | SMESH_Actor::eFaces;
1331 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1332 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1333 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1334 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1335 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1336 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1338 // as we know that all types of elements are present, we can exit the loop
1339 if ( presentEntities == SMESH_Actor::eAllEntity )
1343 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1344 // nodes: color, marker
1345 dlg.setNodeColor( nodeColor );
1346 if( markerType != VTK::MT_USER )
1347 dlg.setNodeMarker( markerType, markerScale );
1349 dlg.setNodeCustomMarker( markerId );
1350 // edges: color, line width
1351 dlg.setEdgeColor( edgeColor );
1352 dlg.setEdgeWidth( edgeWidth );
1353 // faces: front color, back color
1354 dlg.setFaceColor( faceColor, deltaF );
1355 // volumes: normal color, reversed color
1356 dlg.setVolumeColor( volumeColor, deltaV );
1357 // outlines: color, line width
1358 dlg.setOutlineColor( outlineColor );
1359 dlg.setOutlineWidth( outlineWidth );
1360 // 0d elements: color, size
1361 dlg.setElem0dColor( elem0dColor );
1362 dlg.setElem0dSize( elem0dSize );
1363 // balls: color, size
1364 dlg.setBallColor( ballColor );
1365 dlg.setBallSize( ballSize );
1366 // orientation: color, scale, 3d flag
1367 dlg.setOrientationColor( orientationColor );
1368 dlg.setOrientationSize( int( orientationScale * 100. ) );
1369 dlg.setOrientation3d( orientation3d );
1370 // shrink: scale factor
1371 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1372 // hide unused controls
1373 dlg.showControls( presentEntities, hasNodes );
1376 nodeColor = dlg.nodeColor();
1377 markerType = dlg.nodeMarkerType();
1378 markerScale = dlg.nodeMarkerScale();
1379 markerId = dlg.nodeMarkerId();
1380 edgeColor = dlg.edgeColor();
1381 edgeWidth = dlg.edgeWidth();
1382 faceColor = dlg.faceColor();
1383 deltaF = dlg.faceColorDelta();
1384 volumeColor = dlg.volumeColor();
1385 deltaV = dlg.volumeColorDelta();
1386 outlineColor = dlg.outlineColor();
1387 outlineWidth = dlg.outlineWidth();
1388 elem0dColor = dlg.elem0dColor();
1389 elem0dSize = dlg.elem0dSize();
1390 ballColor = dlg.ballColor();
1391 ballSize = dlg.ballSize();
1392 orientationColor = dlg.orientationColor();
1393 orientationScale = dlg.orientationSize() / 100.;
1394 orientation3d = dlg.orientation3d();
1395 shrinkCoef = dlg.shrinkCoef() / 100.;
1397 // store point markers map that might be changed by the user
1398 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1400 // set properties from dialog box to the presentations
1401 SALOME_ListIteratorOfListIO It( selected );
1402 for ( ; It.More(); It.Next() ) {
1403 Handle(SALOME_InteractiveObject) IObject = It.Value();
1404 if ( !IObject->hasEntry() ) continue;
1405 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1406 if ( !anActor ) continue;
1408 // nodes: color, marker
1409 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1410 if ( markerType != VTK::MT_USER ) {
1411 anActor->SetMarkerStd( markerType, markerScale );
1414 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1415 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1416 if ( iter != markerMap.end() )
1417 anActor->SetMarkerTexture( markerId, iter->second.second );
1419 // volumes: normal color, reversed color (delta)
1420 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1421 // faces: front color, back color (delta)
1422 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1423 // edges: color, width
1424 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1425 anActor->SetLineWidth( edgeWidth );
1427 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1428 anActor->SetOutlineWidth( outlineWidth );
1429 // 0D elements: color, size
1430 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1431 anActor->Set0DSize( elem0dSize );
1432 // balls: color, size
1433 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1434 anActor->SetBallSize( ballSize );
1435 // orientation: color, scale, 3d flag
1436 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1437 anActor->SetFacesOrientationScale( orientationScale );
1438 anActor->SetFacesOrientation3DVectors( orientation3d );
1440 anActor->SetShrinkFactor( shrinkCoef );
1442 // for groups, set also proper color
1443 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1444 if ( !aGroupObject->_is_nil() ) {
1445 SMESH::ElementType anElementType = aGroupObject->GetType();
1447 switch( anElementType ) {
1449 aColor = nodeColor; break;
1451 aColor = edgeColor; break;
1453 aColor = faceColor; break;
1455 aColor = volumeColor; break;
1457 aColor = elem0dColor; break;
1459 aColor = ballColor; break;
1463 if ( aColor.isValid() ) {
1464 SALOMEDS::Color aGroupColor;
1465 aGroupColor.R = aColor.redF();
1466 aGroupColor.G = aColor.greenF();
1467 aGroupColor.B = aColor.blueF();
1468 aGroupObject->SetColor( aGroupColor );
1470 } // if ( !aGroupObject->_is_nil() )
1471 } // for ( ; It.More(); It.Next() )
1472 SMESH::RepaintCurrentView();
1473 } // if ( dlg.exec() )
1476 } // switch(theCommandID)
1477 SALOME_ListIteratorOfListIO It( selected );
1478 for( ; It.More(); It.Next()){
1479 Handle(SALOME_InteractiveObject) IObject = It.Value();
1480 if(IObject->hasEntry()){
1481 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1482 switch(theCommandID){
1484 anActor->SetRepresentation(SMESH_Actor::eEdge);
1487 anActor->SetRepresentation(SMESH_Actor::eSurface);
1490 if(anActor->IsShrunk())
1491 anActor->UnShrink();
1493 anActor->SetShrink();
1496 anActor->SetRepresentation(SMESH_Actor::ePoint);
1499 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1500 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1503 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1504 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1510 SMESH::RepaintCurrentView();
1514 void Control( int theCommandID )
1516 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1517 SALOME_ListIO selected;
1519 aSel->selectedObjects( selected );
1521 if( !selected.IsEmpty() ){
1522 Handle(SALOME_InteractiveObject) anIO = selected.First();
1524 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1525 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1526 switch ( theCommandID ){
1528 aControl = SMESH_Actor::eLength;
1531 aControl = SMESH_Actor::eLength2D;
1534 aControl = SMESH_Actor::eFreeEdges;
1537 aControl = SMESH_Actor::eFreeBorders;
1540 aControl = SMESH_Actor::eMultiConnection;
1543 aControl = SMESH_Actor::eFreeNodes;
1546 aControl = SMESH_Actor::eMultiConnection2D;
1549 aControl = SMESH_Actor::eArea;
1552 aControl = SMESH_Actor::eTaper;
1555 aControl = SMESH_Actor::eAspectRatio;
1558 aControl = SMESH_Actor::eAspectRatio3D;
1561 aControl = SMESH_Actor::eMinimumAngle;
1564 aControl = SMESH_Actor::eWarping;
1567 aControl = SMESH_Actor::eSkew;
1570 aControl = SMESH_Actor::eVolume3D;
1573 aControl = SMESH_Actor::eFreeFaces;
1576 aControl = SMESH_Actor::eMaxElementLength2D;
1579 aControl = SMESH_Actor::eMaxElementLength3D;
1582 aControl = SMESH_Actor::eBareBorderVolume;
1585 aControl = SMESH_Actor::eBareBorderFace;
1588 aControl = SMESH_Actor::eOverConstrainedVolume;
1591 aControl = SMESH_Actor::eOverConstrainedFace;
1594 aControl = SMESH_Actor::eCoincidentNodes;
1597 aControl = SMESH_Actor::eCoincidentElems1D;
1600 aControl = SMESH_Actor:: eCoincidentElems2D;
1603 aControl = SMESH_Actor::eCoincidentElems3D;
1607 anActor->SetControlMode(aControl);
1608 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1609 SMESH::RepaintCurrentView();
1610 #ifndef DISABLE_PLOT2DVIEWER
1611 if(anActor->GetPlot2Histogram()) {
1612 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1613 QString functorName = functorToString( anActor->GetFunctor());
1614 QString aHistogramName("%1 : %2");
1615 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1616 aHistogram->setName(aHistogramName);
1617 aHistogram->setHorTitle(functorName);
1618 SMESH::ProcessIn2DViewers(anActor);
1627 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1628 SMESH::MeshObjectType theType,
1629 const QString theInTypeName,
1630 QString & theOutTypeName)
1632 SMESH_TypeFilter aTypeFilter( theType );
1634 if( !theIO.IsNull() )
1636 entry = theIO->getEntry();
1637 LightApp_DataOwner owner( entry );
1638 if ( aTypeFilter.isOk( &owner )) {
1639 theOutTypeName = theInTypeName;
1647 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1649 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1650 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1652 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1653 CORBA::String_var anID = aSComp->GetID().c_str();
1654 if (!strcmp(anID.in(),theIO->getEntry()))
1660 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1661 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1662 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1663 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1664 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1672 QString CheckHomogeneousSelection()
1674 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1675 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1676 SALOME_ListIO selected;
1678 aSel->selectedObjects( selected );
1680 QString RefType = CheckTypeObject(selected.First());
1681 SALOME_ListIteratorOfListIO It(selected);
1682 for ( ; It.More(); It.Next())
1684 Handle(SALOME_InteractiveObject) IObject = It.Value();
1685 QString Type = CheckTypeObject(IObject);
1686 if (Type.compare(RefType) != 0)
1687 return "Heterogeneous Selection";
1694 void SMESHGUI::OnEditDelete()
1696 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1697 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1698 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1700 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1701 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1702 _PTR(GenericAttribute) anAttr;
1703 _PTR(AttributeIOR) anIOR;
1705 int objectCount = 0;
1707 QString aParentComponent = QString::null;
1708 Handle(SALOME_InteractiveObject) anIO;
1709 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1711 anIO = anIt.Value();
1712 QString cur = anIO->getComponentDataType();
1713 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1715 // check if object is reference
1716 _PTR(SObject) aRefSObj;
1717 aNameList.append("\n - ");
1718 if ( aSO->ReferencedObject( aRefSObj ) ) {
1719 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1720 aNameList.append( aRefName );
1721 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1724 aNameList.append(anIO->getName());
1728 if( aParentComponent.isNull() )
1729 aParentComponent = cur;
1730 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1731 aParentComponent = "";
1734 if ( objectCount == 0 )
1735 return; // No Valid Objects Selected
1737 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1738 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1739 QObject::tr("ERR_ERROR"),
1740 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1743 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1744 if (SUIT_MessageBox::warning
1745 (SMESHGUI::desktop(),
1746 QObject::tr("SMESH_WRN_WARNING"),
1747 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1748 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1749 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1752 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1754 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1755 // then treat them all starting from the deepest objects (at list back)
1756 std::list< _PTR(SObject) > listSO;
1757 SALOME_ListIteratorOfListIO It(selected);
1758 for( ; It.More(); It.Next()) // loop on selected IO's
1760 Handle(SALOME_InteractiveObject) IObject = It.Value();
1761 if(IObject->hasEntry()) {
1762 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1764 // disable removal of "SMESH" component object
1765 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1767 if ( engineIOR() == anIOR->Value().c_str() )
1770 //Check the referenced object
1771 _PTR(SObject) aRefSObject;
1772 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1773 aSO = aRefSObject; // Delete main Object instead of reference
1775 listSO.push_back( aSO );
1776 std::list< _PTR(SObject) >::iterator itSO = listSO.begin();
1777 for ( ; itSO != listSO.end(); ++itSO ) {
1778 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1779 for (it->InitEx(false); it->More(); it->Next())
1780 listSO.push_back( it->Value() );
1784 // Check if none of objects to delete is referred from outside
1785 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1786 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1788 _PTR(SObject) SO = *ritSO;
1789 if ( !SO ) continue;
1790 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1791 for (size_t i = 0; i < aReferences.size(); i++) {
1792 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1793 std::string type = aComponent->ComponentDataType();
1794 if ( type != "SMESH" )
1796 SUIT_MessageBox::warning( anApp->desktop(),
1797 QObject::tr("WRN_WARNING"),
1798 QObject::tr("DEP_OBJECT") );
1799 return; // outside SMESH, there is an object depending on a SMESH object
1804 // Treat SO's in the list starting from the back
1805 aStudyBuilder->NewCommand(); // There is a transaction
1806 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1808 _PTR(SObject) SO = *ritSO;
1809 if ( !SO ) continue;
1810 std::string anEntry = SO->GetID();
1812 /** Erase graphical object **/
1813 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1814 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1815 // ViewManagerList aViewMenegers = anApp->viewManagers();
1816 // ViewManagerList::const_iterator it = aViewMenegers.begin();
1817 // for( ; it != aViewMenegers.end(); it++) {
1818 // SUIT_ViewManager* vm = *it;
1819 // int nbSf = vm ? vm->getViewsCount() : 0;
1821 // QVector<SUIT_ViewWindow*> aViews = vm->getViews();
1822 // for(int i = 0; i < nbSf; i++){
1823 // SUIT_ViewWindow *sf = aViews[i];
1824 // if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
1825 // SMESH::RemoveActor(sf,anActor);
1831 /** Remove an object from data structures **/
1832 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1833 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1834 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1835 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1836 aMesh->RemoveGroup( aGroup );
1838 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1839 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1840 aMesh->RemoveSubMesh( aSubMesh );
1842 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1844 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1847 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1848 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1849 QString objType = CheckTypeObject(IObject);
1850 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1851 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1852 aStudyBuilder->RemoveObjectWithChildren( SO );
1854 else {// default action: remove SObject from the study
1855 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1856 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1858 aStudyBuilder->RemoveObjectWithChildren( SO );
1862 } /* listSO back loop */
1864 aStudyBuilder->CommitCommand();
1866 /* Clear any previous selection */
1868 aSel->setSelectedObjects( l1 );
1870 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1875 SMESHGUI_EXPORT CAM_Module* createModule()
1877 return new SMESHGUI();
1880 SMESHGUI_EXPORT char* getModuleVersion() {
1881 return (char*)SMESH_VERSION_STR;
1885 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1887 //=============================================================================
1891 //=============================================================================
1892 SMESHGUI::SMESHGUI() :
1893 SalomeApp_Module( "SMESH" )
1895 if ( CORBA::is_nil( myComponentSMESH ) )
1897 CORBA::Boolean anIsEmbeddedMode;
1898 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1899 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1901 // 0019923: EDF 765 SMESH : default values of hypothesis
1902 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1903 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1904 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1905 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1906 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1908 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1909 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1910 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1912 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1913 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1917 myActiveDialogBox = 0;
1918 myFilterLibraryDlg = 0;
1922 myEventCallbackCommand = vtkCallbackCommand::New();
1923 myEventCallbackCommand->Delete();
1924 myEventCallbackCommand->SetClientData( this );
1925 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1928 /* load resources for all available meshers */
1929 SMESH::InitAvailableHypotheses();
1932 //=============================================================================
1936 //=============================================================================
1937 SMESHGUI::~SMESHGUI()
1941 //=============================================================================
1945 //=============================================================================
1946 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1948 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1950 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1955 //=============================================================================
1959 //=============================================================================
1960 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1962 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1966 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
1967 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1968 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
1969 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
1970 return autoUpdate && !exceeded;
1973 //=============================================================================
1977 //=============================================================================
1978 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
1980 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
1983 //=============================================================================
1987 //=============================================================================
1988 SMESHGUI* SMESHGUI::GetSMESHGUI()
1990 SMESHGUI* smeshMod = 0;
1991 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
1994 CAM_Module* module = app->module( "Mesh" );
1995 smeshMod = dynamic_cast<SMESHGUI*>( module );
1998 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2000 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2003 _PTR(Study) aStudy = study->studyDS();
2005 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2014 Standard_EXPORT SMESHGUI* GetComponentGUI()
2016 return SMESHGUI::GetSMESHGUI();
2020 //=============================================================================
2024 //=============================================================================
2025 void SMESHGUI::SetState(int aState)
2030 //=============================================================================
2034 //=============================================================================
2035 void SMESHGUI::ResetState()
2040 //=============================================================================
2044 //=============================================================================
2045 void SMESHGUI::EmitSignalDeactivateDialog()
2047 emit SignalDeactivateActiveDialog();
2050 //=============================================================================
2054 //=============================================================================
2055 void SMESHGUI::EmitSignalStudyFrameChanged()
2057 emit SignalStudyFrameChanged();
2060 //=============================================================================
2064 //=============================================================================
2065 void SMESHGUI::EmitSignalCloseAllDialogs()
2067 emit SignalCloseAllDialogs();
2070 //=============================================================================
2074 //=============================================================================
2075 void SMESHGUI::EmitSignalVisibilityChanged()
2077 emit SignalVisibilityChanged();
2080 //=============================================================================
2084 //=============================================================================
2085 QDialog *SMESHGUI::GetActiveDialogBox()
2087 return myActiveDialogBox;
2090 //=============================================================================
2094 //=============================================================================
2095 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2097 myActiveDialogBox = (QDialog *) aDlg;
2101 //=============================================================================
2105 //=============================================================================
2106 SUIT_Desktop* SMESHGUI::desktop()
2108 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2110 return app->desktop();
2115 //=============================================================================
2119 //=============================================================================
2120 SalomeApp_Study* SMESHGUI::activeStudy()
2122 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2124 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2129 //=============================================================================
2133 //=============================================================================
2134 void SMESHGUI::Modified( bool theIsUpdateActions )
2136 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2137 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2138 appStudy->Modified();
2139 if( theIsUpdateActions )
2140 app->updateActions();
2145 //=============================================================================
2149 //=============================================================================
2150 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2152 /* Here the position is on the bottom right corner - 10 */
2153 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2155 SUIT_Desktop *PP = desktop();
2156 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2157 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2161 //=============================================================================
2165 //=============================================================================
2166 static int isStudyLocked(_PTR(Study) theStudy){
2167 return theStudy->GetProperties()->IsLocked();
2170 static bool checkLock(_PTR(Study) theStudy) {
2171 if (isStudyLocked(theStudy)) {
2172 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2173 QObject::tr("WRN_WARNING"),
2174 QObject::tr("WRN_STUDY_LOCKED") );
2180 //=======================================================================
2181 //function : CheckActiveStudyLocked
2183 //=======================================================================
2185 bool SMESHGUI::isActiveStudyLocked()
2187 _PTR(Study) aStudy = activeStudy()->studyDS();
2188 return checkLock( aStudy );
2191 //=============================================================================
2195 //=============================================================================
2196 bool SMESHGUI::OnGUIEvent( int theCommandID )
2198 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2202 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2203 SUIT_ResourceMgr* mgr = resourceMgr();
2207 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2208 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2211 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2212 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2214 //QAction* act = action( theCommandID );
2216 switch (theCommandID) {
2218 if(checkLock(aStudy)) break;
2230 if(checkLock(aStudy)) break;
2231 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2235 case 150: //MED FILE INFORMATION
2237 SALOME_ListIO selected;
2238 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2240 aSel->selectedObjects( selected );
2241 if( selected.Extent() )
2243 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2244 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2245 if ( !aMesh->_is_nil() )
2247 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2254 case 122: // EXPORT MED
2269 ::ExportMeshToFile(theCommandID);
2273 case 200: // SCALAR BAR
2275 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2276 SALOME_ListIO selected;
2278 aSel->selectedObjects( selected );
2280 if( selected.Extent() ) {
2281 Handle(SALOME_InteractiveObject) anIO = selected.First();
2282 if( anIO->hasEntry() ) {
2283 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2284 anActor->SetControlMode( SMESH_Actor::eNone );
2285 #ifndef DISABLE_PLOT2DVIEWER
2286 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2295 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2300 // dump control distribution data to the text file
2301 ::SaveDistribution();
2307 // show/ distribution
2308 ::ShowDistribution();
2312 #ifndef DISABLE_PLOT2DVIEWER
2315 // plot distribution
2316 ::PlotDistribution();
2327 ::DisableAutoColor();
2330 case 1134: // Clipping
2331 case 1133: // Tranparency
2332 case 1132: // Display preferences (colors, shrink size, line width, ...)
2339 ::SetDisplayMode(theCommandID, myMarkerMap);
2342 //2D quadratic representation
2345 ::SetDisplayMode(theCommandID, myMarkerMap);
2349 case 216: // 0D elements
2352 case 219: // Volumes
2353 case 220: // All Entity
2355 ::SetDisplayEntity(theCommandID);
2358 case 221: // Orientation of faces
2360 LightApp_SelectionMgr* mgr = selectionMgr();
2361 SALOME_ListIO selected; mgr->selectedObjects( selected );
2363 SALOME_ListIteratorOfListIO it(selected);
2364 for( ; it.More(); it.Next()) {
2365 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2366 if(anIObject->hasEntry()) {
2367 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2368 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2377 if(checkLock(aStudy)) break;
2379 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2382 SMESH::UpdateView();
2384 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2385 SMESH::OnVisuException();
2387 catch (...) { // PAL16774 (Crash after display of many groups)
2388 SMESH::OnVisuException();
2392 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2393 aSel->selectedObjects( l );
2394 aSel->setSelectedObjects( l );
2399 case 301: // DISPLAY
2400 case 302: // DISPLAY ONLY
2402 SMESH::EDisplaing anAction;
2403 switch (theCommandID) {
2404 case 300: anAction = SMESH::eErase; break;
2405 case 301: anAction = SMESH::eDisplay; break;
2406 case 302: anAction = SMESH::eDisplayOnly; break;
2409 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2410 SALOME_ListIO sel_objects, to_process;
2412 aSel->selectedObjects( sel_objects );
2414 if( theCommandID==302 )
2416 MESSAGE("anAction = SMESH::eDisplayOnly");
2417 startOperation( myEraseAll );
2420 extractContainers( sel_objects, to_process );
2423 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2427 SALOME_ListIteratorOfListIO It( to_process );
2428 for ( ; It.More(); It.Next()) {
2430 Handle(SALOME_InteractiveObject) IOS = It.Value();
2431 if (IOS->hasEntry()) {
2433 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2434 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2435 break; // PAL16774 (Crash after display of many groups)
2437 if (anAction == SMESH::eDisplayOnly)
2439 MESSAGE("anAction = SMESH::eDisplayOnly");
2440 anAction = SMESH::eDisplay;
2446 // PAL13338 + PAL15161 -->
2447 if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2448 MESSAGE("anAction = SMESH::eDisplayOnly");
2449 SMESH::UpdateView();
2450 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2452 // PAL13338 + PAL15161 <--
2454 catch (...) { // PAL16774 (Crash after display of many groups)
2455 SMESH::OnVisuException();
2458 if (anAction == SMESH::eErase) {
2459 MESSAGE("anAction == SMESH::eErase");
2461 aSel->setSelectedObjects( l1 );
2464 aSel->setSelectedObjects( to_process );
2471 if(checkLock(aStudy)) break;
2474 EmitSignalDeactivateDialog();
2476 ( new SMESHGUI_NodesDlg( this ) )->show();
2479 SUIT_MessageBox::warning(desktop(),
2480 tr("SMESH_WRN_WARNING"),
2481 tr("SMESH_WRN_VIEWER_VTK"));
2486 case 2151: // FILTER
2490 EmitSignalDeactivateDialog();
2491 ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2496 case 701: // COMPUTE MESH
2497 case 711: // PRECOMPUTE MESH
2498 case 712: // EVALUATE MESH
2499 case 713: // MESH ORDER
2500 case 702: // Create mesh
2501 case 703: // Create sub-mesh
2502 case 704: // Edit mesh/sub-mesh
2503 startOperation( theCommandID );
2505 case 705: // copy mesh
2507 if (checkLock(aStudy)) break;
2508 EmitSignalDeactivateDialog();
2509 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2512 case 710: // Build compound mesh
2514 if (checkLock(aStudy)) break;
2515 EmitSignalDeactivateDialog();
2516 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2520 case 407: // DIAGONAL INVERSION
2521 case 408: // Delete diagonal
2525 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2526 tr( "NOT_A_VTK_VIEWER" ) );
2530 if ( checkLock( aStudy ) )
2533 /*Standard_Boolean aRes;
2534 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2535 if ( aMesh->_is_nil() )
2537 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2538 tr( "SMESH_BAD_SELECTION" ) );
2542 EmitSignalDeactivateDialog();
2543 if ( theCommandID == 407 )
2544 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2546 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2549 case 409: // Change orientation
2550 case 410: // Union of triangles
2551 case 411: // Cutting of quadrangles
2552 case 419: // Splitting volumes into tetrahedra
2556 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2557 tr( "NOT_A_VTK_VIEWER" ) );
2561 if ( checkLock( aStudy ) )
2564 EmitSignalDeactivateDialog();
2565 SMESHGUI_MultiEditDlg* aDlg = NULL;
2566 if ( theCommandID == 409 )
2567 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2568 else if ( theCommandID == 410 )
2569 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2570 else if ( theCommandID == 419 )
2571 aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2573 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2578 case 412: // Smoothing
2580 if(checkLock(aStudy)) break;
2582 EmitSignalDeactivateDialog();
2583 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2586 SUIT_MessageBox::warning(desktop(),
2587 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2591 case 413: // Extrusion
2593 if (checkLock(aStudy)) break;
2595 EmitSignalDeactivateDialog();
2596 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2598 SUIT_MessageBox::warning(desktop(),
2599 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2603 case 414: // Revolution
2605 if(checkLock(aStudy)) break;
2607 EmitSignalDeactivateDialog();
2608 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2611 SUIT_MessageBox::warning(desktop(),
2612 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2616 case 415: // Pattern mapping
2618 if ( checkLock( aStudy ) )
2622 EmitSignalDeactivateDialog();
2623 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2626 SUIT_MessageBox::warning(desktop(),
2627 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2631 case 416: // Extrusion along a path
2633 if (checkLock(aStudy)) break;
2635 EmitSignalDeactivateDialog();
2636 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2638 SUIT_MessageBox::warning(desktop(),
2639 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2643 case 417: // Convert mesh to quadratic
2644 case 418: // create 2D mesh from 3D
2645 case 420: // Reorient faces
2646 case 806: // CREATE GEO GROUP
2648 startOperation( theCommandID );
2651 case 801: // CREATE GROUP
2655 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2656 tr( "NOT_A_VTK_VIEWER" ) );
2660 if(checkLock(aStudy)) break;
2661 EmitSignalDeactivateDialog();
2662 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2664 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2665 SALOME_ListIO selected;
2667 aSel->selectedObjects( selected );
2669 int nbSel = selected.Extent();
2671 // check if mesh is selected
2672 aMesh = SMESH::GetMeshByIO( selected.First() );
2674 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2679 case 802: // CONSTRUCT GROUP
2683 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2684 tr( "NOT_A_VTK_VIEWER" ) );
2688 if(checkLock(aStudy)) break;
2689 EmitSignalDeactivateDialog();
2691 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2692 SALOME_ListIO selected;
2694 aSel->selectedObjects( selected );
2696 int nbSel = selected.Extent();
2698 // check if submesh is selected
2699 Handle(SALOME_InteractiveObject) IObject = selected.First();
2700 if (IObject->hasEntry()) {
2701 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2703 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2704 if (!aSubMesh->_is_nil()) {
2706 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2707 // get submesh elements list by types
2708 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2709 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2710 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2711 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2712 // create group for each type o elements
2713 QString aName = IObject->getName();
2714 QStringList anEntryList;
2715 if (aNodes->length() > 0) {
2716 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2717 aGroup->Add(aNodes.inout());
2718 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2719 anEntryList.append( aSObject->GetID().c_str() );
2721 if (aEdges->length() > 0) {
2722 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2723 aGroup->Add(aEdges.inout());
2724 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2725 anEntryList.append( aSObject->GetID().c_str() );
2727 if (aFaces->length() > 0) {
2728 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2729 aGroup->Add(aFaces.inout());
2730 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2731 anEntryList.append( aSObject->GetID().c_str() );
2733 if (aVolumes->length() > 0) {
2734 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2735 aGroup->Add(aVolumes.inout());
2736 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2737 anEntryList.append( aSObject->GetID().c_str() );
2740 anApp->browseObjects( anEntryList );
2742 catch(const SALOME::SALOME_Exception & S_ex){
2743 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2750 SUIT_MessageBox::warning(desktop(),
2751 tr("SMESH_WRN_WARNING"),
2752 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2757 case 803: // EDIT GROUP
2761 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2762 tr( "NOT_A_VTK_VIEWER" ) );
2766 if(checkLock(aStudy)) break;
2767 EmitSignalDeactivateDialog();
2769 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2770 SALOME_ListIO selected;
2772 aSel->selectedObjects( selected );
2774 SALOME_ListIteratorOfListIO It (selected);
2775 int nbSelectedGroups = 0;
2776 for ( ; It.More(); It.Next() )
2778 SMESH::SMESH_GroupBase_var aGroup =
2779 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2780 if (!aGroup->_is_nil()) {
2782 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2786 if (nbSelectedGroups == 0)
2788 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2794 case 804: // Add elements to group
2796 if(checkLock(aStudy)) break;
2797 if (myState == 800) {
2798 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2799 if (aDlg) aDlg->onAdd();
2804 case 805: // Remove elements from group
2806 if(checkLock(aStudy)) break;
2807 if (myState == 800) {
2808 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2809 if (aDlg) aDlg->onRemove();
2814 case 815: // Edit GEOM GROUP as standalone
2818 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2819 tr( "NOT_A_VTK_VIEWER" ) );
2823 if(checkLock(aStudy)) break;
2824 EmitSignalDeactivateDialog();
2826 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2827 SALOME_ListIO selected;
2829 aSel->selectedObjects( selected );
2831 SALOME_ListIteratorOfListIO It (selected);
2832 for ( ; It.More(); It.Next() )
2834 SMESH::SMESH_GroupOnGeom_var aGroup =
2835 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2836 if (!aGroup->_is_nil()) {
2837 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2842 SMESH::SMESH_GroupOnFilter_var aGroup =
2843 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2844 if (!aGroup->_is_nil()) {
2845 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2853 case 810: // Union Groups
2854 case 811: // Intersect groups
2855 case 812: // Cut groups
2859 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2860 tr( "NOT_A_VTK_VIEWER" ) );
2864 if ( checkLock( aStudy ) )
2867 EmitSignalDeactivateDialog();
2869 SMESHGUI_GroupOpDlg* aDlg = 0;
2870 if ( theCommandID == 810 )
2871 aDlg = new SMESHGUI_UnionGroupsDlg( this );
2872 else if ( theCommandID == 811 )
2873 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2875 aDlg = new SMESHGUI_CutGroupsDlg( this );
2882 case 814: // Create groups of entities from existing groups of superior dimensions
2884 if ( checkLock( aStudy ) )
2887 EmitSignalDeactivateDialog();
2888 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2894 case 813: // Delete groups with their contents
2898 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2899 tr( "NOT_A_VTK_VIEWER" ) );
2903 if ( checkLock( aStudy ) )
2906 EmitSignalDeactivateDialog();
2908 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2912 case 900: // MESH INFOS
2913 case 903: // WHAT IS
2915 int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2916 EmitSignalDeactivateDialog();
2917 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2918 SALOME_ListIO selected;
2920 aSel->selectedObjects( selected );
2922 if ( selected.Extent() > 1 ) { // a dlg for each IO
2923 SALOME_ListIteratorOfListIO It( selected );
2924 for ( ; It.More(); It.Next() ) {
2925 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2926 dlg->showInfo( It.Value() );
2931 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2937 case 904: // FIND ELEM
2939 startOperation( theCommandID );
2943 case 1100: // EDIT HYPOTHESIS
2945 if(checkLock(aStudy)) break;
2947 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2948 SALOME_ListIO selected;
2950 aSel->selectedObjects( selected );
2952 int nbSel = selected.Extent();
2955 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2956 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
2958 /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
2959 /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects */
2960 /* Warning : however by internal mechanism all subMeshes icons are changed ! */
2961 if ( !aHypothesis->_is_nil() )
2964 //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2965 SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2967 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
2977 case 1102: // REMOVE HYPOTHESIS / ALGORITHMS
2979 if(checkLock(aStudy)) break;
2980 SUIT_OverrideCursor wc;
2982 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2983 SALOME_ListIO selected;
2985 aSel->selectedObjects( selected, QString::null, false );
2987 SALOME_ListIteratorOfListIO It(selected);
2988 for (int i = 0; It.More(); It.Next(), i++) {
2989 Handle(SALOME_InteractiveObject) IObject = It.Value();
2990 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2993 aSel->setSelectedObjects( l1 );
2999 case 4009: // ELEM0D
3001 case 4021: // TRIANGLE
3003 case 4023: // POLYGON
3007 case 4134: // PYRAMID
3008 case 4135: // OCTA12
3010 if(checkLock(aStudy)) break;
3012 EmitSignalDeactivateDialog();
3013 SMDSAbs_EntityType type = SMDSEntity_Edge;
3014 switch (theCommandID) {
3015 case 4008: type = SMDSEntity_Ball; break;
3016 case 4009: type = SMDSEntity_0D; break;
3017 case 4021: type = SMDSEntity_Triangle; break;
3018 case 4022: type = SMDSEntity_Quadrangle; break;
3019 case 4031: type = SMDSEntity_Tetra; break;
3020 case 4023: type = SMDSEntity_Polygon; break;
3021 case 4032: type = SMDSEntity_Hexa; break;
3022 case 4133: type = SMDSEntity_Penta; break;
3023 case 4134: type = SMDSEntity_Pyramid; break;
3024 case 4135: type = SMDSEntity_Hexagonal_Prism; break;
3027 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3030 SUIT_MessageBox::warning(desktop(),
3031 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3035 case 4033: // POLYHEDRON
3037 if(checkLock(aStudy)) break;
3039 EmitSignalDeactivateDialog();
3040 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3043 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3044 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3048 case 4034: // QUADRATIC EDGE
3049 case 4035: // QUADRATIC TRIANGLE
3050 case 4036: // QUADRATIC QUADRANGLE
3051 case 4136: // BIQUADRATIC QUADRANGLE
3052 case 4037: // QUADRATIC TETRAHEDRON
3053 case 4038: // QUADRATIC PYRAMID
3054 case 4039: // QUADRATIC PENTAHEDRON
3055 case 4040: // QUADRATIC HEXAHEDRON
3056 case 4140: // TRIQUADRATIC HEXAHEDRON
3058 if(checkLock(aStudy)) break;
3060 EmitSignalDeactivateDialog();
3061 SMDSAbs_EntityType type = SMDSEntity_Last;
3063 switch (theCommandID) {
3065 type = SMDSEntity_Quad_Edge; break;
3067 type = SMDSEntity_Quad_Triangle; break;
3069 type = SMDSEntity_Quad_Quadrangle; break;
3071 type = SMDSEntity_BiQuad_Quadrangle; break;
3073 type = SMDSEntity_Quad_Tetra; break;
3075 type = SMDSEntity_Quad_Pyramid; break;
3077 type = SMDSEntity_Quad_Penta; break;
3079 type = SMDSEntity_Quad_Hexa; break;
3081 type = SMDSEntity_TriQuad_Hexa; break;
3084 if ( type != SMDSEntity_Last )
3085 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3088 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3089 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3093 case 4041: // REMOVES NODES
3095 if(checkLock(aStudy)) break;
3097 EmitSignalDeactivateDialog();
3098 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3101 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3102 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3106 case 4042: // REMOVES ELEMENTS
3108 if(checkLock(aStudy)) break;
3110 EmitSignalDeactivateDialog();
3111 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3115 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3116 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3120 case 4043: { // CLEAR_MESH
3122 if(checkLock(aStudy)) break;
3124 SALOME_ListIO selected;
3125 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3126 aSel->selectedObjects( selected );
3128 SUIT_OverrideCursor wc;
3129 SALOME_ListIteratorOfListIO It (selected);
3130 for ( ; It.More(); It.Next() )
3132 Handle(SALOME_InteractiveObject) IOS = It.Value();
3133 SMESH::SMESH_Mesh_var aMesh =
3134 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3135 if ( aMesh->_is_nil()) continue;
3137 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3139 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3140 SMESH::ModifiedMesh( aMeshSObj, false, true);
3141 // hide groups and submeshes
3142 _PTR(ChildIterator) anIter =
3143 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3144 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3146 _PTR(SObject) so = anIter->Value();
3147 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3150 catch (const SALOME::SALOME_Exception& S_ex){
3152 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3156 SMESH::UpdateView();
3160 case 4044: // REMOVE ORPHAN NODES
3162 if(checkLock(aStudy)) break;
3163 SALOME_ListIO selected;
3164 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3165 aSel->selectedObjects( selected );
3166 if ( selected.Extent() == 1 ) {
3167 Handle(SALOME_InteractiveObject) anIO = selected.First();
3168 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3169 if ( !aMesh->_is_nil() ) {
3170 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3171 tr( "SMESH_WARNING" ),
3172 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3173 SUIT_MessageBox::Yes |
3174 SUIT_MessageBox::No,
3175 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3178 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3179 int removed = aMeshEditor->RemoveOrphanNodes();
3180 SUIT_MessageBox::information(SMESHGUI::desktop(),
3181 tr("SMESH_INFORMATION"),
3182 tr("NB_NODES_REMOVED").arg(removed));
3183 if ( removed > 0 ) {
3184 SMESH::UpdateView();
3185 SMESHGUI::Modified();
3188 catch (const SALOME::SALOME_Exception& S_ex) {
3189 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3198 case 4051: // RENUMBERING NODES
3200 if(checkLock(aStudy)) break;
3202 EmitSignalDeactivateDialog();
3203 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3207 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3208 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3212 case 4052: // RENUMBERING ELEMENTS
3214 if(checkLock(aStudy)) break;
3216 EmitSignalDeactivateDialog();
3217 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3221 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3222 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3226 case 4061: // TRANSLATION
3228 if(checkLock(aStudy)) break;
3230 EmitSignalDeactivateDialog();
3231 ( new SMESHGUI_TranslationDlg( this ) )->show();
3234 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3235 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3239 case 4062: // ROTATION
3241 if(checkLock(aStudy)) break;
3243 EmitSignalDeactivateDialog();
3244 ( new SMESHGUI_RotationDlg( this ) )->show();
3247 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3248 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3252 case 4063: // SYMMETRY
3254 if(checkLock(aStudy)) break;
3256 EmitSignalDeactivateDialog();
3257 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3260 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3261 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3265 case 4064: // SEWING
3267 if(checkLock(aStudy)) break;
3269 EmitSignalDeactivateDialog();
3270 ( new SMESHGUI_SewingDlg( this ) )->show();
3273 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3274 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3278 case 4065: // MERGE NODES
3280 if(checkLock(aStudy)) break;
3282 EmitSignalDeactivateDialog();
3283 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3286 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3287 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3291 case 4066: // MERGE EQUAL ELEMENTS
3293 if (checkLock(aStudy)) break;
3295 EmitSignalDeactivateDialog();
3296 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3298 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3299 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3304 case 4067: // MAKE MESH PASS THROUGH POINT
3305 startOperation( 4067 );
3310 if(checkLock(aStudy)) break;
3312 EmitSignalDeactivateDialog();
3313 ( new SMESHGUI_ScaleDlg( this ) )->show();
3316 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3317 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3322 case 4069: // DUPLICATE NODES
3324 if(checkLock(aStudy)) break;
3326 EmitSignalDeactivateDialog();
3327 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3330 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3331 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3336 case 4070: // 0D_ON_ALL_NODES
3337 startOperation( 4070 );
3340 case 5105: // Library of selection filters
3342 static QList<int> aTypes;
3343 if ( aTypes.isEmpty() )
3345 aTypes.append( SMESH::NODE );
3346 aTypes.append( SMESH::EDGE );
3347 aTypes.append( SMESH::FACE );
3348 aTypes.append( SMESH::VOLUME );
3350 if (!myFilterLibraryDlg)
3351 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3352 else if (myFilterLibraryDlg->isHidden())
3353 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3354 myFilterLibraryDlg->raise();
3358 case 6017: // CONTROLS
3386 LightApp_SelectionMgr* mgr = selectionMgr();
3387 SALOME_ListIO selected; mgr->selectedObjects( selected );
3389 if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3390 _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3392 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3393 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
3394 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3395 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
3396 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3397 ::Control( theCommandID );
3402 SUIT_MessageBox::warning(desktop(),
3403 tr( "SMESH_WRN_WARNING" ),
3404 tr( "SMESH_BAD_SELECTION" ) );
3408 SUIT_MessageBox::warning(desktop(),
3409 tr( "SMESH_WRN_WARNING" ),
3410 tr( "NOT_A_VTK_VIEWER" ) );
3415 LightApp_SelectionMgr* mgr = selectionMgr();
3416 SALOME_ListIO selected; mgr->selectedObjects( selected );
3418 SALOME_ListIteratorOfListIO it(selected);
3419 for( ; it.More(); it.Next()) {
3420 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3421 if(anIObject->hasEntry()) {
3422 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3423 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3431 LightApp_SelectionMgr* mgr = selectionMgr();
3432 SALOME_ListIO selected; mgr->selectedObjects( selected );
3434 SALOME_ListIteratorOfListIO it(selected);
3435 for( ; it.More(); it.Next()) {
3436 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3437 if(anIObject->hasEntry())
3438 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3439 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3447 int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3448 EmitSignalDeactivateDialog();
3449 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3455 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3456 //updateObjBrowser();
3460 //=============================================================================
3464 //=============================================================================
3465 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3470 //=============================================================================
3474 //=============================================================================
3475 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3480 //=============================================================================
3484 //=============================================================================
3485 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3490 //=============================================================================
3491 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3492 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3494 //=============================================================================
3495 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3496 SUIT_ViewWindow* wnd )
3498 if(theIO->hasEntry()){
3499 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3500 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3504 //=======================================================================
3505 // function : createSMESHAction
3507 //=======================================================================
3508 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3509 const int key, const bool toggle, const QString& shortcutAction )
3512 QWidget* parent = application()->desktop();
3513 SUIT_ResourceMgr* resMgr = resourceMgr();
3515 if ( !icon_id.isEmpty() )
3516 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3518 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3519 if ( !pix.isNull() )
3520 icon = QIcon( pix );
3522 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3523 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3524 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3526 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3527 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3530 //=======================================================================
3531 // function : createPopupItem
3533 //=======================================================================
3534 void SMESHGUI::createPopupItem( const int id,
3535 const QString& clients,
3536 const QString& types,
3537 const QString& theRule,
3540 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3541 popupMgr()->insert( action( id ), pId, 0 );
3543 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3544 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3545 QString rule = "(%1) and (%2) and (%3)";
3546 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3547 if( clients.isEmpty() )
3548 rule = rule.arg( QString( "true" ) );
3550 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3551 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3554 bool cont = myRules.contains( id );
3556 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3558 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3559 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3562 //=======================================================================
3563 // function : initialize
3565 //=======================================================================
3566 void SMESHGUI::initialize( CAM_Application* app )
3568 SalomeApp_Module::initialize( app );
3570 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3572 /* Automatic Update flag */
3573 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3575 // ----- create actions --------------
3577 //createSMESHAction( 111, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3578 createSMESHAction( 112, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3579 createSMESHAction( 113, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3580 createSMESHAction( 114, "NUM" );
3581 createSMESHAction( 115, "IMPORT_STL" );
3582 createSMESHAction( 116, "IMPORT_CGNS" );
3583 createSMESHAction( 117, "IMPORT_SAUV" );
3584 createSMESHAction( 118, "IMPORT_GMF" );
3585 createSMESHAction( 121, "DAT" );
3586 createSMESHAction( 122, "MED" );
3587 createSMESHAction( 123, "UNV" );
3588 createSMESHAction( 140, "STL" );
3589 createSMESHAction( 142, "CGNS");
3590 createSMESHAction( 144, "SAUV");
3591 createSMESHAction( 146, "GMF" );
3592 createSMESHAction( 124, "DAT" );
3593 createSMESHAction( 125, "MED" );
3594 createSMESHAction( 126, "UNV" );
3595 createSMESHAction( 141, "STL" );
3596 createSMESHAction( 143, "CGNS");
3597 createSMESHAction( 145, "SAUV");
3598 createSMESHAction( 147, "GMF" );
3599 createSMESHAction( 150, "FILE_INFO" );
3600 createSMESHAction( 33, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3601 createSMESHAction( 5105, "SEL_FILTER_LIB" );
3602 createSMESHAction( 701, "COMPUTE", "ICON_COMPUTE" );
3603 createSMESHAction( 702, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3604 createSMESHAction( 703, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3605 createSMESHAction( 704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3606 createSMESHAction( 705, "COPY_MESH", "ICON_COPY_MESH" );
3607 createSMESHAction( 710, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3608 createSMESHAction( 711, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3609 createSMESHAction( 712, "EVALUATE", "ICON_COMPUTE" );
3610 createSMESHAction( 713, "MESH_ORDER", "ICON_COMPUTE" );
3611 createSMESHAction( 806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3612 createSMESHAction( 801, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3613 createSMESHAction( 802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3614 createSMESHAction( 803, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3615 createSMESHAction( 815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3616 createSMESHAction( 804, "ADD" );
3617 createSMESHAction( 805, "REMOVE" );
3618 createSMESHAction( 810, "UN_GROUP", "ICON_UNION" );
3619 createSMESHAction( 811, "INT_GROUP", "ICON_INTERSECT" );
3620 createSMESHAction( 812, "CUT_GROUP", "ICON_CUT" );
3621 createSMESHAction( 814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3622 createSMESHAction( 813, "DEL_GROUP", "ICON_DEL_GROUP" );
3623 createSMESHAction( 900, "ADV_INFO", "ICON_ADV_INFO" );
3624 //createSMESHAction( 902, "STD_INFO", "ICON_STD_INFO" );
3625 //createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3626 createSMESHAction( 904, "FIND_ELEM", "ICON_FIND_ELEM" );
3627 createSMESHAction( 6001, "LENGTH", "ICON_LENGTH", 0, true );
3628 createSMESHAction( 6002, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3629 createSMESHAction( 6021, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3630 createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3631 createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3632 createSMESHAction( 6024, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3633 createSMESHAction( 6025, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3634 createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3635 createSMESHAction( 6027, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3636 createSMESHAction( 6028, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3637 createSMESHAction( 6029, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3638 createSMESHAction( 6030, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3639 createSMESHAction( 6031, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3640 createSMESHAction( 6003, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3641 createSMESHAction( 6004, "CONNECTION", "ICON_CONNECTION", 0, true );
3642 createSMESHAction( 6005, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3643 createSMESHAction( 6011, "AREA", "ICON_AREA", 0, true );
3644 createSMESHAction( 6012, "TAPER", "ICON_TAPER", 0, true );
3645 createSMESHAction( 6013, "ASPECT", "ICON_ASPECT", 0, true );
3646 createSMESHAction( 6014, "MIN_ANG", "ICON_ANGLE", 0, true );
3647 createSMESHAction( 6015, "WARP", "ICON_WARP", 0, true );
3648 createSMESHAction( 6016, "SKEW", "ICON_SKEW", 0, true );
3649 createSMESHAction( 6017, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3650 createSMESHAction( 6018, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3651 createSMESHAction( 6019, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3652 createSMESHAction( 6009, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3653 createSMESHAction( 4000, "NODE", "ICON_DLG_NODE" );
3654 createSMESHAction( 4009, "ELEM0D", "ICON_DLG_ELEM0D" );
3655 createSMESHAction( 4008, "BALL", "ICON_DLG_BALL" );
3656 createSMESHAction( 4010, "EDGE", "ICON_DLG_EDGE" );
3657 createSMESHAction( 4021, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3658 createSMESHAction( 4022, "QUAD", "ICON_DLG_QUADRANGLE" );
3659 createSMESHAction( 4023, "POLYGON", "ICON_DLG_POLYGON" );
3660 createSMESHAction( 4031, "TETRA", "ICON_DLG_TETRAS" );
3661 createSMESHAction( 4032, "HEXA", "ICON_DLG_HEXAS" );
3662 createSMESHAction( 4133, "PENTA", "ICON_DLG_PENTA" );
3663 createSMESHAction( 4134, "PYRAMID", "ICON_DLG_PYRAMID" );
3664 createSMESHAction( 4135, "OCTA", "ICON_DLG_OCTA" );
3665 createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3666 createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3667 createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3668 createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3669 createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3670 createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3671 createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3672 createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3673 createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3674 createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3675 createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3676 createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3677 createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3678 createSMESHAction( 4043, "CLEAR_MESH" , "ICON_CLEAR_MESH" );
3679 createSMESHAction( 4051, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3680 createSMESHAction( 4052, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3681 createSMESHAction( 4061, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3682 createSMESHAction( 4062, "ROT", "ICON_DLG_MESH_ROTATION" );
3683 createSMESHAction( 4063, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3684 createSMESHAction( 4064, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3685 createSMESHAction( 4065, "MERGE", "ICON_SMESH_MERGE_NODES" );
3686 createSMESHAction( 4066, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3687 createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3688 createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" );
3689 createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3690 createSMESHAction( 4070, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3691 createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" );
3692 createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" );
3693 createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3694 createSMESHAction( 410, "UNION", "ICON_UNIONTRI" );
3695 createSMESHAction( 411, "CUT", "ICON_CUTQUAD" );
3696 createSMESHAction( 412, "SMOOTH", "ICON_DLG_SMOOTHING" );
3697 createSMESHAction( 413, "EXTRUSION", "ICON_EXTRUSION" );
3698 createSMESHAction( 414, "REVOLUTION", "ICON_REVOLUTION" );
3699 createSMESHAction( 415, "MAP", "ICON_MAP" );
3700 createSMESHAction( 416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3701 createSMESHAction( 417, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3702 createSMESHAction( 418, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3703 createSMESHAction( 419, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3704 createSMESHAction( 420, "REORIENT_2D", "ICON_REORIENT_2D" );
3705 createSMESHAction( 200, "RESET" );
3706 createSMESHAction( 201, "SCALAR_BAR_PROP" );
3707 createSMESHAction( 2021, "SAVE_DISTRIBUTION" );
3708 createSMESHAction( 2022, "SHOW_DISTRIBUTION","",0, true );
3709 #ifndef DISABLE_PLOT2DVIEWER
3710 createSMESHAction( 2023, "PLOT_DISTRIBUTION" );
3712 createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true );
3713 createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true );
3714 createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true );
3715 createSMESHAction( 214, "UPDATE", "ICON_UPDATE" );
3716 createSMESHAction( 215, "NODES", "ICON_POINTS", 0, true );
3717 createSMESHAction( 222, "BALLS", "ICON_DLG_BALL", 0, true );
3718 createSMESHAction( 216, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3719 createSMESHAction( 217, "EDGES", "ICON_DLG_EDGE", 0, true );
3720 createSMESHAction( 218, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3721 createSMESHAction( 219, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3722 createSMESHAction( 220, "ALL" );
3723 createSMESHAction( 221, "FACE_ORIENTATION", "", 0, true );
3725 createSMESHAction( 231, "LINE_REPRESENTATION", "", 0, true );
3726 createSMESHAction( 232, "ARC_REPRESENTATION", "", 0, true );
3728 createSMESHAction( 1100, "EDIT_HYPO" );
3729 createSMESHAction( 1102, "UNASSIGN" );
3730 createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3731 createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3732 createSMESHAction( 1131, "DISPMODE" );
3733 createSMESHAction( 1132, "COLORS" );
3734 createSMESHAction( 1133, "TRANSP" );
3735 createSMESHAction( 1134, "CLIP" );
3736 createSMESHAction( 1135, "DISP_ENT" );
3737 createSMESHAction( 1136, "AUTO_COLOR" );
3738 createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3739 createSMESHAction( 2000, "CTRL" );
3741 createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3742 createSMESHAction( 502, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3744 createSMESHAction( 300, "HIDE" );
3745 createSMESHAction( 301, "SHOW" );
3746 createSMESHAction( 302, "DISPLAY_ONLY" );
3748 // ----- create menu --------------
3749 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3750 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3751 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3752 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3753 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3754 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3755 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3756 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3758 createMenu( separator(), fileId );
3760 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3761 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3762 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3763 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3764 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3765 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3766 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3767 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3768 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3769 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3771 //createMenu( 111, importId, -1 );
3772 createMenu( 112, importId, -1 );
3773 createMenu( 113, importId, -1 );
3774 createMenu( 115, importId, -1 );
3776 createMenu( 116, importId, -1 );
3778 createMenu( 117, importId, -1 );
3779 createMenu( 118, importId, -1 );
3780 createMenu( 121, exportId, -1 );
3781 createMenu( 122, exportId, -1 );
3782 createMenu( 123, exportId, -1 );
3783 createMenu( 140, exportId, -1 ); // export to STL
3785 createMenu( 142, exportId, -1 ); // export to CGNS
3787 createMenu( 144, exportId, -1 ); // export to SAUV
3788 createMenu( 146, exportId, -1 ); // export to GMF
3789 createMenu( separator(), fileId, 10 );
3791 createMenu( 33, editId, -1 );
3793 createMenu( 5105, toolsId, -1 );
3795 createMenu( 702, meshId, -1 ); // "Mesh" menu
3796 createMenu( 703, meshId, -1 );
3797 createMenu( 704, meshId, -1 );
3798 createMenu( 710, meshId, -1 );
3799 createMenu( 705, meshId, -1 );
3800 createMenu( separator(), meshId, -1 );
3801 createMenu( 701, meshId, -1 );
3802 createMenu( 711, meshId, -1 );
3803 createMenu( 712, meshId, -1 );
3804 createMenu( 713, meshId, -1 );
3805 createMenu( separator(), meshId, -1 );
3806 createMenu( 801, meshId, -1 );
3807 createMenu( 806, meshId, -1 );
3808 createMenu( 802, meshId, -1 );
3809 createMenu( 803, meshId, -1 );
3810 createMenu( 815, meshId, -1 );
3811 createMenu( separator(), meshId, -1 );
3812 createMenu( 810, meshId, -1 );
3813 createMenu( 811, meshId, -1 );
3814 createMenu( 812, meshId, -1 );
3815 createMenu( separator(), meshId, -1 );
3816 createMenu( 814, meshId, -1 );
3817 createMenu( separator(), meshId, -1 );
3818 createMenu( 900, meshId, -1 );
3819 //createMenu( 902, meshId, -1 );
3820 //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3821 createMenu( 904, meshId, -1 );
3822 createMenu( separator(), meshId, -1 );
3824 createMenu( 6005, nodeId, -1 );
3825 createMenu( 6028, nodeId, -1 );
3826 createMenu( 6002, edgeId, -1 );
3827 createMenu( 6003, edgeId, -1 );
3828 createMenu( 6001, edgeId, -1 );
3829 createMenu( 6004, edgeId, -1 );
3830 createMenu( 6029, edgeId, -1 );
3831 createMenu( 6021, faceId, -1 );
3832 createMenu( 6025, faceId, -1 );
3833 createMenu( 6027, faceId, -1 );
3834 createMenu( 6018, faceId, -1 );
3835 createMenu( 6019, faceId, -1 );
3836 createMenu( 6011, faceId, -1 );
3837 createMenu( 6012, faceId, -1 );
3838 createMenu( 6013, faceId, -1 );
3839 createMenu( 6014, faceId, -1 );
3840 createMenu( 6015, faceId, -1 );
3841 createMenu( 6016, faceId, -1 );
3842 createMenu( 6022, faceId, -1 );
3843 createMenu( 6030, faceId, -1 );
3844 createMenu( 6017, volumeId, -1 );
3845 createMenu( 6009, volumeId, -1 );
3846 createMenu( 6023, volumeId, -1 );
3847 createMenu( 6024, volumeId, -1 );
3848 createMenu( 6026, volumeId, -1 );
3849 createMenu( 6031, volumeId, -1 );
3851 createMenu( 4000, addId, -1 );
3852 createMenu( 4009, addId, -1 );
3853 createMenu( 4070, addId, -1 );
3854 createMenu( 4008, addId, -1 );
3855 createMenu( 4010, addId, -1 );
3856 createMenu( 4021, addId, -1 );
3857 createMenu( 4022, addId, -1 );
3858 createMenu( 4023, addId, -1 );
3859 createMenu( 4031, addId, -1 );
3860 createMenu( 4032, addId, -1 );
3861 createMenu( 4133, addId, -1 );
3862 createMenu( 4134, addId, -1 );
3863 createMenu( 4135, addId, -1 );
3864 createMenu( 4033, addId, -1 );
3865 createMenu( separator(), addId, -1 );
3866 createMenu( 4034, addId, -1 );
3867 createMenu( 4035, addId, -1 );
3868 createMenu( 4036, addId, -1 );
3869 createMenu( 4136, addId, -1 );
3870 createMenu( 4037, addId, -1 );
3871 createMenu( 4038, addId, -1 );
3872 createMenu( 4039, addId, -1 );
3873 createMenu( 4040, addId, -1 );
3874 createMenu( 4140, addId, -1 );
3876 createMenu( 4041, removeId, -1 );
3877 createMenu( 4042, removeId, -1 );
3878 createMenu( 4044, removeId, -1 );
3879 createMenu( separator(), removeId, -1 );
3880 createMenu( 813, removeId, -1 );
3881 createMenu( separator(), removeId, -1 );
3882 createMenu( 4043, removeId, -1 );
3884 createMenu( 4051, renumId, -1 );
3885 createMenu( 4052, renumId, -1 );
3887 createMenu( 4061, transfId, -1 );
3888 createMenu( 4062, transfId, -1 );
3889 createMenu( 4063, transfId, -1 );
3890 createMenu( 4068, transfId, -1 );
3891 createMenu( 4064, transfId, -1 );
3892 createMenu( 4065, transfId, -1 );
3893 createMenu( 4066, transfId, -1 );
3894 createMenu( 4069, transfId, -1 );
3896 createMenu( 4067,modifyId, -1 );
3897 createMenu( 407, modifyId, -1 );
3898 createMenu( 408, modifyId, -1 );
3899 createMenu( 409, modifyId, -1 );
3900 createMenu( 420, modifyId, -1 );
3901 createMenu( 410, modifyId, -1 );
3902 createMenu( 411, modifyId, -1 );
3903 createMenu( 419, modifyId, -1 );
3904 createMenu( 412, modifyId, -1 );
3905 createMenu( 413, modifyId, -1 );
3906 createMenu( 416, modifyId, -1 );
3907 createMenu( 414, modifyId, -1 );
3908 createMenu( 415, modifyId, -1 );
3909 createMenu( 417, modifyId, -1 );
3910 createMenu( 418, modifyId, -1 );
3912 createMenu( 501, measureId, -1 );
3913 createMenu( 502, measureId, -1 );
3914 createMenu( 214, viewId, -1 );
3916 // ----- create toolbars --------------
3917 int meshTb = createTool( tr( "TB_MESH" ) ),
3918 ctrlTb = createTool( tr( "TB_CTRL" ) ),
3919 addRemTb = createTool( tr( "TB_ADD_REMOVE" ) ),
3920 modifyTb = createTool( tr( "TB_MODIFY" ) ),
3921 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
3923 createTool( 702, meshTb );
3924 createTool( 703, meshTb );
3925 createTool( 704, meshTb );
3926 createTool( 710, meshTb );
3927 createTool( 705, meshTb );
3928 createTool( separator(), meshTb );
3929 createTool( 701, meshTb );
3930 createTool( 711, meshTb );
3931 createTool( 712, meshTb );
3932 createTool( 713, meshTb );
3933 createTool( separator(), meshTb );
3934 createTool( 801, meshTb );
3935 createTool( 806, meshTb );
3936 createTool( 802, meshTb );
3937 createTool( 803, meshTb );
3938 //createTool( 815, meshTb );
3939 createTool( separator(), meshTb );
3940 createTool( 900, meshTb );
3941 //createTool( 902, meshTb );
3942 //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3943 createTool( 904, meshTb );
3944 createTool( separator(), meshTb );
3946 createTool( 6005, ctrlTb );
3947 createTool( 6028, ctrlTb );
3948 createTool( separator(), ctrlTb );
3949 createTool( 6002, ctrlTb );
3950 createTool( 6003, ctrlTb );
3951 createTool( 6001, ctrlTb );
3952 createTool( 6004, ctrlTb );
3953 createTool( 6029, ctrlTb );
3954 createTool( separator(), ctrlTb );
3955 createTool( 6021, ctrlTb );
3956 createTool( 6025, ctrlTb );
3957 createTool( 6027, ctrlTb );
3958 createTool( 6018, ctrlTb );
3959 createTool( 6019, ctrlTb );
3960 createTool( 6011, ctrlTb );
3961 createTool( 6012, ctrlTb );
3962 createTool( 6013, ctrlTb );
3963 createTool( 6014, ctrlTb );
3964 createTool( 6015, ctrlTb );
3965 createTool( 6016, ctrlTb );
3966 createTool( 6022, ctrlTb );
3967 createTool( 6030, ctrlTb );
3968 createTool( separator(), ctrlTb );
3969 createTool( 6017, ctrlTb );
3970 createTool( 6009, ctrlTb );
3971 createTool( 6023, ctrlTb );
3972 createTool( 6024, ctrlTb );
3973 createTool( 6026, ctrlTb );
3974 createTool( 6031, ctrlTb );
3975 createTool( separator(), ctrlTb );
3977 createTool( 4000, addRemTb );
3978 createTool( 4009, addRemTb );
3979 createTool( 4070, addRemTb );
3980 createTool( 4008, addRemTb );
3981 createTool( 4010, addRemTb );
3982 createTool( 4021, addRemTb );
3983 createTool( 4022, addRemTb );
3984 createTool( 4023, addRemTb );
3985 createTool( 4031, addRemTb );
3986 createTool( 4032, addRemTb );
3987 createTool( 4133, addRemTb );
3988 createTool( 4134, addRemTb );
3989 createTool( 4135, addRemTb );
3990 createTool( 4033, addRemTb );
3991 createTool( separator(), addRemTb );
3992 createTool( 4034, addRemTb );
3993 createTool( 4035, addRemTb );
3994 createTool( 4036, addRemTb );
3995 createTool( 4136, addRemTb );
3996 createTool( 4037, addRemTb );
3997 createTool( 4038, addRemTb );
3998 createTool( 4039, addRemTb );
3999 createTool( 4040, addRemTb );
4000 createTool( 4140, addRemTb );
4001 createTool( separator(), addRemTb );
4002 createTool( 4041, addRemTb );
4003 createTool( 4042, addRemTb );
4004 createTool( 4044, addRemTb );
4005 createTool( 4043, addRemTb );
4006 createTool( separator(), addRemTb );
4007 createTool( 4051, addRemTb );
4008 createTool( 4052, addRemTb );
4009 createTool( separator(), addRemTb );
4010 createTool( 4061, addRemTb );
4011 createTool( 4062, addRemTb );
4012 createTool( 4063, addRemTb );
4013 createTool( 4068, addRemTb );
4014 createTool( 4064, addRemTb );
4015 createTool( 4065, addRemTb );
4016 createTool( 4066, addRemTb );
4017 createTool( 4069, addRemTb );
4018 createTool( separator(), addRemTb );
4020 createTool( 4067,modifyTb );
4021 createTool( 407, modifyTb );
4022 createTool( 408, modifyTb );
4023 createTool( 409, modifyTb );
4024 createTool( 420, modifyTb );
4025 createTool( 410, modifyTb );
4026 createTool( 411, modifyTb );
4027 createTool( 419, modifyTb );
4028 createTool( 412, modifyTb );
4029 createTool( 413, modifyTb );
4030 createTool( 416, modifyTb );
4031 createTool( 414, modifyTb );
4032 createTool( 415, modifyTb );
4033 createTool( 417, modifyTb );
4034 createTool( 418, modifyTb );
4036 createTool( 214, dispModeTb );
4038 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4039 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4042 QString OB = "'ObjectBrowser'",
4043 View = "'" + SVTK_Viewer::Type() + "'",
4045 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4046 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4047 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4048 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4049 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4050 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4051 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4052 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4053 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4054 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4055 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4057 mesh_part = mesh + " " + subMesh + " " + group,
4058 mesh_group = mesh + " " + group,
4059 hyp_alg = hypo + " " + algo;
4061 // popup for object browser
4063 isInvisible("not( isVisible )"),
4064 isEmpty("numberOfNodes = 0"),
4065 isNotEmpty("numberOfNodes <> 0"),
4067 // has nodes, edges, etc in VISIBLE! actor
4068 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4069 hasElems("(count( elemTypes ) > 0)"),
4070 hasDifferentElems("(count( elemTypes ) > 1)"),
4071 hasBalls("({'BallElem'} in elemTypes)"),
4072 hasElems0d("({'Elem0d'} in elemTypes)"),
4073 hasEdges("({'Edge'} in elemTypes)"),
4074 hasFaces("({'Face'} in elemTypes)"),
4075 hasVolumes("({'Volume'} in elemTypes)");
4077 createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
4078 createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
4079 createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
4080 createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
4081 createPopupItem( 803, OB, group ); // EDIT_GROUP
4082 createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
4084 popupMgr()->insert( separator(), -1, 0 );
4085 createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
4086 createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
4087 createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
4088 createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
4089 createPopupItem( 214, OB, mesh_part ); // UPDATE
4090 createPopupItem( 900, OB, mesh_part ); // ADV_INFO
4091 createPopupItem( 904, OB, mesh_group ); // FIND_ELEM
4092 popupMgr()->insert( separator(), -1, 0 );
4093 createPopupItem( 801, OB, mesh ); // CREATE_GROUP
4094 createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
4095 createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
4096 popupMgr()->insert( separator(), -1, 0 );
4097 createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
4098 createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4099 popupMgr()->insert( separator(), -1, 0 );
4100 createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
4101 popupMgr()->insert( separator(), -1, 0 );
4102 createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
4103 createPopupItem( 418, OB, mesh + " " + group, // create 2D mesh from 3D
4105 popupMgr()->insert( separator(), -1, 0 );
4107 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4108 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4109 QString only_one_2D = only_one_non_empty + " && dim>1";
4111 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4112 createPopupItem( 125, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_MED
4113 createPopupItem( 126, OB, mesh_group, only_one_non_empty, anId ); // EXPORT_UNV
4114 createPopupItem( 141, OB, mesh_group, only_one_2D, anId ); // EXPORT_STL
4116 createPopupItem( 143, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_CGNS
4118 createPopupItem( 145, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_SAUV
4119 createPopupItem( 147, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_GMF
4120 createPopupItem( 124, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_DAT
4121 createPopupItem( 33, OB, mesh_part + " " + hyp_alg ); // DELETE
4122 createPopupItem( 813, OB, group ); // DEL_GROUP with contents
4123 popupMgr()->insert( separator(), -1, 0 );
4126 createPopupItem( 803, View, group ); // EDIT_GROUP
4127 createPopupItem( 804, View, elems ); // ADD
4128 createPopupItem( 805, View, elems ); // REMOVE
4130 popupMgr()->insert( separator(), -1, 0 );
4131 createPopupItem( 214, View, mesh_part ); // UPDATE
4132 createPopupItem( 900, View, mesh_part ); // ADV_INFO
4133 createPopupItem( 904, View, mesh ); // FIND_ELEM
4134 popupMgr()->insert( separator(), -1, 0 );
4136 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
4137 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
4138 popupMgr()->insert( separator(), -1, 0 );
4140 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4141 QString aType = QString( "%1type in {%2}" ).arg( lc );
4142 aType = aType.arg( mesh_part );
4143 QString aMeshInVTK = aClient + "&&" + aType;
4145 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4146 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4147 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4149 //-------------------------------------------------
4151 //-------------------------------------------------
4152 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4154 popupMgr()->insert( action( 9010 ), anId, -1 );
4155 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4156 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4158 popupMgr()->insert( action( 9011 ), anId, -1 );
4159 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4160 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4162 popupMgr()->insert( separator(), -1, -1 );
4164 //-------------------------------------------------
4166 //-------------------------------------------------
4167 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4169 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4170 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4171 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4173 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4174 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4175 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4177 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4178 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4179 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4181 popupMgr()->insert( separator(), anId, -1 );
4183 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4184 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4185 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4187 //-------------------------------------------------
4189 //-------------------------------------------------
4190 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4192 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4194 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4195 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4196 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4198 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4199 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4200 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4202 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4203 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4204 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4206 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4207 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4208 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4210 popupMgr()->insert( action( 222 ), anId, -1 ); // BALLS
4211 popupMgr()->setRule( action( 222 ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4212 popupMgr()->setRule( action( 222 ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4214 popupMgr()->insert( separator(), anId, -1 );
4216 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4217 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4220 //-------------------------------------------------
4221 // Representation of the 2D Quadratic elements
4222 //-------------------------------------------------
4223 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4224 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4225 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4226 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4228 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4229 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4230 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4232 //-------------------------------------------------
4233 // Orientation of faces
4234 //-------------------------------------------------
4235 popupMgr()->insert( action( 221 ), -1, -1 );
4236 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4237 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4239 //-------------------------------------------------
4241 //-------------------------------------------------
4242 popupMgr()->insert( action( 1132 ), -1, -1 );
4243 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4245 //-------------------------------------------------
4247 //-------------------------------------------------
4248 popupMgr()->insert( action( 1133 ), -1, -1 );
4249 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4251 //-------------------------------------------------
4253 //-------------------------------------------------
4255 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4256 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4257 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4258 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4260 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4262 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4263 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4265 popupMgr()->insert( separator(), anId, -1 );
4267 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4269 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4270 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4271 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4273 popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4274 popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4275 popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4277 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4279 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4280 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4281 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4283 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4284 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4285 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4287 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4288 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4289 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4291 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4292 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4293 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4294 popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4295 popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4296 popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4298 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4300 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4301 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4302 QtxPopupMgr::VisibleRule );
4303 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4305 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4306 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4307 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4309 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4310 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4311 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4313 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4314 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4315 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4317 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4318 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4319 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4321 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4322 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4323 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4325 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4326 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4327 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4329 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4330 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4331 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4333 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4334 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4335 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4337 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4338 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4339 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4341 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4342 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4343 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4345 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4346 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4347 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4348 popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4349 popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4350 popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4352 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4354 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4355 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4356 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4358 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4359 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4360 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4362 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4363 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4364 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4366 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4367 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4368 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4370 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4371 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4372 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4374 popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4375 popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4376 popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4378 popupMgr()->insert( separator(), anId, -1 );
4380 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4381 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4383 popupMgr()->insert( separator(), anId, -1 );
4385 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4387 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4388 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4390 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4391 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4392 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4394 #ifndef DISABLE_PLOT2DVIEWER
4395 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4396 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4399 //-------------------------------------------------
4401 //-------------------------------------------------
4402 popupMgr()->insert( separator(), -1, -1 );
4403 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4404 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4405 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4406 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4408 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4409 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4411 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4412 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4414 popupMgr()->insert( separator(), -1, -1 );
4416 //-------------------------------------------------
4418 //-------------------------------------------------
4419 popupMgr()->insert( action( 1134 ), -1, -1 );
4420 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4422 popupMgr()->insert( separator(), -1, -1 );
4424 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4425 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4427 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4428 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4431 //================================================================================
4433 * \brief Return true if SMESH or GEOM objects are selected.
4434 * Is called form LightApp_Module::activateModule() which clear selection if
4435 * not isSelectionCompatible()
4437 //================================================================================
4439 bool SMESHGUI::isSelectionCompatible()
4441 bool isCompatible = true;
4442 SALOME_ListIO selected;
4443 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4444 Sel->selectedObjects( selected );
4446 SALOME_ListIteratorOfListIO It( selected );
4447 for ( ; isCompatible && It.More(); It.Next())
4449 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4450 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4452 return isCompatible;
4456 bool SMESHGUI::reusableOperation( const int id )
4458 // compute, evaluate and precompute are not reusable operations
4459 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4462 bool SMESHGUI::activateModule( SUIT_Study* study )
4464 bool res = SalomeApp_Module::activateModule( study );
4466 setMenuShown( true );
4467 setToolShown( true );
4469 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4470 PyGILState_STATE gstate = PyGILState_Ensure();
4471 PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4472 if(pluginsmanager==NULL)
4476 PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4481 PyGILState_Release(gstate);
4482 // end of GEOM plugins loading
4484 // Reset actions accelerator keys
4485 //action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4486 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4487 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4489 action( 33)->setEnabled(true); // Delete: Key_Delete
4491 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4492 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4493 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4494 if ( _PTR(Study) aStudy = s->studyDS()) {
4495 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4496 updateObjBrowser(); // objects can be removed
4499 // get all view currently opened in the study and connect their signals to
4500 // the corresponding slots of the class.
4501 SUIT_Desktop* aDesk = study->application()->desktop();
4503 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4504 SUIT_ViewWindow* wnd;
4505 foreach ( wnd, wndList )
4512 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4514 setMenuShown( false );
4515 setToolShown( false );
4517 EmitSignalCloseAllDialogs();
4519 // Unset actions accelerator keys
4520 //action(111)->setShortcut(QKeySequence()); // Import DAT
4521 action(112)->setShortcut(QKeySequence()); // Import UNV
4522 action(113)->setShortcut(QKeySequence()); // Import MED
4524 action( 33)->setEnabled(false); // Delete: Key_Delete
4526 return SalomeApp_Module::deactivateModule( study );
4529 void SMESHGUI::studyClosed( SUIT_Study* s )
4531 SMESH::RemoveVisuData( s->id() );
4532 SalomeApp_Module::studyClosed( s );
4535 void SMESHGUI::OnGUIEvent()
4537 const QObject* obj = sender();
4538 if ( !obj || !obj->inherits( "QAction" ) )
4540 int id = actionId((QAction*)obj);
4545 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4547 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4548 if ( CORBA::is_nil( myComponentSMESH ) )
4550 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4552 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4553 return aGUI.myComponentSMESH;
4556 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4557 return myComponentSMESH;
4560 QString SMESHGUI::engineIOR() const
4562 CORBA::ORB_var anORB = getApp()->orb();
4563 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4564 return QString( anIOR.in() );
4567 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4569 SalomeApp_Module::contextMenuPopup( client, menu, title );
4571 selectionMgr()->selectedObjects( lst );
4572 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4573 Handle(SALOME_InteractiveObject) io = lst.First();
4574 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4575 _PTR(Study) study = appStudy->studyDS();
4576 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4578 QString aName = QString( obj->GetName().c_str() );
4579 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4580 aName.remove( (aName.length() - 1), 1 );
4586 LightApp_Selection* SMESHGUI::createSelection() const
4588 return new SMESHGUI_Selection();
4591 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4593 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4594 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4597 void SMESHGUI::viewManagers( QStringList& list ) const
4599 list.append( SVTK_Viewer::Type() );
4602 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4604 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4605 SMESH::UpdateSelectionProp( this );
4607 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4608 for(int i = 0; i < aViews.count() ; i++){
4609 SUIT_ViewWindow *sf = aViews[i];
4615 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4617 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4618 myClippingPlaneInfoMap.erase( theViewManager );
4621 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4623 theActor->AddObserver( SMESH::DeleteActorEvent,
4624 myEventCallbackCommand.GetPointer(),
4628 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4629 unsigned long theEvent,
4630 void* theClientData,
4633 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4634 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4635 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4636 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4637 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4638 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4639 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4640 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4641 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4642 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4643 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4644 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4645 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4646 if( anActor == *anIter3 ) {
4647 anActorList.erase( anIter3 );
4658 void SMESHGUI::createPreferences()
4660 // General tab ------------------------------------------------------------------------
4661 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4663 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4664 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4665 setPreferenceProperty( lim, "min", 0 );
4666 setPreferenceProperty( lim, "max", 100000000 );
4667 setPreferenceProperty( lim, "step", 1000 );
4668 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4670 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4671 setPreferenceProperty( qaGroup, "columns", 2 );
4672 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4673 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4674 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4675 setPreferenceProperty( prec, "min", 0 );
4676 setPreferenceProperty( prec, "max", 16 );
4677 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4678 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4679 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4680 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4681 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4683 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4684 setPreferenceProperty( dispgroup, "columns", 2 );
4685 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4687 modes.append( tr("MEN_WIRE") );
4688 modes.append( tr("MEN_SHADE") );
4689 modes.append( tr("MEN_NODES") );
4690 modes.append( tr("MEN_SHRINK") );
4691 QList<QVariant> indices;
4692 indices.append( 0 );
4693 indices.append( 1 );
4694 indices.append( 2 );
4695 indices.append( 3 );
4696 setPreferenceProperty( dispmode, "strings", modes );
4697 setPreferenceProperty( dispmode, "indexes", indices );
4699 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4700 setPreferenceProperty( arcgroup, "columns", 2 );
4701 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4702 QStringList quadraticModes;
4703 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4704 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4706 indices.append( 0 );
4707 indices.append( 1 );
4708 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4709 setPreferenceProperty( quadraticmode, "indexes", indices );
4711 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4712 "SMESH", "max_angle" );
4713 setPreferenceProperty( maxAngle, "min", 1 );
4714 setPreferenceProperty( maxAngle, "max", 90 );
4718 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4719 setPreferenceProperty( exportgroup, "columns", 2 );
4720 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4721 addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4723 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4724 setPreferenceProperty( computeGroup, "columns", 2 );
4725 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4727 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4728 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4729 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4731 indices.append( 0 );
4732 indices.append( 1 );
4733 indices.append( 2 );
4734 setPreferenceProperty( notifyMode, "strings", modes );
4735 setPreferenceProperty( notifyMode, "indexes", indices );
4737 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4738 setPreferenceProperty( infoGroup, "columns", 2 );
4739 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4741 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4742 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4744 indices.append( 0 );
4745 indices.append( 1 );
4746 setPreferenceProperty( elemInfo, "strings", modes );
4747 setPreferenceProperty( elemInfo, "indexes", indices );
4748 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4749 setPreferenceProperty( nodesLim, "min", 0 );
4750 setPreferenceProperty( nodesLim, "max", 10000000 );
4751 setPreferenceProperty( nodesLim, "step", 10000 );
4752 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4753 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
4754 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
4755 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
4756 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
4758 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4759 setPreferenceProperty( segGroup, "columns", 2 );
4760 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4761 "SMESH", "segmentation" );
4762 setPreferenceProperty( segLen, "min", 1 );
4763 setPreferenceProperty( segLen, "max", 10000000 );
4764 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4765 "SMESH", "nb_segments_per_edge" );
4766 setPreferenceProperty( nbSeg, "min", 1 );
4767 setPreferenceProperty( nbSeg, "max", 10000000 );
4769 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4770 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4771 "SMESH", "forget_mesh_on_hyp_modif" );
4774 // Quantities with individual precision settings
4775 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4776 setPreferenceProperty( precGroup, "columns", 2 );
4778 const int nbQuantities = 6;
4779 int precs[nbQuantities], ii = 0;
4780 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4781 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4782 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4783 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4784 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4785 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4786 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4787 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4788 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4789 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4790 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4791 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4793 // Set property for precision value for spinboxes
4794 for ( ii = 0; ii < nbQuantities; ii++ ){
4795 setPreferenceProperty( precs[ii], "min", -14 );
4796 setPreferenceProperty( precs[ii], "max", 14 );
4797 setPreferenceProperty( precs[ii], "precision", 2 );
4800 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4801 setPreferenceProperty( previewGroup, "columns", 2 );
4802 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4803 setPreferenceProperty( chunkSize, "min", 1 );
4804 setPreferenceProperty( chunkSize, "max", 1000 );
4805 setPreferenceProperty( chunkSize, "step", 50 );
4807 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4808 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4810 // Mesh tab ------------------------------------------------------------------------
4811 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4812 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4813 setPreferenceProperty( nodeGroup, "columns", 3 );
4815 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4817 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4819 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4820 QList<QVariant> aMarkerTypeIndicesList;
4821 QList<QVariant> aMarkerTypeIconsList;
4822 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4823 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4824 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4825 aMarkerTypeIndicesList << i;
4826 aMarkerTypeIconsList << pixmap;
4828 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4829 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4831 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4833 QList<QVariant> aMarkerScaleIndicesList;
4834 QStringList aMarkerScaleValuesList;
4835 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4836 aMarkerScaleIndicesList << i;
4837 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4839 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4840 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4842 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4843 //setPreferenceProperty( elemGroup, "columns", 2 );
4845 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4846 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4847 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
4848 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
4849 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4850 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
4851 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4852 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4855 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4856 setPreferenceProperty( grpGroup, "columns", 2 );
4858 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4859 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
4861 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4862 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4863 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
4864 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
4865 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4866 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4867 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
4868 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
4869 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4870 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4872 setPreferenceProperty( size0d, "min", 1 );
4873 setPreferenceProperty( size0d, "max", 10 );
4875 setPreferenceProperty( ballSize, "min", 1 );
4876 setPreferenceProperty( ballSize, "max", 10 );
4878 setPreferenceProperty( elemW, "min", 1 );
4879 setPreferenceProperty( elemW, "max", 5 );
4881 setPreferenceProperty( outW, "min", 1 );
4882 setPreferenceProperty( outW, "max", 5 );
4884 setPreferenceProperty( shrink, "min", 0 );
4885 setPreferenceProperty( shrink, "max", 100 );
4887 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
4888 setPreferenceProperty( numGroup, "columns", 6 );
4890 fonts << tr( "SMESH_ARIAL" ) << tr( "SMESH_COURIER" ) << tr( "SMESH_TIMES" );
4891 indices.clear(); indices << 0 << 1 << 2;
4893 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
4894 int NumNodeSize = addPreference( tr( "PREF_NUMBERING_SIZE" ), numGroup, LightApp_Preferences::IntSpin, "SMESH", "numbering_node_size" );
4895 setPreferenceProperty( NumNodeSize, "min", 1 );
4896 setPreferenceProperty( NumNodeSize, "max", 100 );
4897 int NumFontNode = addPreference( tr( "PREF_NUMBERING_FONT" ), numGroup, LightApp_Preferences::Selector, "SMESH", "numbering_node_font" );
4898 setPreferenceProperty( NumFontNode, "strings", fonts );
4899 setPreferenceProperty( NumFontNode, "indexes", indices );
4900 addPreference( tr( "PREF_NUMBERING_BOLD" ), numGroup, LightApp_Preferences::Bool, "SMESH", "numbering_node_bold" );
4901 addPreference( tr( "PREF_NUMBERING_ITALIC" ), numGroup, LightApp_Preferences::Bool, "SMESH", "numbering_node_italic" );
4902 addPreference( tr( "PREF_NUMBERING_SHADOW" ), numGroup, LightApp_Preferences::Bool, "SMESH", "numbering_node_shadow" );
4904 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
4905 int NumElemSize = addPreference( tr( "PREF_NUMBERING_SIZE" ), numGroup, LightApp_Preferences::IntSpin, "SMESH", "numbering_elem_size" );
4906 setPreferenceProperty( NumElemSize, "min", 1 );
4907 setPreferenceProperty( NumElemSize, "max", 100 );
4908 int NumFontElem = addPreference( tr( "PREF_NUMBERING_FONT" ), numGroup, LightApp_Preferences::Selector, "SMESH", "numbering_elem_font" );
4909 setPreferenceProperty( NumFontElem, "strings", fonts );
4910 setPreferenceProperty( NumFontElem, "indexes", indices );
4911 addPreference( tr( "PREF_NUMBERING_BOLD" ), numGroup, LightApp_Preferences::Bool, "SMESH", "numbering_elem_bold" );
4912 addPreference( tr( "PREF_NUMBERING_ITALIC" ), numGroup, LightApp_Preferences::Bool, "SMESH", "numbering_elem_italic" );
4913 addPreference( tr( "PREF_NUMBERING_SHADOW" ), numGroup, LightApp_Preferences::Bool, "SMESH", "numbering_elem_shadow" );
4915 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4916 setPreferenceProperty( orientGroup, "columns", 1 );
4918 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4919 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4921 setPreferenceProperty( orientScale, "min", 0.05 );
4922 setPreferenceProperty( orientScale, "max", 0.5 );
4923 setPreferenceProperty( orientScale, "step", 0.05 );
4925 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4927 // Selection tab ------------------------------------------------------------------------
4928 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4930 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4931 setPreferenceProperty( selGroup, "columns", 2 );
4933 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4934 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4936 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4937 setPreferenceProperty( preGroup, "columns", 2 );
4939 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4941 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4942 setPreferenceProperty( precSelGroup, "columns", 2 );
4944 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4945 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4946 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4948 // Scalar Bar tab ------------------------------------------------------------------------
4949 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4950 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4951 setPreferenceProperty( fontGr, "columns", 2 );
4953 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4954 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4956 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4957 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4959 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4960 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4962 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4963 setPreferenceProperty( numcol, "min", 2 );
4964 setPreferenceProperty( numcol, "max", 256 );
4966 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4967 setPreferenceProperty( numlab, "min", 2 );
4968 setPreferenceProperty( numlab, "max", 65 );
4970 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4971 setPreferenceProperty( orientGr, "columns", 2 );
4972 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4973 QStringList orients;
4974 orients.append( tr( "SMESH_VERTICAL" ) );
4975 orients.append( tr( "SMESH_HORIZONTAL" ) );
4976 indices.clear(); indices.append( 0 ); indices.append( 1 );
4977 setPreferenceProperty( orient, "strings", orients );
4978 setPreferenceProperty( orient, "indexes", indices );
4980 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4981 setPreferenceProperty( posVSizeGr, "columns", 2 );
4982 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4983 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4984 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4985 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4986 setPreferenceProperty( xv, "step", 0.1 );
4987 setPreferenceProperty( xv, "min", 0.0 );
4988 setPreferenceProperty( xv, "max", 1.0 );
4989 setPreferenceProperty( yv, "step", 0.1 );
4990 setPreferenceProperty( yv, "min", 0.0 );
4991 setPreferenceProperty( yv, "max", 1.0 );
4992 setPreferenceProperty( wv, "step", 0.1 );
4993 setPreferenceProperty( wv, "min", 0.0 );
4994 setPreferenceProperty( wv, "max", 1.0 );
4995 setPreferenceProperty( hv, "min", 0.0 );
4996 setPreferenceProperty( hv, "max", 1.0 );
4997 setPreferenceProperty( hv, "step", 0.1 );
4999 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5000 setPreferenceProperty( posHSizeGr, "columns", 2 );
5001 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5002 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5003 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5004 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5005 setPreferenceProperty( xv, "min", 0.0 );
5006 setPreferenceProperty( xv, "max", 1.0 );
5007 setPreferenceProperty( xv, "step", 0.1 );
5008 setPreferenceProperty( xh, "min", 0.0 );
5009 setPreferenceProperty( xh, "max", 1.0 );
5010 setPreferenceProperty( xh, "step", 0.1 );
5011 setPreferenceProperty( yh, "min", 0.0 );
5012 setPreferenceProperty( yh, "max", 1.0 );
5013 setPreferenceProperty( yh, "step", 0.1 );
5014 setPreferenceProperty( wh, "min", 0.0 );
5015 setPreferenceProperty( wh, "max", 1.0 );
5016 setPreferenceProperty( wh, "step", 0.1 );
5017 setPreferenceProperty( hh, "min", 0.0 );
5018 setPreferenceProperty( hh, "max", 1.0 );
5019 setPreferenceProperty( hh, "step", 0.1 );
5021 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5022 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5023 setPreferenceProperty( distributionGr, "columns", 3 );
5025 types.append( tr( "SMESH_MONOCOLOR" ) );
5026 types.append( tr( "SMESH_MULTICOLOR" ) );
5027 indices.clear(); indices.append( 0 ); indices.append( 1 );
5028 setPreferenceProperty( coloringType, "strings", types );
5029 setPreferenceProperty( coloringType, "indexes", indices );
5030 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5034 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5036 if( sect=="SMESH" ) {
5037 float sbX1,sbY1,sbW,sbH;
5038 float aTol = 1.00000009999999;
5039 std::string aWarning;
5040 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5041 if( name=="selection_object_color" || name=="selection_element_color" ||
5042 name=="highlight_color" ||
5043 name=="selection_precision_node" || name=="selection_precision_element" ||
5044 name=="selection_precision_object")
5045 SMESH::UpdateSelectionProp( this );
5046 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5047 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5048 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5049 if(sbX1+sbW > aTol){
5050 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5053 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5054 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5057 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5058 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5059 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5060 if(sbY1+sbH > aTol){
5061 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5062 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5063 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5066 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5067 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5068 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5069 if(sbX1+sbW > aTol){
5070 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5073 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5074 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5077 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5078 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5079 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5080 if(sbY1+sbH > aTol){
5081 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5084 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5085 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5088 else if ( name == "segmentation" ) {
5089 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5090 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5092 else if ( name == "nb_segments_per_edge" ) {
5093 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5094 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5096 else if ( name == "historical_python_dump" ||
5097 name == "forget_mesh_on_hyp_modif") {
5098 QString val = aResourceMgr->stringValue( "SMESH", name );
5099 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5101 else if(name == QString("numbering_node_color") || name == QString("numbering_node_size") ||
5102 name == QString("numbering_node_font") || name == QString("numbering_node_bold") ||
5103 name == QString("numbering_node_italic") || name == QString("numbering_node_shadow") ) {
5104 SMESH::UpdateFontProp( this );
5106 else if(name == QString("numbering_elem_color") || name == QString("numbering_elem_size") ||
5107 name == QString("numbering_elem_font") || name == QString("numbering_elem_bold") ||
5108 name == QString("numbering_elem_italic") || name == QString("numbering_elem_shadow") ) {
5109 SMESH::UpdateFontProp( this );
5112 if(aWarning.size() != 0){
5113 aWarning += "The default values are applied instead.";
5114 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5115 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5116 QObject::tr(aWarning.c_str()));
5121 //================================================================================
5123 * \brief Update something in accordance with update flags
5124 * \param theFlags - update flags
5126 * Update viewer or/and object browser etc. in accordance with update flags ( see
5127 * LightApp_UpdateFlags enumeration ).
5129 //================================================================================
5130 void SMESHGUI::update( const int flags )
5132 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5133 SMESH::UpdateView();
5135 SalomeApp_Module::update( flags );
5138 //================================================================================
5140 * \brief Set default selection mode
5142 * SLOT called when operation commited. Sets default selection mode
5144 //================================================================================
5145 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5147 SVTK_ViewWindow* vtkWnd =
5148 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5150 vtkWnd->SetSelectionMode( ActorSelection );
5153 //================================================================================
5155 * \brief Set default selection mode
5157 * SLOT called when operation aborted. Sets default selection mode
5159 //================================================================================
5160 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5162 SVTK_ViewWindow* vtkWnd =
5163 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5165 vtkWnd->SetSelectionMode( ActorSelection );
5168 //================================================================================
5170 * \brief Creates operation with given identifier
5171 * \param id - identifier of operation to be started
5172 * \return Pointer on created operation or NULL if operation is not created
5174 * Virtual method redefined from the base class creates operation with given id.
5175 * It is called called automatically from startOperation method of base class.
5177 //================================================================================
5178 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5180 LightApp_Operation* op = 0;
5181 // to do : create operation here
5184 case 417: //convert to quadratic
5185 op = new SMESHGUI_ConvToQuadOp();
5187 case 418: // create 2D mesh as boundary on 3D
5188 op = new SMESHGUI_Make2DFrom3DOp();
5190 case 420: // Reorient faces
5191 op = new SMESHGUI_ReorientFacesOp();
5193 case 701: // Compute mesh
5194 op = new SMESHGUI_ComputeOp();
5196 case 702: // Create mesh
5197 op = new SMESHGUI_MeshOp( true, true );
5199 case 703: // Create sub-mesh
5200 op = new SMESHGUI_MeshOp( true, false );
5202 case 704: // Edit mesh/sub-mesh
5203 op = new SMESHGUI_MeshOp( false );
5205 case 711: // Precompute mesh
5206 op = new SMESHGUI_PrecomputeOp();
5208 case 712: // Evaluate mesh
5209 op = new SMESHGUI_EvaluateOp();
5211 case 713: // Evaluate mesh
5212 op = new SMESHGUI_MeshOrderOp();
5214 case 806: // Create group on geom
5215 op = new SMESHGUI_GroupOnShapeOp();
5217 case 904: // Find element
5218 op = new SMESHGUI_FindElemByPointOp();
5220 case 4067: // Make mesh pass through point
5221 op = new SMESHGUI_MakeNodeAtPointOp();
5223 case 4070: // Create 0D elements on all nodes
5224 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5231 op = SalomeApp_Module::createOperation( id );
5235 //================================================================================
5237 * \brief Stops current operations and starts a given one
5238 * \param id - The id of the operation to start
5240 //================================================================================
5242 void SMESHGUI::switchToOperation(int id)
5244 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5245 activeStudy()->abortAllOperations();
5246 startOperation( id );
5249 LightApp_Displayer* SMESHGUI::displayer()
5252 myDisplayer = new SMESHGUI_Displayer( getApp() );
5256 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5259 int aTolerance = 64;
5260 int anIterations = 0;
5266 if( anIterations % aPeriod == 0 )
5269 if( aTolerance < 1 )
5273 aHue = (int)( 360.0 * rand() / RAND_MAX );
5276 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5277 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5278 for( ; it != itEnd; ++it )
5280 SALOMEDS::Color anAutoColor = *it;
5281 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5284 aQColor.getHsv( &h, &s, &v );
5285 if( abs( h - aHue ) < aTolerance )
5297 aColor.setHsv( aHue, 255, 255 );
5299 SALOMEDS::Color aSColor;
5300 aSColor.R = aColor.redF();
5301 aSColor.G = aColor.greenF();
5302 aSColor.B = aColor.blueF();
5307 const char* gSeparator = "_"; // character used to separate parameter names
5308 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5309 const char* gPathSep = "|"; // character used to separate paths
5312 * \brief Store visual parameters
5314 * This method is called just before the study document is saved.
5315 * Store visual parameters in AttributeParameter attribue(s)
5317 void SMESHGUI::storeVisualParameters (int savePoint)
5320 Kernel_Utils::Localizer loc;
5322 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5323 if (!appStudy || !appStudy->studyDS())
5325 _PTR(Study) studyDS = appStudy->studyDS();
5327 // componentName is used for encoding of entries when storing them in IParameters
5328 std::string componentName = myComponentSMESH->ComponentDataType();
5329 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5330 //if (!aSComponent) return;
5333 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5334 componentName.c_str(),
5336 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5338 // store map of custom markers
5339 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5340 if( !aMarkerMap.empty() )
5342 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5343 for( ; anIter != aMarkerMap.end(); anIter++ )
5345 int anId = anIter->first;
5346 VTK::MarkerData aMarkerData = anIter->second;
5347 std::string aMarkerFileName = aMarkerData.first;
5348 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5349 if( aMarkerTexture.size() < 3 )
5350 continue; // should contain at least width, height and the first value
5352 QString aPropertyName( "texture" );
5353 aPropertyName += gSeparator;
5354 aPropertyName += QString::number( anId );
5356 QString aPropertyValue = aMarkerFileName.c_str();
5357 aPropertyValue += gPathSep;
5359 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5360 ushort aWidth = *aTextureIter++;
5361 ushort aHeight = *aTextureIter++;
5362 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5363 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5364 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5365 aPropertyValue += QString::number( *aTextureIter );
5367 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5371 // viewers counters are used for storing view_numbers in IParameters
5374 // main cycle to store parameters of displayed objects
5375 QList<SUIT_ViewManager*> lst;
5376 QList<SUIT_ViewManager*>::Iterator it;
5377 getApp()->viewManagers(lst);
5378 for (it = lst.begin(); it != lst.end(); it++)
5380 SUIT_ViewManager* vman = *it;
5381 QString vType = vman->getType();
5383 // saving VTK actors properties
5384 if (vType == SVTK_Viewer::Type())
5386 // store the clipping planes attached to the view manager
5387 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5388 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5389 if( anIter != myClippingPlaneInfoMap.end() )
5390 aClippingPlaneInfoList = anIter->second;
5392 if( !aClippingPlaneInfoList.empty() ) {
5393 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5394 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5396 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5397 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5399 QString aPropertyName( "ClippingPlane" );
5400 aPropertyName += gSeparator;
5401 aPropertyName += QString::number( vtkViewers );
5402 aPropertyName += gSeparator;
5403 aPropertyName += QString::number( anId );
5405 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5406 aPropertyValue += gDigitsSep;
5407 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5408 aPropertyValue += gDigitsSep;
5409 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5410 aPropertyValue += gDigitsSep;
5411 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5413 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5417 QVector<SUIT_ViewWindow*> views = vman->getViews();
5418 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5420 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5422 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5423 vtkActorCollection* allActors = aCopy.GetActors();
5424 allActors->InitTraversal();
5425 while (vtkActor* actor = allActors->GetNextActor())
5427 if (actor->GetVisibility()) // store only visible actors
5429 SMESH_Actor* aSmeshActor = 0;
5430 if (actor->IsA("SMESH_Actor"))
5431 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5432 if (aSmeshActor && aSmeshActor->hasIO())
5434 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5437 // entry is "encoded" = it does NOT contain component adress,
5438 // since it is a subject to change on next component loading
5439 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5441 std::string param, vtkParam = vType.toLatin1().data();
5442 vtkParam += gSeparator;
5443 vtkParam += QString::number(vtkViewers).toLatin1().data();
5444 vtkParam += gSeparator;
5447 param = vtkParam + "Visibility";
5448 ip->setParameter(entry, param, "On");
5451 param = vtkParam + "Representation";
5452 ip->setParameter(entry, param, QString::number
5453 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5456 param = vtkParam + "IsShrunk";
5457 ip->setParameter(entry, param, QString::number
5458 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5460 // Displayed entities
5461 unsigned int aMode = aSmeshActor->GetEntityMode();
5462 bool isE = aMode & SMESH_Actor::eEdges;
5463 bool isF = aMode & SMESH_Actor::eFaces;
5464 bool isV = aMode & SMESH_Actor::eVolumes;
5465 bool is0d = aMode & SMESH_Actor::e0DElements;
5466 bool isB = aMode & SMESH_Actor::eBallElem;
5468 QString modeStr ("e");
5469 modeStr += gDigitsSep; modeStr += QString::number(isE);
5470 modeStr += gDigitsSep; modeStr += "f";
5471 modeStr += gDigitsSep; modeStr += QString::number(isF);
5472 modeStr += gDigitsSep; modeStr += "v";
5473 modeStr += gDigitsSep; modeStr += QString::number(isV);
5474 modeStr += gDigitsSep; modeStr += "0d";
5475 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5476 modeStr += gDigitsSep; modeStr += "b";
5477 modeStr += gDigitsSep; modeStr += QString::number(isB);
5479 param = vtkParam + "Entities";
5480 ip->setParameter(entry, param, modeStr.toLatin1().data());
5483 vtkFloatingPointType r, g, b;
5486 aSmeshActor->GetSufaceColor(r, g, b, delta);
5487 QStringList colorStr;
5488 colorStr << "surface";
5489 colorStr << QString::number(r);
5490 colorStr << QString::number(g);
5491 colorStr << QString::number(b);
5493 colorStr << "backsurface";
5494 colorStr << QString::number(delta);
5496 aSmeshActor->GetVolumeColor(r, g, b, delta);
5497 colorStr << "volume";
5498 colorStr << QString::number(r);
5499 colorStr << QString::number(g);
5500 colorStr << QString::number(b);
5501 colorStr << QString::number(delta);
5503 aSmeshActor->GetEdgeColor(r, g, b);
5505 colorStr << QString::number(r);
5506 colorStr << QString::number(g);
5507 colorStr << QString::number(b);
5509 aSmeshActor->GetNodeColor(r, g, b);
5511 colorStr << QString::number(r);
5512 colorStr << QString::number(g);
5513 colorStr << QString::number(b);
5515 aSmeshActor->GetOutlineColor(r, g, b);
5516 colorStr << "outline";
5517 colorStr << QString::number(r);
5518 colorStr << QString::number(g);
5519 colorStr << QString::number(b);
5521 aSmeshActor->Get0DColor(r, g, b);
5522 colorStr << "elem0d";
5523 colorStr << QString::number(r);
5524 colorStr << QString::number(g);
5525 colorStr << QString::number(b);
5527 aSmeshActor->GetBallColor(r, g, b);
5529 colorStr << QString::number(r);
5530 colorStr << QString::number(g);
5531 colorStr << QString::number(b);
5533 aSmeshActor->GetFacesOrientationColor(r, g, b);
5534 colorStr << "orientation";
5535 colorStr << QString::number(r);
5536 colorStr << QString::number(g);
5537 colorStr << QString::number(b);
5539 param = vtkParam + "Colors";
5540 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5543 QStringList sizeStr;
5545 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5546 sizeStr << "outline";
5547 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5548 sizeStr << "elem0d";
5549 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5551 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5552 sizeStr << "shrink";
5553 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5554 sizeStr << "orientation";
5555 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5556 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5558 param = vtkParam + "Sizes";
5559 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5564 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5565 if( aMarkerType == VTK::MT_USER ) {
5566 markerStr += "custom";
5567 markerStr += gDigitsSep;
5568 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5572 markerStr += gDigitsSep;
5573 markerStr += QString::number( (int)aMarkerType );
5574 markerStr += gDigitsSep;
5575 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5578 param = vtkParam + "PointMarker";
5579 ip->setParameter(entry, param, markerStr.toLatin1().data());
5582 param = vtkParam + "Opacity";
5583 ip->setParameter(entry, param,
5584 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5587 param = vtkParam + "ClippingPlane";
5589 if( !aClippingPlaneInfoList.empty() ) {
5590 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5591 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5593 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5594 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5595 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5596 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5597 if( aSmeshActor == *anIter2 ) {
5598 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5599 QString::number( anId ).toLatin1().constData() );
5606 ip->setParameter( entry, param, "Off" );
5607 } // if (io->hasEntry())
5608 } // SMESH_Actor && hasIO
5610 } // while.. actors traversal
5614 } // if (SVTK view model)
5615 } // for (viewManagers)
5618 // data structures for clipping planes processing
5621 vtkIdType Orientation;
5622 vtkFloatingPointType Distance;
5623 vtkFloatingPointType Angle[2];
5625 typedef std::list<TPlaneData> TPlaneDataList;
5626 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5628 typedef std::list<vtkActor*> TActorList;
5631 TActorList ActorList;
5632 SUIT_ViewManager* ViewManager;
5634 typedef std::list<TPlaneInfo> TPlaneInfoList;
5635 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5638 * \brief Restore visual parameters
5640 * This method is called after the study document is opened.
5641 * Restore visual parameters from AttributeParameter attribue(s)
5643 void SMESHGUI::restoreVisualParameters (int savePoint)
5646 Kernel_Utils::Localizer loc;
5648 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5649 if (!appStudy || !appStudy->studyDS())
5651 _PTR(Study) studyDS = appStudy->studyDS();
5653 // componentName is used for encoding of entries when storing them in IParameters
5654 std::string componentName = myComponentSMESH->ComponentDataType();
5655 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5656 //if (!aSComponent) return;
5659 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5660 componentName.c_str(),
5662 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5664 // restore map of custom markers and map of clipping planes
5665 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5666 TPlaneDataMap aPlaneDataMap;
5668 std::vector<std::string> properties = ip->getProperties();
5669 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5671 std::string property = *propIt;
5672 QString aPropertyName( property.c_str() );
5673 QString aPropertyValue( ip->getProperty( property ).c_str() );
5675 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5676 if( aPropertyNameList.isEmpty() )
5679 QString aPropertyType = aPropertyNameList[0];
5680 if( aPropertyType == "texture" )
5682 if( aPropertyNameList.size() != 2 )
5686 int anId = aPropertyNameList[1].toInt( &ok );
5687 if( !ok || anId < 1 )
5690 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5691 if( aPropertyValueList.size() != 2 )
5694 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5695 QString aMarkerTextureString = aPropertyValueList[1];
5696 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5697 if( aMarkerTextureStringList.size() != 3 )
5701 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5706 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5710 VTK::MarkerTexture aMarkerTexture;
5711 aMarkerTexture.push_back( aWidth );
5712 aMarkerTexture.push_back( aHeight );
5714 QString aMarkerTextureData = aMarkerTextureStringList[2];
5715 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5717 QChar aChar = aMarkerTextureData.at( i );
5718 if( aChar.isDigit() )
5719 aMarkerTexture.push_back( aChar.digitValue() );
5722 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5724 else if( aPropertyType == "ClippingPlane" )
5726 if( aPropertyNameList.size() != 3 )
5730 int aViewId = aPropertyNameList[1].toInt( &ok );
5731 if( !ok || aViewId < 0 )
5735 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5736 if( !ok || aClippingPlaneId < 0 )
5739 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5740 if( aPropertyValueList.size() != 4 )
5743 TPlaneData aPlaneData;
5744 aPlaneData.Id = aClippingPlaneId;
5747 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5752 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5757 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5762 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5766 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5767 aPlaneDataList.push_back( aPlaneData );
5771 TPlaneInfoMap aPlaneInfoMap;
5773 std::vector<std::string> entries = ip->getEntries();
5775 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5777 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5778 QString entry (ip->decodeEntry(*entIt).c_str());
5780 // Check that the entry corresponds to a real object in the Study
5781 // as the object may be deleted or modified after the visual state is saved.
5782 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5783 if (!so) continue; //Skip the not existent entry
5785 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5786 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5788 std::vector<std::string>::iterator namesIt = paramNames.begin();
5789 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5791 // actors are stored in a map after displaying of them for
5792 // quicker access in the future: map < viewID to actor >
5793 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5795 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5797 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5798 // '_' is used as separator and should not be used in viewer type or parameter names.
5799 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5800 if (lst.size() != 3)
5803 QString viewerTypStr = lst[0];
5804 QString viewIndexStr = lst[1];
5805 QString paramNameStr = lst[2];
5808 int viewIndex = viewIndexStr.toUInt(&ok);
5809 if (!ok) // bad conversion of view index to integer
5813 if (viewerTypStr == SVTK_Viewer::Type())
5815 SMESH_Actor* aSmeshActor = 0;
5816 if (vtkActors.IsBound(viewIndex))
5817 aSmeshActor = vtkActors.Find(viewIndex);
5819 QList<SUIT_ViewManager*> lst;
5820 getApp()->viewManagers(viewerTypStr, lst);
5822 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5823 SUIT_ViewManager* vman = NULL;
5824 if (viewIndex >= 0 && viewIndex < lst.count())
5825 vman = lst.at(viewIndex);
5827 if (paramNameStr == "Visibility")
5829 if (!aSmeshActor && displayer() && vman)
5831 SUIT_ViewModel* vmodel = vman->getViewModel();
5832 // SVTK view model can be casted to SALOME_View
5833 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5835 // store displayed actor in a temporary map for quicker
5836 // access later when restoring other parameters
5837 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5838 vtkRenderer* Renderer = vtkView->getRenderer();
5839 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5840 vtkActorCollection* theActors = aCopy.GetActors();
5841 theActors->InitTraversal();
5842 bool isFound = false;
5843 vtkActor *ac = theActors->GetNextActor();
5844 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5845 if (ac->IsA("SMESH_Actor")) {
5846 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5847 if (aGeomAc->hasIO()) {
5848 Handle(SALOME_InteractiveObject) io =
5849 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5850 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5852 vtkActors.Bind(viewIndex, aGeomAc);
5858 } // if (paramNameStr == "Visibility")
5861 // the rest properties "work" with SMESH_Actor
5864 QString val ((*valuesIt).c_str());
5867 if (paramNameStr == "Representation") {
5868 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5871 else if (paramNameStr == "IsShrunk") {
5873 if (!aSmeshActor->IsShrunk())
5874 aSmeshActor->SetShrink();
5877 if (aSmeshActor->IsShrunk())
5878 aSmeshActor->UnShrink();
5881 // Displayed entities
5882 else if (paramNameStr == "Entities") {
5883 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5884 int aEntityMode = SMESH_Actor::eAllEntity;
5885 for ( int i = 0; i < mode.count(); i+=2 ) {
5886 if ( i < mode.count()-1 ) {
5887 QString type = mode[i];
5888 bool val = mode[i+1].toInt();
5889 if ( type == "e" && !val )
5890 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
5891 else if ( type == "f" && !val )
5892 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
5893 else if ( type == "v" && !val )
5894 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
5895 else if ( type == "0d" && !val )
5896 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
5897 else if ( type == "b" && !val )
5898 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
5901 aSmeshActor->SetEntityMode( aEntityMode );
5904 else if (paramNameStr == "Colors") {
5905 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5912 QColor outlineColor;
5913 QColor orientationColor;
5919 // below lines are required to get default values for delta coefficients
5920 // of backface color for faces and color of reversed volumes
5921 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
5922 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
5923 for ( int i = 0; i < colors.count(); i++ ) {
5924 QString type = colors[i];
5925 if ( type == "surface" ) {
5926 // face color is set by 3 values r:g:b, where
5927 // - r,g,b - is rgb color components
5928 if ( i+1 >= colors.count() ) break; // format error
5929 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5930 if ( i+2 >= colors.count() ) break; // format error
5931 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5932 if ( i+3 >= colors.count() ) break; // format error
5933 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5934 faceColor.setRgbF( r, g, b );
5937 else if ( type == "backsurface" ) {
5938 // backface color can be defined in several ways
5939 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
5940 // - in latest versions, it is set as delta coefficient
5941 bool rgbOk = false, deltaOk;
5942 if ( i+1 >= colors.count() ) break; // format error
5943 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5944 int delta = colors[i+1].toInt( &deltaOk );
5946 if ( i+1 < colors.count() ) // index is shifted to 1
5947 g = colors[i+1].toDouble( &rgbOk );
5948 if ( rgbOk ) i++; // shift index
5949 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
5950 b = colors[i+1].toDouble( &rgbOk );
5952 // - as currently there's no way to set directly backsurface color as it was before,
5953 // we ignore old dump where r,g,b triple was set
5954 // - also we check that delta parameter is set properly
5955 if ( !rgbOk && deltaOk )
5958 else if ( type == "volume" ) {
5959 // volume color is set by 4 values r:g:b:delta, where
5960 // - r,g,b - is a normal volume rgb color components
5961 // - delta - is a reversed volume color delta coefficient
5962 if ( i+1 >= colors.count() ) break; // format error
5963 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5964 if ( i+2 >= colors.count() ) break; // format error
5965 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5966 if ( i+3 >= colors.count() ) break; // format error
5967 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5968 if ( i+4 >= colors.count() ) break; // format error
5969 int delta = colors[i+4].toInt( &bOk );
5970 if ( !bOk ) break; // format error
5971 volumeColor.setRgbF( r, g, b );
5975 else if ( type == "edge" ) {
5976 // edge color is set by 3 values r:g:b, where
5977 // - r,g,b - is rgb color components
5978 if ( i+1 >= colors.count() ) break; // format error
5979 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5980 if ( i+2 >= colors.count() ) break; // format error
5981 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5982 if ( i+3 >= colors.count() ) break; // format error
5983 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5984 edgeColor.setRgbF( r, g, b );
5987 else if ( type == "node" ) {
5988 // node color is set by 3 values r:g:b, where
5989 // - r,g,b - is rgb color components
5990 if ( i+1 >= colors.count() ) break; // format error
5991 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5992 if ( i+2 >= colors.count() ) break; // format error
5993 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5994 if ( i+3 >= colors.count() ) break; // format error
5995 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5996 nodeColor.setRgbF( r, g, b );
5999 else if ( type == "elem0d" ) {
6000 // 0d element color is set by 3 values r:g:b, where
6001 // - r,g,b - is rgb color components
6002 if ( i+1 >= colors.count() ) break; // format error
6003 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6004 if ( i+2 >= colors.count() ) break; // format error
6005 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6006 if ( i+3 >= colors.count() ) break; // format error
6007 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6008 elem0dColor.setRgbF( r, g, b );
6011 else if ( type == "ball" ) {
6012 // ball color is set by 3 values r:g:b, where
6013 // - r,g,b - is rgb color components
6014 if ( i+1 >= colors.count() ) break; // format error
6015 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6016 if ( i+2 >= colors.count() ) break; // format error
6017 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6018 if ( i+3 >= colors.count() ) break; // format error
6019 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6020 ballColor.setRgbF( r, g, b );
6023 else if ( type == "outline" ) {
6024 // outline color is set by 3 values r:g:b, where
6025 // - r,g,b - is rgb color components
6026 if ( i+1 >= colors.count() ) break; // format error
6027 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6028 if ( i+2 >= colors.count() ) break; // format error
6029 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6030 if ( i+3 >= colors.count() ) break; // format error
6031 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6032 outlineColor.setRgbF( r, g, b );
6035 else if ( type == "orientation" ) {
6036 // orientation color is set by 3 values r:g:b, where
6037 // - r,g,b - is rgb color components
6038 if ( i+1 >= colors.count() ) break; // format error
6039 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6040 if ( i+2 >= colors.count() ) break; // format error
6041 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6042 if ( i+3 >= colors.count() ) break; // format error
6043 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6044 orientationColor.setRgbF( r, g, b );
6049 if ( nodeColor.isValid() )
6050 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6052 if ( edgeColor.isValid() )
6053 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6055 if ( faceColor.isValid() )
6056 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6058 if ( volumeColor.isValid() )
6059 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6060 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6061 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6063 if ( elem0dColor.isValid() )
6064 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6066 if ( ballColor.isValid() )
6067 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6069 if ( outlineColor.isValid() )
6070 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6071 // orientation color
6072 if ( orientationColor.isValid() )
6073 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6076 else if (paramNameStr == "Sizes") {
6077 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6080 int outlineWidth = -1;
6081 int elem0dSize = -1;
6083 double shrinkSize = -1;
6084 double orientationSize = -1;
6085 bool orientation3d = false;
6086 for ( int i = 0; i < sizes.count(); i++ ) {
6087 QString type = sizes[i];
6088 if ( type == "line" ) {
6089 // line (wireframe) width is given as single integer value
6090 if ( i+1 >= sizes.count() ) break; // format error
6091 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6095 if ( type == "outline" ) {
6096 // outline width is given as single integer value
6097 if ( i+1 >= sizes.count() ) break; // format error
6098 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6102 else if ( type == "elem0d" ) {
6103 // 0d element size is given as single integer value
6104 if ( i+1 >= sizes.count() ) break; // format error
6105 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6109 else if ( type == "ball" ) {
6110 // ball size is given as single integer value
6111 if ( i+1 >= sizes.count() ) break; // format error
6112 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6116 else if ( type == "shrink" ) {
6117 // shrink factor is given as single floating point value
6118 if ( i+1 >= sizes.count() ) break; // format error
6119 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6123 else if ( type == "orientation" ) {
6124 // orientation vectors are specified by two values size:3d, where
6125 // - size - is a floating point value specifying scale factor
6126 // - 3d - is a boolean
6127 if ( i+1 >= sizes.count() ) break; // format error
6128 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6129 if ( i+2 >= sizes.count() ) break; // format error
6130 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6131 orientationSize = v1;
6132 orientation3d = (bool)v2;
6136 // line (wireframe) width
6137 if ( lineWidth > 0 )
6138 aSmeshActor->SetLineWidth( lineWidth );
6140 if ( outlineWidth > 0 )
6141 aSmeshActor->SetOutlineWidth( outlineWidth );
6142 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6143 aSmeshActor->SetOutlineWidth( lineWidth );
6145 if ( elem0dSize > 0 )
6146 aSmeshActor->Set0DSize( elem0dSize );
6149 aSmeshActor->SetBallSize( ballSize );
6151 if ( shrinkSize > 0 )
6152 aSmeshActor->SetShrinkFactor( shrinkSize );
6153 // orientation vectors
6154 if ( orientationSize > 0 ) {
6155 aSmeshActor->SetFacesOrientationScale( orientationSize );
6156 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6160 else if (paramNameStr == "PointMarker") {
6161 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6162 if( data.count() >= 2 ) {
6164 int aParam1 = data[1].toInt( &ok );
6166 if( data[0] == "std" && data.count() == 3 ) {
6167 int aParam2 = data[2].toInt( &ok );
6168 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6170 else if( data[0] == "custom" ) {
6171 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6172 if( markerIt != aMarkerMap.end() ) {
6173 VTK::MarkerData aMarkerData = markerIt->second;
6174 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6181 else if (paramNameStr == "Opacity") {
6182 aSmeshActor->SetOpacity(val.toFloat());
6185 else if (paramNameStr.startsWith("ClippingPlane")) {
6186 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6187 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
6188 // new format - val looks like "Off" or "0" (plane id)
6189 // (note: in new format "Off" value is used only for consistency,
6190 // so it is processed together with values in old format)
6191 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
6192 if( anIsOldFormat ) {
6193 if (paramNameStr == "ClippingPlane1" || val == "Off")
6194 aSmeshActor->RemoveAllClippingPlanes();
6196 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
6197 double aDistance = vals[1].toFloat();
6198 vtkFloatingPointType anAngle[2];
6199 anAngle[0] = vals[2].toFloat();
6200 anAngle[1] = vals[3].toFloat();
6202 QList<SUIT_ViewManager*> lst;
6203 getApp()->viewManagers(viewerTypStr, lst);
6204 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6205 if (viewIndex >= 0 && viewIndex < lst.count()) {
6206 SUIT_ViewManager* vman = lst.at(viewIndex);
6207 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6209 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6211 SMESH::TActorList anActorList;
6212 anActorList.push_back( aSmeshActor );
6213 SMESH::OrientedPlane* aPlane =
6214 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
6216 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6217 aClippingPlaneInfo.Plane = aPlane;
6218 aClippingPlaneInfo.ActorList = anActorList;
6219 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6226 int aPlaneId = val.toInt( &ok );
6227 if( ok && aPlaneId >= 0 ) {
6228 bool anIsDefinedPlane = false;
6229 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6230 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6231 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6232 TPlaneInfo& aPlaneInfo = *anIter;
6233 if( aPlaneInfo.PlaneId == aPlaneId ) {
6234 aPlaneInfo.ActorList.push_back( aSmeshActor );
6235 anIsDefinedPlane = true;
6239 if( !anIsDefinedPlane ) {
6240 TPlaneInfo aPlaneInfo;
6241 aPlaneInfo.PlaneId = aPlaneId;
6242 aPlaneInfo.ActorList.push_back( aSmeshActor );
6243 aPlaneInfo.ViewManager = vman;
6245 // to make the list sorted by plane id
6246 anIter = aPlaneInfoList.begin();
6247 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6248 const TPlaneInfo& aPlaneInfoRef = *anIter;
6249 if( aPlaneInfoRef.PlaneId > aPlaneId )
6252 aPlaneInfoList.insert( anIter, aPlaneInfo );
6257 } // if (aSmeshActor)
6258 } // other parameters than Visibility
6260 } // for names/parameters iterator
6261 } // for entries iterator
6263 // take into account planes with empty list of actors referred to them
6264 QList<SUIT_ViewManager*> aVMList;
6265 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6267 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6268 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6269 int aViewId = aPlaneDataIter->first;
6270 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6271 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6273 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6275 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6276 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6277 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6278 const TPlaneData& aPlaneData = *anIter2;
6279 int aPlaneId = aPlaneData.Id;
6281 bool anIsFound = false;
6282 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6283 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6284 const TPlaneInfo& aPlaneInfo = *anIter3;
6285 if( aPlaneInfo.PlaneId == aPlaneId ) {
6292 TPlaneInfo aPlaneInfo; // ActorList field is empty
6293 aPlaneInfo.PlaneId = aPlaneId;
6294 aPlaneInfo.ViewManager = aViewManager;
6296 // to make the list sorted by plane id
6297 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6298 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6299 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6300 if( aPlaneInfoRef.PlaneId > aPlaneId )
6303 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6309 // add clipping planes to actors according to the restored parameters
6310 // and update the clipping plane map
6311 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6312 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6313 int aViewId = anIter1->first;
6314 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6316 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6317 if( anIter2 == aPlaneDataMap.end() )
6319 const TPlaneDataList& aPlaneDataList = anIter2->second;
6321 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6322 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6323 const TPlaneInfo& aPlaneInfo = *anIter3;
6324 int aPlaneId = aPlaneInfo.PlaneId;
6325 const TActorList& anActorList = aPlaneInfo.ActorList;
6326 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6330 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6334 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6336 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6337 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6338 const TPlaneData& aPlaneData = *anIter4;
6339 if( aPlaneData.Id == aPlaneId ) {
6340 SMESH::OrientedPlane* aPlane =
6341 SMESHGUI_ClippingDlg::AddPlane( anActorList,
6343 (SMESH::Orientation)aPlaneData.Orientation,
6344 aPlaneData.Distance,
6347 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6348 aClippingPlaneInfo.Plane = aPlane;
6349 aClippingPlaneInfo.ActorList = anActorList;
6350 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6358 // update all VTK views
6359 QList<SUIT_ViewManager*> lst;
6360 getApp()->viewManagers(lst);
6361 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6362 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6363 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6364 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6365 vtkView->getRenderer()->ResetCameraClippingRange();
6372 \brief Adds preferences for dfont of VTK viewer
6374 \param pIf group identifier
6375 \param param parameter
6376 \return identifier of preferences
6378 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
6380 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6382 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6385 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6386 fam.append( tr( "SMESH_FONT_COURIER" ) );
6387 fam.append( tr( "SMESH_FONT_TIMES" ) );
6389 setPreferenceProperty( tfont, "fonts", fam );
6391 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6392 setPreferenceProperty( tfont, "features", f );
6398 \brief Actions after hypothesis edition
6399 Updates object browser after hypothesis edition
6401 void SMESHGUI::onHypothesisEdit( int result )
6404 SMESHGUI::Modified();
6405 updateObjBrowser( true );
6410 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6411 \param pview view being closed
6413 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6414 #ifndef DISABLE_PLOT2DVIEWER
6415 //Crear all Plot2d Viewers if need.
6416 SMESH::ClearPlot2Viewers(pview);
6420 void SMESHGUI::message( const QString& msg )
6423 QStringList data = msg.split("/");
6424 if ( data.count() > 0 ) {
6425 if ( data.first() == "mesh_loading" ) {
6427 QString entry = data.count() > 1 ? data[1] : QString();
6428 if ( entry.isEmpty() )
6431 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6433 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6436 name = obj->GetName().c_str();
6437 if ( name.isEmpty() )
6440 if ( data.last() == "stop" )
6441 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6443 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6444 QApplication::processEvents();
6450 \brief Connects or disconnects signals about activating and cloning view on the module slots
6451 \param pview view which is connected/disconnected
6453 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6457 SUIT_ViewManager* viewMgr = pview->getViewManager();
6459 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6460 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6462 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6463 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6468 \brief Return \c true if object can be renamed
6470 bool SMESHGUI::renameAllowed( const QString& entry) const {
6471 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6475 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6479 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6484 if(appStudy->isComponent(entry) || obj->isReference())
6487 // check type to prevent renaming of inappropriate objects
6488 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6489 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6490 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6491 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6492 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6493 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6500 Rename object by entry.
6501 \param entry entry of the object
6502 \param name new name of the object
6503 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6505 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6507 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6511 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6516 _PTR(Study) aStudy = appStudy->studyDS();
6521 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6523 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6528 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6529 _PTR(GenericAttribute) anAttr;
6530 _PTR(AttributeName) aName;
6532 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6534 // check type to prevent renaming of inappropriate objects
6535 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6536 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6537 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6538 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6539 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6540 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6541 if ( !name.isEmpty() ) {
6542 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6544 // update name of group object and its actor
6545 Handle(SALOME_InteractiveObject) IObject =
6546 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6548 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6549 if( !aGroupObject->_is_nil() ) {
6550 aGroupObject->SetName( qPrintable(name) );
6551 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6552 anActor->setName( qPrintable(name) );