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 #ifdef WITHGENERICOBJ
361 // obj has been published in study. Its refcount has been incremented.
362 // It is safe to decrement its refcount
363 // so that it will be destroyed when the entry in study will be removed
364 aMeshes[i]->UnRegister();
373 // update Object browser
374 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
376 // browse to the published meshes
377 if( LightApp_Application* anApp =
378 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
379 anApp->browseObjects( anEntryList );
381 // show Error message box if there were errors
382 if ( errors.count() > 0 ) {
383 SUIT_MessageBox::critical( SMESHGUI::desktop(),
384 QObject::tr( "SMESH_ERROR" ),
385 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
388 // show warning message box, if some imported mesh is empty
390 SUIT_MessageBox::warning( SMESHGUI::desktop(),
391 QObject::tr( "SMESH_WRN_WARNING" ),
392 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
397 //================================================================================
399 * \brief Export selected meshes or groups into a file
401 //================================================================================
403 void ExportMeshToFile( int theCommandID )
405 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
406 SALOME_ListIO selected;
408 aSel->selectedObjects( selected );
410 const bool isMED = ( theCommandID == 122 || theCommandID == 125 );
411 const bool isDAT = ( theCommandID == 121 || theCommandID == 124 );
412 const bool isUNV = ( theCommandID == 123 || theCommandID == 126 );
413 const bool isSTL = ( theCommandID == 140 || theCommandID == 141 );
414 const bool isCGNS= ( theCommandID == 142 || theCommandID == 143 );
415 const bool isSAUV= ( theCommandID == 144 || theCommandID == 145 );
416 const bool isGMF = ( theCommandID == 146 || theCommandID == 147 );
418 // actually, the following condition can't be met (added for insurance)
419 if( selected.Extent() == 0 ||
420 ( selected.Extent() > 1 && !isMED && !isSTL ))
423 // get mesh object from selection and check duplication of their names
424 bool hasDuplicatedMeshNames = false;
425 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
426 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
427 SALOME_ListIteratorOfListIO It( selected );
428 for( ; It.More(); It.Next() )
430 Handle(SALOME_InteractiveObject) anIObject = It.Value();
431 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
432 if ( aMeshItem->_is_nil() ) {
433 SUIT_MessageBox::warning( SMESHGUI::desktop(),
434 QObject::tr( "SMESH_WRN_WARNING" ),
435 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
439 QString aMeshName = anIObject->getName();
441 // check for name duplications
442 if ( !hasDuplicatedMeshNames )
443 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
444 if( aMeshName == (*aMeshIter).second ) {
445 hasDuplicatedMeshNames = true;
450 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
453 if( hasDuplicatedMeshNames && isMED ) {
454 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
455 QObject::tr("SMESH_WRN_WARNING"),
456 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
457 QObject::tr("SMESH_BUT_YES"),
458 QObject::tr("SMESH_BUT_NO"), 0, 1);
463 aMeshIter = aMeshList.begin();
464 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
465 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
466 QString aMeshName = (*aMeshIter).second;
468 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
470 // check for equal group names within each mesh
471 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
472 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
473 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
474 int aRet = SUIT_MessageBox::warning
475 (SMESHGUI::desktop(),
476 QObject::tr("SMESH_WRN_WARNING"),
477 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
478 QObject::tr("SMESH_BUT_YES"),
479 QObject::tr("SMESH_BUT_NO"), 0, 1);
486 // Warn the user about presence of not supported elements
488 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
492 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Quadrangle );
493 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
494 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
495 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
496 notSupportedElemTypes.push_back( SMESH::Entity_Tetra );
497 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Tetra );
498 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
499 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
500 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Hexa );
501 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
502 notSupportedElemTypes.push_back( SMESH::Entity_Penta );
503 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
504 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
505 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
506 notSupportedElemTypes.push_back( SMESH::Entity_0D );
507 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
512 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
513 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
514 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
515 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
516 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
517 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
518 notSupportedElemTypes.push_back( SMESH::Entity_0D );
519 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
524 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
525 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
526 notSupportedElemTypes.push_back( SMESH::Entity_0D );
527 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
532 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
537 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
538 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
539 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
540 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
541 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
542 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
547 notSupportedElemTypes.push_back( SMESH::Entity_0D );
548 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Quadrangle );
549 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
550 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
551 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
552 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Hexa );
553 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
554 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
555 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
556 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
557 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
559 if ( ! notSupportedElemTypes.empty() )
561 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
562 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
563 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
564 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
566 if ( !presentNotSupported.empty() )
569 const char* typeMsg[SMESH::Entity_Last] = { "SMESH_NODES",
570 "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES","SMESH_TRIANGLES",
571 "SMESH_QUADRATIC_TRIANGLES","SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES",
572 "SMESH_BIQUADRATIC_QUADRANGLES","SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
573 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
574 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
575 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
576 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
578 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
579 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
580 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
581 if ( iType != presentNotSupported.size() - 1 )
582 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
584 int aRet = SUIT_MessageBox::warning
585 (SMESHGUI::desktop(),
586 QObject::tr("SMESH_WRN_WARNING"),
587 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
588 QObject::tr("SMESH_BUT_YES"),
589 QObject::tr("SMESH_BUT_NO"), 0, 1);
594 // Get parameters of export operation
597 SMESH::MED_VERSION aFormat;
598 // Init the parameters with the default values
599 bool aIsASCII_STL = true;
600 bool toCreateGroups = false;
601 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
603 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
604 bool toOverwrite = true;
606 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
607 QString anInitialPath = "";
608 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
609 anInitialPath = QDir::currentPath();
611 // Get a file name to write in and additional otions
612 if ( isUNV || isDAT || isGMF ) // Export w/o options
615 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
617 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
619 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
620 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
621 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
622 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
623 anInitialPath + QString("/") + aMeshName,
624 aFilter, aTitle, false);
626 // else if ( isGMF )// Export to GMF
628 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
629 // ( SMESHGUI::desktop(), false, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
630 // QStringList filters;
631 // filters << QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)"
632 // << QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
633 // fd->setWindowTitle( aTitle );
634 // fd->setNameFilters( filters );
636 // if ( !aMeshOrGroup->_is_equivalent( aMesh ))
637 // toCreateGroups = false;
639 // toCreateGroups = ( aMesh->NbGroups() > 0 );
641 // fd->SetChecked( true );
642 // if ( !anInitialPath.isEmpty() )
643 // fd->setDirectory( anInitialPath );
644 // fd->selectFile(aMeshName);
647 // aFilename = fd->selectedFile();
648 // toCreateGroups = fd->IsChecked();
652 else if ( isCGNS )// Export to CGNS
654 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
655 fd->setWindowTitle( aTitle );
656 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
657 if ( !anInitialPath.isEmpty() )
658 fd->setDirectory( anInitialPath );
659 fd->selectFile(aMeshName);
660 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
661 fd->setValidator( fv );
664 aFilename = fd->selectedFile();
665 toOverwrite = fv->isOverwrite();
669 else if ( isSTL ) // Export to STL
671 QMap<QString, int> aFilterMap;
672 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
673 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
676 QMap<QString, int>::const_iterator it = aFilterMap.begin();
677 for ( ; it != aFilterMap.end(); ++it )
678 filters.push_back( it.key() );
680 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
681 fd->setWindowTitle( aTitle );
682 fd->setNameFilters( filters );
683 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
684 if ( !anInitialPath.isEmpty() )
685 fd->setDirectory( anInitialPath );
686 fd->selectFile(aMeshName);
690 aFilename = fd->selectedFile();
691 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
696 else if ( isMED || isSAUV ) // Export to MED or SAUV
698 QMap<QString, SMESH::MED_VERSION> aFilterMap;
699 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
701 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
702 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
703 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
706 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
707 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
708 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
712 QString aDefaultFilter;
713 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
714 for ( ; it != aFilterMap.end(); ++it ) {
715 filters.push_back( it.key() );
716 if (it.value() == SMESH::MED_V2_2)
717 aDefaultFilter = it.key();
720 SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
721 ( SMESHGUI::desktop(), false, QObject::tr("SMESH_AUTO_GROUPS"), true, true );
722 fd->setWindowTitle( aTitle );
723 fd->setNameFilters( filters );
724 fd->selectNameFilter(aDefaultFilter);
725 fd->SetChecked(toCreateGroups);
726 if ( !anInitialPath.isEmpty() )
727 fd->setDirectory( anInitialPath );
728 fd->selectFile(aMeshName);
730 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
731 fd->setValidator( fv );
736 aFilename = fd->selectedFile();
738 aFilename = QString::null;
741 aFormat = aFilterMap[fd->selectedNameFilter()];
742 toOverwrite = fv->isOverwrite();
744 if ( !aFilename.isEmpty() ) {
745 // med-2.1 does not support poly elements
746 if ( aFormat==SMESH::MED_V2_1 )
747 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
748 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
749 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
750 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
751 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
753 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
754 QObject::tr("SMESH_WRN_WARNING"),
755 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
756 QObject::tr("SMESH_BUT_YES"),
757 QObject::tr("SMESH_BUT_NO"), 0, 1);
765 // can't append to an existing using other format
766 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
767 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toLatin1().constData(), aVersion );
768 if( !isVersionOk || aVersion != aFormat ) {
769 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
770 QObject::tr("SMESH_WRN_WARNING"),
771 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
772 QObject::tr("SMESH_BUT_YES"),
773 QObject::tr("SMESH_BUT_NO"), 0, 1);
780 QStringList aMeshNamesCollisionList;
781 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toLatin1().constData() );
782 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
783 QString anExistingMeshName( aMeshNames[ i ] );
784 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
785 QString anExportMeshName = (*aMeshIter).second;
786 if( anExportMeshName == anExistingMeshName ) {
787 aMeshNamesCollisionList.append( anExportMeshName );
792 if( !aMeshNamesCollisionList.isEmpty() ) {
793 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
794 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
795 QObject::tr("SMESH_WRN_WARNING"),
796 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
797 QObject::tr("SMESH_BUT_YES"),
798 QObject::tr("SMESH_BUT_NO"),
799 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
808 toCreateGroups = fd->IsChecked();
818 if ( !aFilename.isEmpty() ) {
819 // Check whether the file already exists and delete it if yes
820 QFile aFile( aFilename );
821 if ( aFile.exists() && toOverwrite )
823 SUIT_OverrideCursor wc;
826 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
827 // bool Renumber = false;
828 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
830 // Renumber= resMgr->booleanValue("renumbering");
832 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
833 // aMeshEditor->RenumberNodes();
834 // aMeshEditor->RenumberElements();
835 // if ( SMESHGUI::automaticUpdate() )
836 // SMESH::UpdateView();
840 aMeshIter = aMeshList.begin();
841 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
843 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
844 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
845 if ( aMeshOrGroup->_is_equivalent( aMeshItem ))
846 aMeshItem->ExportToMEDX( aFilename.toLatin1().data(), toCreateGroups,
847 aFormat, toOverwrite && aMeshIndex == 0 );
849 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups,
850 aFormat, toOverwrite && aMeshIndex == 0 );
855 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
857 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
858 if( !aMeshItem->_is_nil() )
859 aMeshItem->ExportSAUV( aFilename.toLatin1().data(), toCreateGroups );
864 if ( aMeshOrGroup->_is_equivalent( aMesh ))
865 aMesh->ExportDAT( aFilename.toLatin1().data() );
867 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toLatin1().data() );
871 if ( aMeshOrGroup->_is_equivalent( aMesh ))
872 aMesh->ExportUNV( aFilename.toLatin1().data() );
874 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toLatin1().data() );
878 if ( aMeshOrGroup->_is_equivalent( aMesh ))
879 aMesh->ExportSTL( aFilename.toLatin1().data(), aIsASCII_STL );
881 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toLatin1().data(), aIsASCII_STL );
885 aMeshIter = aMeshList.begin();
886 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
888 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
889 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
890 aMeshItem->ExportCGNS( aMeshOrGroup,
891 aFilename.toLatin1().data(),
892 toOverwrite && aMeshIndex == 0 );
897 toCreateGroups = true;
898 aMesh->ExportGMF( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups );
901 catch (const SALOME::SALOME_Exception& S_ex){
903 SUIT_MessageBox::warning(SMESHGUI::desktop(),
904 QObject::tr("SMESH_WRN_WARNING"),
905 QObject::tr("SMESH_EXPORT_FAILED"));
911 inline void InverseEntityMode(unsigned int& theOutputMode,
912 unsigned int theMode)
914 bool anIsNotPresent = ~theOutputMode & theMode;
916 theOutputMode |= theMode;
918 theOutputMode &= ~theMode;
921 void SetDisplayEntity(int theCommandID){
922 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
923 SALOME_ListIO selected;
925 aSel->selectedObjects( selected );
927 if(selected.Extent() >= 1){
928 SALOME_ListIteratorOfListIO It( selected );
929 for( ; It.More(); It.Next()){
930 Handle(SALOME_InteractiveObject) IObject = It.Value();
931 if(IObject->hasEntry()){
932 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
933 unsigned int aMode = anActor->GetEntityMode();
934 switch(theCommandID){
936 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
939 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
942 InverseEntityMode(aMode,SMESH_Actor::eEdges);
945 InverseEntityMode(aMode,SMESH_Actor::eFaces);
948 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
951 aMode = SMESH_Actor::eAllEntity;
955 anActor->SetEntityMode(aMode);
963 SALOME_ListIO selected;
964 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
968 LightApp_SelectionMgr* aSel = app->selectionMgr();
969 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
970 if( !aSel || !appStudy )
973 aSel->selectedObjects( selected );
974 if( selected.IsEmpty() )
977 Handle(SALOME_InteractiveObject) anIObject = selected.First();
979 _PTR(Study) aStudy = appStudy->studyDS();
980 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
981 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
982 if( aMainObject->_is_nil() )
985 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
987 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
988 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
990 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
991 SALOMEDS::Color aColor = aGroupObject->GetColor();
992 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
996 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
997 switch ( aGroupObject->GetType ()) {
999 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1001 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1003 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1005 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1007 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1008 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1011 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1012 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1018 SMESH::RepaintCurrentView();
1021 QString functorToString( SMESH::Controls::FunctorPtr f )
1023 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1024 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1025 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1026 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1027 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1028 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1029 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1030 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1031 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1032 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1033 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1034 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1035 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1036 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1037 type = QObject::tr( "WARP_ELEMENTS" );
1038 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1039 type = QObject::tr( "TAPER_ELEMENTS" );
1040 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1041 type = QObject::tr( "SKEW_ELEMENTS" );
1042 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1043 type = QObject::tr( "AREA_ELEMENTS" );
1044 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1045 type = QObject::tr( "LENGTH_EDGES" );
1046 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1047 type = QObject::tr( "LENGTH2D_EDGES" );
1048 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1049 type = QObject::tr( "MULTI_BORDERS" );
1050 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1051 type = QObject::tr( "MULTI2D_BORDERS" );
1052 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1053 type = QObject::tr( "FREE_NODES" );
1054 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1055 type = QObject::tr( "FREE_EDGES" );
1056 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1057 type = QObject::tr( "FREE_BORDERS" );
1058 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1059 type = QObject::tr( "FREE_FACES" );
1060 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1061 type = QObject::tr( "BARE_BORDER_VOLUME" );
1062 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1063 type = QObject::tr( "BARE_BORDER_FACE" );
1064 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1065 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1066 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1067 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1068 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1069 type = QObject::tr( "EQUAL_NODE" );
1070 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1071 type = QObject::tr( "EQUAL_EDGE" );
1072 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1073 type = QObject::tr( "EQUAL_FACE" );
1074 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1075 type = QObject::tr( "EQUAL_VOLUME" );
1079 void SaveDistribution()
1081 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1082 SALOME_ListIO selected;
1084 aSel->selectedObjects( selected );
1086 if ( selected.Extent() == 1 ) {
1087 Handle(SALOME_InteractiveObject) anIO = selected.First();
1088 if ( anIO->hasEntry() ) {
1089 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1090 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1091 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1092 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1093 if ( aScalarBarActor && aFunctor ) {
1094 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1096 std::vector<int> elements;
1097 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1098 if ( mesh->_is_nil() ) {
1099 SMESH::SMESH_IDSource_var idSource =
1100 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1101 if ( !idSource->_is_nil() )
1103 SMESH::long_array_var ids = idSource->GetIDs();
1104 elements.resize( ids->length() );
1105 for ( unsigned i = 0; i < elements.size(); ++i )
1106 elements[i] = ids[i];
1109 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1110 vtkLookupTable* lookupTable =
1111 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1112 double * minmax = lookupTable->GetRange();
1113 std::vector<int> nbEvents;
1114 std::vector<double> funValues;
1115 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax );
1116 QString anInitialPath = "";
1117 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1118 anInitialPath = QDir::currentPath();
1119 QString aMeshName = anIO->getName();
1121 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1122 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1123 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1124 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1125 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1128 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1130 if ( !aFilename.isEmpty() ) {
1131 QFile f( aFilename );
1132 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1133 QTextStream out( &f );
1134 out << "# Mesh: " << aMeshName << endl;
1135 out << "# Control: " << functorToString( aFunctor ) << endl;
1137 out.setFieldWidth( 10 );
1138 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1139 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1150 void ShowDistribution() {
1151 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1152 SALOME_ListIO selected;
1154 aSel->selectedObjects( selected );
1156 if ( selected.Extent() == 1 ) {
1157 Handle(SALOME_InteractiveObject) anIO = selected.First();
1158 if ( anIO->hasEntry() ) {
1159 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1160 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1161 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1162 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1168 #ifndef DISABLE_PLOT2DVIEWER
1169 void PlotDistribution() {
1170 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1174 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1175 SALOME_ListIO selected;
1177 aSel->selectedObjects( selected );
1179 if ( selected.Extent() == 1 ) {
1180 Handle(SALOME_InteractiveObject) anIO = selected.First();
1181 if ( anIO->hasEntry() ) {
1182 //Find Actor by entry before getting Plot2d viewer,
1183 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1184 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1186 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1191 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1195 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1199 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1200 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1201 QString functorName = functorToString( anActor->GetFunctor());
1202 QString aHistogramName("%1 : %2");
1203 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1204 aHistogram->setName(aHistogramName);
1205 aHistogram->setHorTitle(functorName);
1206 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1207 aPlot->displayObject(aHistogram, true);
1212 #endif //DISABLE_PLOT2DVIEWER
1214 void DisableAutoColor(){
1215 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1216 SALOME_ListIO selected;
1218 aSel->selectedObjects( selected );
1220 if(selected.Extent()){
1221 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1222 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1223 if ( !aMesh->_is_nil() ) {
1224 aMesh->SetAutoColor( false );
1229 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1231 SALOME_ListIO selected;
1232 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1236 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1237 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1238 if( !aSel || !appStudy )
1241 if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection
1242 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1243 aModule->EmitSignalDeactivateDialog();
1244 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1245 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1250 _PTR(Study) aStudy = appStudy->studyDS();
1252 aSel->selectedObjects( selected );
1254 if(selected.Extent() >= 1){
1255 switch(theCommandID){
1257 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1258 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1262 vtkFloatingPointType color[3];
1263 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1264 QColor orientationColor, outlineColor, volumeColor;
1265 int deltaF = 0, deltaV = 0;
1269 int outlineWidth = 1;
1270 vtkFloatingPointType shrinkCoef = 0.0;
1271 vtkFloatingPointType orientationScale = 0.0;
1272 bool orientation3d = false;
1273 VTK::MarkerType markerType = VTK::MT_NONE;
1274 VTK::MarkerScale markerScale = VTK::MS_NONE;
1276 bool hasNodes = false;
1277 int presentEntities = 0;
1278 bool firstTime = true;
1280 SALOME_ListIteratorOfListIO It( selected );
1281 for ( ; It.More(); It.Next() ) {
1282 Handle(SALOME_InteractiveObject) IObject = It.Value();
1283 if ( !IObject->hasEntry() ) continue;
1284 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1285 if ( !anActor || !anActor->GetObject() ) continue;
1288 // nodes: color, marker
1289 anActor->GetNodeColor( color[0], color[1], color[2] );
1290 nodeColor.setRgbF( color[0], color[1], color[2] );
1291 markerType = anActor->GetMarkerType();
1292 markerScale = anActor->GetMarkerScale();
1293 markerId = anActor->GetMarkerTexture();
1294 // edges: color, width
1295 anActor->GetEdgeColor( color[0], color[1], color[2] );
1296 edgeColor.setRgbF( color[0], color[1], color[2] );
1297 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1298 // faces: front color, back color (delta)
1299 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1300 faceColor.setRgbF( color[0], color[1], color[2] );
1301 // faces: front color, back color (delta)
1302 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1303 volumeColor.setRgbF( color[0], color[1], color[2] );
1304 // 0d elements: color, size
1305 anActor->Get0DColor( color[0], color[1], color[2] );
1306 elem0dColor.setRgbF( color[0], color[1], color[2] );
1307 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1308 // balls: color, size
1309 anActor->GetBallColor( color[0], color[1], color[2] );
1310 ballColor.setRgbF( color[0], color[1], color[2] );
1311 ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1313 anActor->GetOutlineColor( color[0], color[1], color[2] );
1314 outlineColor.setRgbF( color[0], color[1], color[2] );
1315 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1316 // orientation vectors: color, scale, 3d flag
1317 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1318 orientationColor.setRgbF( color[0], color[1], color[2] );
1319 orientationScale = anActor->GetFacesOrientationScale();
1320 orientation3d = anActor->GetFacesOrientation3DVectors();
1322 shrinkCoef = anActor->GetShrinkFactor();
1325 firstTime = false; // we only take properties from first object (for performance reasons)
1328 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1329 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1330 presentEntities = presentEntities | SMESH_Actor::eEdges;
1331 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1332 presentEntities = presentEntities | SMESH_Actor::eFaces;
1333 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1334 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1335 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1336 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1337 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1338 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1340 // as we know that all types of elements are present, we can exit the loop
1341 if ( presentEntities == SMESH_Actor::eAllEntity )
1345 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1346 // nodes: color, marker
1347 dlg.setNodeColor( nodeColor );
1348 if( markerType != VTK::MT_USER )
1349 dlg.setNodeMarker( markerType, markerScale );
1351 dlg.setNodeCustomMarker( markerId );
1352 // edges: color, line width
1353 dlg.setEdgeColor( edgeColor );
1354 dlg.setEdgeWidth( edgeWidth );
1355 // faces: front color, back color
1356 dlg.setFaceColor( faceColor, deltaF );
1357 // volumes: normal color, reversed color
1358 dlg.setVolumeColor( volumeColor, deltaV );
1359 // outlines: color, line width
1360 dlg.setOutlineColor( outlineColor );
1361 dlg.setOutlineWidth( outlineWidth );
1362 // 0d elements: color, size
1363 dlg.setElem0dColor( elem0dColor );
1364 dlg.setElem0dSize( elem0dSize );
1365 // balls: color, size
1366 dlg.setBallColor( ballColor );
1367 dlg.setBallSize( ballSize );
1368 // orientation: color, scale, 3d flag
1369 dlg.setOrientationColor( orientationColor );
1370 dlg.setOrientationSize( int( orientationScale * 100. ) );
1371 dlg.setOrientation3d( orientation3d );
1372 // shrink: scale factor
1373 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1374 // hide unused controls
1375 dlg.showControls( presentEntities, hasNodes );
1378 nodeColor = dlg.nodeColor();
1379 markerType = dlg.nodeMarkerType();
1380 markerScale = dlg.nodeMarkerScale();
1381 markerId = dlg.nodeMarkerId();
1382 edgeColor = dlg.edgeColor();
1383 edgeWidth = dlg.edgeWidth();
1384 faceColor = dlg.faceColor();
1385 deltaF = dlg.faceColorDelta();
1386 volumeColor = dlg.volumeColor();
1387 deltaV = dlg.volumeColorDelta();
1388 outlineColor = dlg.outlineColor();
1389 outlineWidth = dlg.outlineWidth();
1390 elem0dColor = dlg.elem0dColor();
1391 elem0dSize = dlg.elem0dSize();
1392 ballColor = dlg.ballColor();
1393 ballSize = dlg.ballSize();
1394 orientationColor = dlg.orientationColor();
1395 orientationScale = dlg.orientationSize() / 100.;
1396 orientation3d = dlg.orientation3d();
1397 shrinkCoef = dlg.shrinkCoef() / 100.;
1399 // store point markers map that might be changed by the user
1400 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1402 // set properties from dialog box to the presentations
1403 SALOME_ListIteratorOfListIO It( selected );
1404 for ( ; It.More(); It.Next() ) {
1405 Handle(SALOME_InteractiveObject) IObject = It.Value();
1406 if ( !IObject->hasEntry() ) continue;
1407 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1408 if ( !anActor ) continue;
1410 // nodes: color, marker
1411 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1412 if ( markerType != VTK::MT_USER ) {
1413 anActor->SetMarkerStd( markerType, markerScale );
1416 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1417 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1418 if ( iter != markerMap.end() )
1419 anActor->SetMarkerTexture( markerId, iter->second.second );
1421 // volumes: normal color, reversed color (delta)
1422 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1423 // faces: front color, back color (delta)
1424 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1425 // edges: color, width
1426 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1427 anActor->SetLineWidth( edgeWidth );
1429 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1430 anActor->SetOutlineWidth( outlineWidth );
1431 // 0D elements: color, size
1432 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1433 anActor->Set0DSize( elem0dSize );
1434 // balls: color, size
1435 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1436 anActor->SetBallSize( ballSize );
1437 // orientation: color, scale, 3d flag
1438 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1439 anActor->SetFacesOrientationScale( orientationScale );
1440 anActor->SetFacesOrientation3DVectors( orientation3d );
1442 anActor->SetShrinkFactor( shrinkCoef );
1444 // for groups, set also proper color
1445 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1446 if ( !aGroupObject->_is_nil() ) {
1447 SMESH::ElementType anElementType = aGroupObject->GetType();
1449 switch( anElementType ) {
1451 aColor = nodeColor; break;
1453 aColor = edgeColor; break;
1455 aColor = faceColor; break;
1457 aColor = volumeColor; break;
1459 aColor = elem0dColor; break;
1461 aColor = ballColor; break;
1465 if ( aColor.isValid() ) {
1466 SALOMEDS::Color aGroupColor;
1467 aGroupColor.R = aColor.redF();
1468 aGroupColor.G = aColor.greenF();
1469 aGroupColor.B = aColor.blueF();
1470 aGroupObject->SetColor( aGroupColor );
1472 } // if ( !aGroupObject->_is_nil() )
1473 } // for ( ; It.More(); It.Next() )
1474 SMESH::RepaintCurrentView();
1475 } // if ( dlg.exec() )
1478 } // switch(theCommandID)
1479 SALOME_ListIteratorOfListIO It( selected );
1480 for( ; It.More(); It.Next()){
1481 Handle(SALOME_InteractiveObject) IObject = It.Value();
1482 if(IObject->hasEntry()){
1483 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1484 switch(theCommandID){
1486 anActor->SetRepresentation(SMESH_Actor::eEdge);
1489 anActor->SetRepresentation(SMESH_Actor::eSurface);
1492 if(anActor->IsShrunk())
1493 anActor->UnShrink();
1495 anActor->SetShrink();
1498 anActor->SetRepresentation(SMESH_Actor::ePoint);
1501 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1502 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1505 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1506 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1512 SMESH::RepaintCurrentView();
1516 void Control( int theCommandID )
1518 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1519 SALOME_ListIO selected;
1521 aSel->selectedObjects( selected );
1523 if( !selected.IsEmpty() ){
1524 Handle(SALOME_InteractiveObject) anIO = selected.First();
1526 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1527 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1528 switch ( theCommandID ){
1530 aControl = SMESH_Actor::eLength;
1533 aControl = SMESH_Actor::eLength2D;
1536 aControl = SMESH_Actor::eFreeEdges;
1539 aControl = SMESH_Actor::eFreeBorders;
1542 aControl = SMESH_Actor::eMultiConnection;
1545 aControl = SMESH_Actor::eFreeNodes;
1548 aControl = SMESH_Actor::eMultiConnection2D;
1551 aControl = SMESH_Actor::eArea;
1554 aControl = SMESH_Actor::eTaper;
1557 aControl = SMESH_Actor::eAspectRatio;
1560 aControl = SMESH_Actor::eAspectRatio3D;
1563 aControl = SMESH_Actor::eMinimumAngle;
1566 aControl = SMESH_Actor::eWarping;
1569 aControl = SMESH_Actor::eSkew;
1572 aControl = SMESH_Actor::eVolume3D;
1575 aControl = SMESH_Actor::eFreeFaces;
1578 aControl = SMESH_Actor::eMaxElementLength2D;
1581 aControl = SMESH_Actor::eMaxElementLength3D;
1584 aControl = SMESH_Actor::eBareBorderVolume;
1587 aControl = SMESH_Actor::eBareBorderFace;
1590 aControl = SMESH_Actor::eOverConstrainedVolume;
1593 aControl = SMESH_Actor::eOverConstrainedFace;
1596 aControl = SMESH_Actor::eCoincidentNodes;
1599 aControl = SMESH_Actor::eCoincidentElems1D;
1602 aControl = SMESH_Actor:: eCoincidentElems2D;
1605 aControl = SMESH_Actor::eCoincidentElems3D;
1609 anActor->SetControlMode(aControl);
1610 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1611 SMESH::RepaintCurrentView();
1612 #ifndef DISABLE_PLOT2DVIEWER
1613 if(anActor->GetPlot2Histogram()) {
1614 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1615 QString functorName = functorToString( anActor->GetFunctor());
1616 QString aHistogramName("%1 : %2");
1617 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1618 aHistogram->setName(aHistogramName);
1619 aHistogram->setHorTitle(functorName);
1620 SMESH::ProcessIn2DViewers(anActor);
1629 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1630 SMESH::MeshObjectType theType,
1631 const QString theInTypeName,
1632 QString & theOutTypeName)
1634 SMESH_TypeFilter aTypeFilter( theType );
1636 if( !theIO.IsNull() )
1638 entry = theIO->getEntry();
1639 LightApp_DataOwner owner( entry );
1640 if ( aTypeFilter.isOk( &owner )) {
1641 theOutTypeName = theInTypeName;
1649 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1651 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1652 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1654 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1655 CORBA::String_var anID = aSComp->GetID().c_str();
1656 if (!strcmp(anID.in(),theIO->getEntry()))
1662 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1663 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1664 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1665 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1666 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1674 QString CheckHomogeneousSelection()
1676 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1677 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1678 SALOME_ListIO selected;
1680 aSel->selectedObjects( selected );
1682 QString RefType = CheckTypeObject(selected.First());
1683 SALOME_ListIteratorOfListIO It(selected);
1684 for ( ; It.More(); It.Next())
1686 Handle(SALOME_InteractiveObject) IObject = It.Value();
1687 QString Type = CheckTypeObject(IObject);
1688 if (Type.compare(RefType) != 0)
1689 return "Heterogeneous Selection";
1696 void SMESHGUI::OnEditDelete()
1698 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1699 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1700 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1702 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1703 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1704 _PTR(GenericAttribute) anAttr;
1705 _PTR(AttributeIOR) anIOR;
1707 int objectCount = 0;
1709 QString aParentComponent = QString::null;
1710 Handle(SALOME_InteractiveObject) anIO;
1711 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1713 anIO = anIt.Value();
1714 QString cur = anIO->getComponentDataType();
1715 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1717 // check if object is reference
1718 _PTR(SObject) aRefSObj;
1719 aNameList.append("\n - ");
1720 if ( aSO->ReferencedObject( aRefSObj ) ) {
1721 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1722 aNameList.append( aRefName );
1723 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1726 aNameList.append(anIO->getName());
1730 if( aParentComponent.isNull() )
1731 aParentComponent = cur;
1732 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1733 aParentComponent = "";
1736 if ( objectCount == 0 )
1737 return; // No Valid Objects Selected
1739 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1740 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1741 QObject::tr("ERR_ERROR"),
1742 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1745 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1746 if (SUIT_MessageBox::warning
1747 (SMESHGUI::desktop(),
1748 QObject::tr("SMESH_WRN_WARNING"),
1749 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1750 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1751 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1754 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1756 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1757 // then treat them all starting from the deepest objects (at list back)
1758 std::list< _PTR(SObject) > listSO;
1759 SALOME_ListIteratorOfListIO It(selected);
1760 for( ; It.More(); It.Next()) // loop on selected IO's
1762 Handle(SALOME_InteractiveObject) IObject = It.Value();
1763 if(IObject->hasEntry()) {
1764 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1766 // disable removal of "SMESH" component object
1767 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1769 if ( engineIOR() == anIOR->Value().c_str() )
1772 //Check the referenced object
1773 _PTR(SObject) aRefSObject;
1774 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1775 aSO = aRefSObject; // Delete main Object instead of reference
1777 listSO.push_back( aSO );
1778 std::list< _PTR(SObject) >::iterator itSO = listSO.begin();
1779 for ( ; itSO != listSO.end(); ++itSO ) {
1780 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1781 for (it->InitEx(false); it->More(); it->Next())
1782 listSO.push_back( it->Value() );
1786 // Check if none of objects to delete is referred from outside
1787 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1788 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1790 _PTR(SObject) SO = *ritSO;
1791 if ( !SO ) continue;
1792 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1793 for (size_t i = 0; i < aReferences.size(); i++) {
1794 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1795 std::string type = aComponent->ComponentDataType();
1796 if ( type != "SMESH" )
1798 SUIT_MessageBox::warning( anApp->desktop(),
1799 QObject::tr("WRN_WARNING"),
1800 QObject::tr("DEP_OBJECT") );
1801 return; // outside SMESH, there is an object depending on a SMESH object
1806 // Treat SO's in the list starting from the back
1807 aStudyBuilder->NewCommand(); // There is a transaction
1808 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1810 _PTR(SObject) SO = *ritSO;
1811 if ( !SO ) continue;
1812 std::string anEntry = SO->GetID();
1814 /** Erase graphical object **/
1815 if(SO->FindAttribute(anAttr, "AttributeIOR")){
1816 ViewManagerList aViewMenegers = anApp->viewManagers();
1817 ViewManagerList::const_iterator it = aViewMenegers.begin();
1818 for( ; it != aViewMenegers.end(); it++) {
1819 SUIT_ViewManager* vm = *it;
1820 int nbSf = vm ? vm->getViewsCount() : 0;
1822 QVector<SUIT_ViewWindow*> aViews = vm->getViews();
1823 for(int i = 0; i < nbSf; i++){
1824 SUIT_ViewWindow *sf = aViews[i];
1825 if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
1826 SMESH::RemoveActor(sf,anActor);
1832 /** Remove an object from data structures **/
1833 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1834 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1835 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1836 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1837 aMesh->RemoveGroup( aGroup );
1839 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1840 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1841 aMesh->RemoveSubMesh( aSubMesh );
1843 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1845 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1848 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1849 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1850 QString objType = CheckTypeObject(IObject);
1851 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1852 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1853 aStudyBuilder->RemoveObjectWithChildren( SO );
1855 else {// default action: remove SObject from the study
1856 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1857 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1859 aStudyBuilder->RemoveObjectWithChildren( SO );
1863 } /* listSO back loop */
1865 aStudyBuilder->CommitCommand();
1867 /* Clear any previous selection */
1869 aSel->setSelectedObjects( l1 );
1871 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1876 SMESHGUI_EXPORT CAM_Module* createModule()
1878 return new SMESHGUI();
1881 SMESHGUI_EXPORT char* getModuleVersion() {
1882 return (char*)SMESH_VERSION_STR;
1886 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1888 //=============================================================================
1892 //=============================================================================
1893 SMESHGUI::SMESHGUI() :
1894 SalomeApp_Module( "SMESH" ),
1895 LightApp_Module( "SMESH" )
1897 if ( CORBA::is_nil( myComponentSMESH ) )
1899 CORBA::Boolean anIsEmbeddedMode;
1900 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1901 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1903 // 0019923: EDF 765 SMESH : default values of hypothesis
1904 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1905 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1906 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1907 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1908 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1910 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1911 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1912 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1914 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1915 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1919 myActiveDialogBox = 0;
1920 myFilterLibraryDlg = 0;
1924 myEventCallbackCommand = vtkCallbackCommand::New();
1925 myEventCallbackCommand->Delete();
1926 myEventCallbackCommand->SetClientData( this );
1927 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1930 SMESH::GetFilterManager();
1931 SMESH::GetPattern();
1932 SMESH::GetMeasurements();
1934 /* load resources for all available meshers */
1935 SMESH::InitAvailableHypotheses();
1938 //=============================================================================
1942 //=============================================================================
1943 SMESHGUI::~SMESHGUI()
1945 #ifdef WITHGENERICOBJ
1946 SMESH::GetFilterManager()->UnRegister();
1947 SMESH::GetMeasurements()->UnRegister();
1949 SMESH::GetFilterManager() = SMESH::FilterManager::_nil();
1950 SMESH::GetMeasurements() = SMESH::Measurements::_nil();
1953 //=============================================================================
1957 //=============================================================================
1958 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1960 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1962 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1967 //=============================================================================
1971 //=============================================================================
1972 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1974 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1978 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
1979 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1980 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
1981 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
1982 return autoUpdate && !exceeded;
1985 //=============================================================================
1989 //=============================================================================
1990 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
1992 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
1995 //=============================================================================
1999 //=============================================================================
2000 SMESHGUI* SMESHGUI::GetSMESHGUI()
2002 SMESHGUI* smeshMod = 0;
2003 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2006 CAM_Module* module = app->module( "Mesh" );
2007 smeshMod = dynamic_cast<SMESHGUI*>( module );
2010 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2012 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2015 _PTR(Study) aStudy = study->studyDS();
2017 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2026 Standard_EXPORT SMESHGUI* GetComponentGUI()
2028 return SMESHGUI::GetSMESHGUI();
2032 //=============================================================================
2036 //=============================================================================
2037 void SMESHGUI::SetState(int aState)
2042 //=============================================================================
2046 //=============================================================================
2047 void SMESHGUI::ResetState()
2052 //=============================================================================
2056 //=============================================================================
2057 void SMESHGUI::EmitSignalDeactivateDialog()
2059 emit SignalDeactivateActiveDialog();
2062 //=============================================================================
2066 //=============================================================================
2067 void SMESHGUI::EmitSignalStudyFrameChanged()
2069 emit SignalStudyFrameChanged();
2072 //=============================================================================
2076 //=============================================================================
2077 void SMESHGUI::EmitSignalCloseAllDialogs()
2079 emit SignalCloseAllDialogs();
2082 //=============================================================================
2086 //=============================================================================
2087 void SMESHGUI::EmitSignalVisibilityChanged()
2089 emit SignalVisibilityChanged();
2092 //=============================================================================
2096 //=============================================================================
2097 QDialog *SMESHGUI::GetActiveDialogBox()
2099 return myActiveDialogBox;
2102 //=============================================================================
2106 //=============================================================================
2107 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2109 myActiveDialogBox = (QDialog *) aDlg;
2113 //=============================================================================
2117 //=============================================================================
2118 SUIT_Desktop* SMESHGUI::desktop()
2120 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2122 return app->desktop();
2127 //=============================================================================
2131 //=============================================================================
2132 SalomeApp_Study* SMESHGUI::activeStudy()
2134 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2136 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2141 //=============================================================================
2145 //=============================================================================
2146 void SMESHGUI::Modified( bool theIsUpdateActions )
2148 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2149 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2150 appStudy->Modified();
2151 if( theIsUpdateActions )
2152 app->updateActions();
2157 //=============================================================================
2161 //=============================================================================
2162 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2164 /* Here the position is on the bottom right corner - 10 */
2165 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2167 SUIT_Desktop *PP = desktop();
2168 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2169 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2173 //=============================================================================
2177 //=============================================================================
2178 static int isStudyLocked(_PTR(Study) theStudy){
2179 return theStudy->GetProperties()->IsLocked();
2182 static bool checkLock(_PTR(Study) theStudy) {
2183 if (isStudyLocked(theStudy)) {
2184 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2185 QObject::tr("WRN_WARNING"),
2186 QObject::tr("WRN_STUDY_LOCKED") );
2192 //=======================================================================
2193 //function : CheckActiveStudyLocked
2195 //=======================================================================
2197 bool SMESHGUI::isActiveStudyLocked()
2199 _PTR(Study) aStudy = activeStudy()->studyDS();
2200 return checkLock( aStudy );
2203 //=============================================================================
2207 //=============================================================================
2208 bool SMESHGUI::OnGUIEvent( int theCommandID )
2210 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2214 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2215 SUIT_ResourceMgr* mgr = resourceMgr();
2219 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2220 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2223 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2224 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2226 //QAction* act = action( theCommandID );
2228 switch (theCommandID) {
2230 if(checkLock(aStudy)) break;
2242 if(checkLock(aStudy)) break;
2243 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2247 case 150: //MED FILE INFORMATION
2249 SALOME_ListIO selected;
2250 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2252 aSel->selectedObjects( selected );
2253 if( selected.Extent() )
2255 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2256 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2257 if ( !aMesh->_is_nil() )
2259 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2266 case 122: // EXPORT MED
2281 ::ExportMeshToFile(theCommandID);
2285 case 200: // SCALAR BAR
2287 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2288 SALOME_ListIO selected;
2290 aSel->selectedObjects( selected );
2292 if( selected.Extent() ) {
2293 Handle(SALOME_InteractiveObject) anIO = selected.First();
2294 if( anIO->hasEntry() ) {
2295 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2296 anActor->SetControlMode( SMESH_Actor::eNone );
2297 #ifndef DISABLE_PLOT2DVIEWER
2298 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2307 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2312 // dump control distribution data to the text file
2313 ::SaveDistribution();
2319 // show/ distribution
2320 ::ShowDistribution();
2324 #ifndef DISABLE_PLOT2DVIEWER
2327 // plot distribution
2328 ::PlotDistribution();
2339 ::DisableAutoColor();
2342 case 1134: // Clipping
2343 case 1133: // Tranparency
2344 case 1132: // Display preferences (colors, shrink size, line width, ...)
2351 ::SetDisplayMode(theCommandID, myMarkerMap);
2354 //2D quadratic representation
2357 ::SetDisplayMode(theCommandID, myMarkerMap);
2361 case 216: // 0D elements
2364 case 219: // Volumes
2365 case 220: // All Entity
2367 ::SetDisplayEntity(theCommandID);
2370 case 221: // Orientation of faces
2372 LightApp_SelectionMgr* mgr = selectionMgr();
2373 SALOME_ListIO selected; mgr->selectedObjects( selected );
2375 SALOME_ListIteratorOfListIO it(selected);
2376 for( ; it.More(); it.Next()) {
2377 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2378 if(anIObject->hasEntry()) {
2379 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2380 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2389 if(checkLock(aStudy)) break;
2391 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2394 SMESH::UpdateView();
2396 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2397 SMESH::OnVisuException();
2399 catch (...) { // PAL16774 (Crash after display of many groups)
2400 SMESH::OnVisuException();
2404 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2405 aSel->selectedObjects( l );
2406 aSel->setSelectedObjects( l );
2411 case 301: // DISPLAY
2412 case 302: // DISPLAY ONLY
2414 SMESH::EDisplaing anAction;
2415 switch (theCommandID) {
2416 case 300: anAction = SMESH::eErase; break;
2417 case 301: anAction = SMESH::eDisplay; break;
2418 case 302: anAction = SMESH::eDisplayOnly; break;
2421 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2422 SALOME_ListIO sel_objects, to_process;
2424 aSel->selectedObjects( sel_objects );
2426 if( theCommandID==302 )
2428 MESSAGE("anAction = SMESH::eDisplayOnly");
2429 startOperation( myEraseAll );
2432 extractContainers( sel_objects, to_process );
2435 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2439 SALOME_ListIteratorOfListIO It( to_process );
2440 for ( ; It.More(); It.Next()) {
2442 Handle(SALOME_InteractiveObject) IOS = It.Value();
2443 if (IOS->hasEntry()) {
2445 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2446 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2447 break; // PAL16774 (Crash after display of many groups)
2449 if (anAction == SMESH::eDisplayOnly)
2451 MESSAGE("anAction = SMESH::eDisplayOnly");
2452 anAction = SMESH::eDisplay;
2458 // PAL13338 + PAL15161 -->
2459 if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2460 MESSAGE("anAction = SMESH::eDisplayOnly");
2461 SMESH::UpdateView();
2462 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2464 // PAL13338 + PAL15161 <--
2466 catch (...) { // PAL16774 (Crash after display of many groups)
2467 SMESH::OnVisuException();
2470 if (anAction == SMESH::eErase) {
2471 MESSAGE("anAction == SMESH::eErase");
2473 aSel->setSelectedObjects( l1 );
2476 aSel->setSelectedObjects( to_process );
2483 if(checkLock(aStudy)) break;
2486 EmitSignalDeactivateDialog();
2488 ( new SMESHGUI_NodesDlg( this ) )->show();
2491 SUIT_MessageBox::warning(desktop(),
2492 tr("SMESH_WRN_WARNING"),
2493 tr("SMESH_WRN_VIEWER_VTK"));
2498 case 2151: // FILTER
2502 EmitSignalDeactivateDialog();
2503 ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2508 case 701: // COMPUTE MESH
2509 case 711: // PRECOMPUTE MESH
2510 case 712: // EVALUATE MESH
2511 case 713: // MESH ORDER
2512 case 702: // Create mesh
2513 case 703: // Create sub-mesh
2514 case 704: // Edit mesh/sub-mesh
2515 startOperation( theCommandID );
2517 case 705: // copy mesh
2519 if (checkLock(aStudy)) break;
2520 EmitSignalDeactivateDialog();
2521 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2524 case 710: // Build compound mesh
2526 if (checkLock(aStudy)) break;
2527 EmitSignalDeactivateDialog();
2528 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2532 case 407: // DIAGONAL INVERSION
2533 case 408: // Delete diagonal
2537 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2538 tr( "NOT_A_VTK_VIEWER" ) );
2542 if ( checkLock( aStudy ) )
2545 /*Standard_Boolean aRes;
2546 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2547 if ( aMesh->_is_nil() )
2549 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2550 tr( "SMESH_BAD_SELECTION" ) );
2554 EmitSignalDeactivateDialog();
2555 if ( theCommandID == 407 )
2556 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2558 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2561 case 409: // Change orientation
2562 case 410: // Union of triangles
2563 case 411: // Cutting of quadrangles
2564 case 419: // Splitting volumes into tetrahedra
2568 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2569 tr( "NOT_A_VTK_VIEWER" ) );
2573 if ( checkLock( aStudy ) )
2576 EmitSignalDeactivateDialog();
2577 SMESHGUI_MultiEditDlg* aDlg = NULL;
2578 if ( theCommandID == 409 )
2579 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2580 else if ( theCommandID == 410 )
2581 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2582 else if ( theCommandID == 419 )
2583 aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2585 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2590 case 412: // Smoothing
2592 if(checkLock(aStudy)) break;
2594 EmitSignalDeactivateDialog();
2595 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2598 SUIT_MessageBox::warning(desktop(),
2599 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2603 case 413: // Extrusion
2605 if (checkLock(aStudy)) break;
2607 EmitSignalDeactivateDialog();
2608 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2610 SUIT_MessageBox::warning(desktop(),
2611 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2615 case 414: // Revolution
2617 if(checkLock(aStudy)) break;
2619 EmitSignalDeactivateDialog();
2620 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2623 SUIT_MessageBox::warning(desktop(),
2624 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2628 case 415: // Pattern mapping
2630 if ( checkLock( aStudy ) )
2634 EmitSignalDeactivateDialog();
2635 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2638 SUIT_MessageBox::warning(desktop(),
2639 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2643 case 416: // Extrusion along a path
2645 if (checkLock(aStudy)) break;
2647 EmitSignalDeactivateDialog();
2648 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2650 SUIT_MessageBox::warning(desktop(),
2651 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2655 case 417: // Convert mesh to quadratic
2656 case 418: // create 2D mesh from 3D
2657 case 420: // Reorient faces
2658 case 806: // CREATE GEO GROUP
2660 startOperation( theCommandID );
2663 case 801: // CREATE GROUP
2667 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2668 tr( "NOT_A_VTK_VIEWER" ) );
2672 if(checkLock(aStudy)) break;
2673 EmitSignalDeactivateDialog();
2674 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2676 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2677 SALOME_ListIO selected;
2679 aSel->selectedObjects( selected );
2681 int nbSel = selected.Extent();
2683 // check if mesh is selected
2684 aMesh = SMESH::GetMeshByIO( selected.First() );
2686 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2691 case 802: // CONSTRUCT GROUP
2695 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2696 tr( "NOT_A_VTK_VIEWER" ) );
2700 if(checkLock(aStudy)) break;
2701 EmitSignalDeactivateDialog();
2703 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2704 SALOME_ListIO selected;
2706 aSel->selectedObjects( selected );
2708 int nbSel = selected.Extent();
2710 // check if submesh is selected
2711 Handle(SALOME_InteractiveObject) IObject = selected.First();
2712 if (IObject->hasEntry()) {
2713 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2715 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2716 if (!aSubMesh->_is_nil()) {
2718 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2719 // get submesh elements list by types
2720 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2721 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2722 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2723 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2724 // create group for each type o elements
2725 QString aName = IObject->getName();
2726 QStringList anEntryList;
2727 if (aNodes->length() > 0) {
2728 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2729 aGroup->Add(aNodes.inout());
2730 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2731 anEntryList.append( aSObject->GetID().c_str() );
2733 if (aEdges->length() > 0) {
2734 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2735 aGroup->Add(aEdges.inout());
2736 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2737 anEntryList.append( aSObject->GetID().c_str() );
2739 if (aFaces->length() > 0) {
2740 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2741 aGroup->Add(aFaces.inout());
2742 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2743 anEntryList.append( aSObject->GetID().c_str() );
2745 if (aVolumes->length() > 0) {
2746 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2747 aGroup->Add(aVolumes.inout());
2748 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2749 anEntryList.append( aSObject->GetID().c_str() );
2752 anApp->browseObjects( anEntryList );
2754 catch(const SALOME::SALOME_Exception & S_ex){
2755 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2762 SUIT_MessageBox::warning(desktop(),
2763 tr("SMESH_WRN_WARNING"),
2764 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2769 case 803: // EDIT GROUP
2773 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2774 tr( "NOT_A_VTK_VIEWER" ) );
2778 if(checkLock(aStudy)) break;
2779 EmitSignalDeactivateDialog();
2781 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2782 SALOME_ListIO selected;
2784 aSel->selectedObjects( selected );
2786 SALOME_ListIteratorOfListIO It (selected);
2787 int nbSelectedGroups = 0;
2788 for ( ; It.More(); It.Next() )
2790 SMESH::SMESH_GroupBase_var aGroup =
2791 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2792 if (!aGroup->_is_nil()) {
2794 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2798 if (nbSelectedGroups == 0)
2800 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2806 case 804: // Add elements to group
2808 if(checkLock(aStudy)) break;
2809 if (myState == 800) {
2810 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2811 if (aDlg) aDlg->onAdd();
2816 case 805: // Remove elements from group
2818 if(checkLock(aStudy)) break;
2819 if (myState == 800) {
2820 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2821 if (aDlg) aDlg->onRemove();
2826 case 815: // Edit GEOM GROUP as standalone
2830 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2831 tr( "NOT_A_VTK_VIEWER" ) );
2835 if(checkLock(aStudy)) break;
2836 EmitSignalDeactivateDialog();
2838 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2839 SALOME_ListIO selected;
2841 aSel->selectedObjects( selected );
2843 SALOME_ListIteratorOfListIO It (selected);
2844 for ( ; It.More(); It.Next() )
2846 SMESH::SMESH_GroupOnGeom_var aGroup =
2847 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2848 if (!aGroup->_is_nil()) {
2849 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2854 SMESH::SMESH_GroupOnFilter_var aGroup =
2855 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2856 if (!aGroup->_is_nil()) {
2857 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2865 case 810: // Union Groups
2866 case 811: // Intersect groups
2867 case 812: // Cut groups
2871 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2872 tr( "NOT_A_VTK_VIEWER" ) );
2876 if ( checkLock( aStudy ) )
2879 EmitSignalDeactivateDialog();
2881 SMESHGUI_GroupOpDlg* aDlg = 0;
2882 if ( theCommandID == 810 )
2883 aDlg = new SMESHGUI_UnionGroupsDlg( this );
2884 else if ( theCommandID == 811 )
2885 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2887 aDlg = new SMESHGUI_CutGroupsDlg( this );
2894 case 814: // Create groups of entities from existing groups of superior dimensions
2896 if ( checkLock( aStudy ) )
2899 EmitSignalDeactivateDialog();
2900 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2906 case 813: // Delete groups with their contents
2910 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2911 tr( "NOT_A_VTK_VIEWER" ) );
2915 if ( checkLock( aStudy ) )
2918 EmitSignalDeactivateDialog();
2920 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2924 case 900: // MESH INFOS
2925 case 903: // WHAT IS
2927 int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2928 EmitSignalDeactivateDialog();
2929 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2930 SALOME_ListIO selected;
2932 aSel->selectedObjects( selected );
2934 if ( selected.Extent() > 1 ) { // a dlg for each IO
2935 SALOME_ListIteratorOfListIO It( selected );
2936 for ( ; It.More(); It.Next() ) {
2937 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2938 dlg->showInfo( It.Value() );
2943 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2949 case 904: // FIND ELEM
2951 startOperation( theCommandID );
2955 case 1100: // EDIT HYPOTHESIS
2957 if(checkLock(aStudy)) break;
2959 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2960 SALOME_ListIO selected;
2962 aSel->selectedObjects( selected );
2964 int nbSel = selected.Extent();
2967 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2968 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
2970 /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
2971 /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects */
2972 /* Warning : however by internal mechanism all subMeshes icons are changed ! */
2973 if ( !aHypothesis->_is_nil() )
2976 //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2977 SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2979 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
2989 case 1102: // REMOVE HYPOTHESIS / ALGORITHMS
2991 if(checkLock(aStudy)) break;
2992 SUIT_OverrideCursor wc;
2994 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2995 SALOME_ListIO selected;
2997 aSel->selectedObjects( selected, QString::null, false );
2999 SALOME_ListIteratorOfListIO It(selected);
3000 for (int i = 0; It.More(); It.Next(), i++) {
3001 Handle(SALOME_InteractiveObject) IObject = It.Value();
3002 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3005 aSel->setSelectedObjects( l1 );
3011 case 4009: // ELEM0D
3013 case 4021: // TRIANGLE
3015 case 4023: // POLYGON
3019 case 4134: // PYRAMID
3020 case 4135: // OCTA12
3022 if(checkLock(aStudy)) break;
3024 EmitSignalDeactivateDialog();
3025 SMDSAbs_EntityType type = SMDSEntity_Edge;
3026 switch (theCommandID) {
3027 case 4008: type = SMDSEntity_Ball; break;
3028 case 4009: type = SMDSEntity_0D; break;
3029 case 4021: type = SMDSEntity_Triangle; break;
3030 case 4022: type = SMDSEntity_Quadrangle; break;
3031 case 4031: type = SMDSEntity_Tetra; break;
3032 case 4023: type = SMDSEntity_Polygon; break;
3033 case 4032: type = SMDSEntity_Hexa; break;
3034 case 4133: type = SMDSEntity_Penta; break;
3035 case 4134: type = SMDSEntity_Pyramid; break;
3036 case 4135: type = SMDSEntity_Hexagonal_Prism; break;
3039 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3042 SUIT_MessageBox::warning(desktop(),
3043 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3047 case 4033: // POLYHEDRON
3049 if(checkLock(aStudy)) break;
3051 EmitSignalDeactivateDialog();
3052 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3055 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3056 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3060 case 4034: // QUADRATIC EDGE
3061 case 4035: // QUADRATIC TRIANGLE
3062 case 4036: // QUADRATIC QUADRANGLE
3063 case 4136: // BIQUADRATIC QUADRANGLE
3064 case 4037: // QUADRATIC TETRAHEDRON
3065 case 4038: // QUADRATIC PYRAMID
3066 case 4039: // QUADRATIC PENTAHEDRON
3067 case 4040: // QUADRATIC HEXAHEDRON
3068 case 4140: // TRIQUADRATIC HEXAHEDRON
3070 if(checkLock(aStudy)) break;
3072 EmitSignalDeactivateDialog();
3073 SMDSAbs_EntityType type = SMDSEntity_Last;
3075 switch (theCommandID) {
3077 type = SMDSEntity_Quad_Edge; break;
3079 type = SMDSEntity_Quad_Triangle; break;
3081 type = SMDSEntity_Quad_Quadrangle; break;
3083 type = SMDSEntity_BiQuad_Quadrangle; break;
3085 type = SMDSEntity_Quad_Tetra; break;
3087 type = SMDSEntity_Quad_Pyramid; break;
3089 type = SMDSEntity_Quad_Penta; break;
3091 type = SMDSEntity_Quad_Hexa; break;
3093 type = SMDSEntity_TriQuad_Hexa; break;
3096 if ( type != SMDSEntity_Last )
3097 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3100 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3101 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3105 case 4041: // REMOVES NODES
3107 if(checkLock(aStudy)) break;
3109 EmitSignalDeactivateDialog();
3110 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3113 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3114 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3118 case 4042: // REMOVES ELEMENTS
3120 if(checkLock(aStudy)) break;
3122 EmitSignalDeactivateDialog();
3123 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3127 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3128 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3132 case 4043: { // CLEAR_MESH
3134 if(checkLock(aStudy)) break;
3136 SALOME_ListIO selected;
3137 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3138 aSel->selectedObjects( selected );
3140 SUIT_OverrideCursor wc;
3141 SALOME_ListIteratorOfListIO It (selected);
3142 for ( ; It.More(); It.Next() )
3144 Handle(SALOME_InteractiveObject) IOS = It.Value();
3145 SMESH::SMESH_Mesh_var aMesh =
3146 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3147 if ( aMesh->_is_nil()) continue;
3149 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3151 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3152 SMESH::ModifiedMesh( aMeshSObj, false, true);
3153 // hide groups and submeshes
3154 _PTR(ChildIterator) anIter =
3155 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3156 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3158 _PTR(SObject) so = anIter->Value();
3159 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3162 catch (const SALOME::SALOME_Exception& S_ex){
3164 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3168 SMESH::UpdateView();
3172 case 4044: // REMOVE ORPHAN NODES
3174 if(checkLock(aStudy)) break;
3175 SALOME_ListIO selected;
3176 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3177 aSel->selectedObjects( selected );
3178 if ( selected.Extent() == 1 ) {
3179 Handle(SALOME_InteractiveObject) anIO = selected.First();
3180 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3181 if ( !aMesh->_is_nil() ) {
3182 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3183 tr( "SMESH_WARNING" ),
3184 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3185 SUIT_MessageBox::Yes |
3186 SUIT_MessageBox::No,
3187 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3190 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3191 int removed = aMeshEditor->RemoveOrphanNodes();
3192 SUIT_MessageBox::information(SMESHGUI::desktop(),
3193 tr("SMESH_INFORMATION"),
3194 tr("NB_NODES_REMOVED").arg(removed));
3195 if ( removed > 0 ) {
3196 SMESH::UpdateView();
3197 SMESHGUI::Modified();
3200 catch (const SALOME::SALOME_Exception& S_ex) {
3201 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3210 case 4051: // RENUMBERING NODES
3212 if(checkLock(aStudy)) break;
3214 EmitSignalDeactivateDialog();
3215 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3219 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3220 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3224 case 4052: // RENUMBERING ELEMENTS
3226 if(checkLock(aStudy)) break;
3228 EmitSignalDeactivateDialog();
3229 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3233 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3234 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3238 case 4061: // TRANSLATION
3240 if(checkLock(aStudy)) break;
3242 EmitSignalDeactivateDialog();
3243 ( new SMESHGUI_TranslationDlg( this ) )->show();
3246 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3247 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3251 case 4062: // ROTATION
3253 if(checkLock(aStudy)) break;
3255 EmitSignalDeactivateDialog();
3256 ( new SMESHGUI_RotationDlg( this ) )->show();
3259 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3260 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3264 case 4063: // SYMMETRY
3266 if(checkLock(aStudy)) break;
3268 EmitSignalDeactivateDialog();
3269 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3272 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3273 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3277 case 4064: // SEWING
3279 if(checkLock(aStudy)) break;
3281 EmitSignalDeactivateDialog();
3282 ( new SMESHGUI_SewingDlg( this ) )->show();
3285 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3286 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3290 case 4065: // MERGE NODES
3292 if(checkLock(aStudy)) break;
3294 EmitSignalDeactivateDialog();
3295 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3298 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3299 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3303 case 4066: // MERGE EQUAL ELEMENTS
3305 if (checkLock(aStudy)) break;
3307 EmitSignalDeactivateDialog();
3308 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3310 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3311 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3316 case 4067: // MAKE MESH PASS THROUGH POINT
3317 startOperation( 4067 );
3322 if(checkLock(aStudy)) break;
3324 EmitSignalDeactivateDialog();
3325 ( new SMESHGUI_ScaleDlg( this ) )->show();
3328 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3329 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3334 case 4069: // DUPLICATE NODES
3336 if(checkLock(aStudy)) break;
3338 EmitSignalDeactivateDialog();
3339 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3342 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3343 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3348 case 4070: // 0D_ON_ALL_NODES
3349 startOperation( 4070 );
3352 case 5105: // Library of selection filters
3354 static QList<int> aTypes;
3355 if ( aTypes.isEmpty() )
3357 aTypes.append( SMESH::NODE );
3358 aTypes.append( SMESH::EDGE );
3359 aTypes.append( SMESH::FACE );
3360 aTypes.append( SMESH::VOLUME );
3362 if (!myFilterLibraryDlg)
3363 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3364 else if (myFilterLibraryDlg->isHidden())
3365 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3366 myFilterLibraryDlg->raise();
3370 case 6017: // CONTROLS
3398 LightApp_SelectionMgr* mgr = selectionMgr();
3399 SALOME_ListIO selected; mgr->selectedObjects( selected );
3401 if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3402 _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3404 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3405 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
3406 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3407 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
3408 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3409 ::Control( theCommandID );
3414 SUIT_MessageBox::warning(desktop(),
3415 tr( "SMESH_WRN_WARNING" ),
3416 tr( "SMESH_BAD_SELECTION" ) );
3420 SUIT_MessageBox::warning(desktop(),
3421 tr( "SMESH_WRN_WARNING" ),
3422 tr( "NOT_A_VTK_VIEWER" ) );
3427 LightApp_SelectionMgr* mgr = selectionMgr();
3428 SALOME_ListIO selected; mgr->selectedObjects( selected );
3430 SALOME_ListIteratorOfListIO it(selected);
3431 for( ; it.More(); it.Next()) {
3432 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3433 if(anIObject->hasEntry()) {
3434 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3435 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3443 LightApp_SelectionMgr* mgr = selectionMgr();
3444 SALOME_ListIO selected; mgr->selectedObjects( selected );
3446 SALOME_ListIteratorOfListIO it(selected);
3447 for( ; it.More(); it.Next()) {
3448 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3449 if(anIObject->hasEntry())
3450 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3451 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3459 int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3460 EmitSignalDeactivateDialog();
3461 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3467 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3468 //updateObjBrowser();
3472 //=============================================================================
3476 //=============================================================================
3477 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3482 //=============================================================================
3486 //=============================================================================
3487 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3492 //=============================================================================
3496 //=============================================================================
3497 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3502 //=============================================================================
3503 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3504 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3506 //=============================================================================
3507 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3508 SUIT_ViewWindow* wnd )
3510 if(theIO->hasEntry()){
3511 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3512 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3516 //=======================================================================
3517 // function : createSMESHAction
3519 //=======================================================================
3520 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3521 const int key, const bool toggle, const QString& shortcutAction )
3524 QWidget* parent = application()->desktop();
3525 SUIT_ResourceMgr* resMgr = resourceMgr();
3527 if ( !icon_id.isEmpty() )
3528 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3530 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3531 if ( !pix.isNull() )
3532 icon = QIcon( pix );
3534 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3535 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3536 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3538 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3539 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3542 //=======================================================================
3543 // function : createPopupItem
3545 //=======================================================================
3546 void SMESHGUI::createPopupItem( const int id,
3547 const QString& clients,
3548 const QString& types,
3549 const QString& theRule,
3552 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3553 popupMgr()->insert( action( id ), pId, 0 );
3555 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3556 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3557 QString rule = "(%1) and (%2) and (%3)";
3558 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3559 if( clients.isEmpty() )
3560 rule = rule.arg( QString( "true" ) );
3562 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3563 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3566 bool cont = myRules.contains( id );
3568 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3570 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3571 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3574 //=======================================================================
3575 // function : initialize
3577 //=======================================================================
3578 void SMESHGUI::initialize( CAM_Application* app )
3580 SalomeApp_Module::initialize( app );
3582 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3584 /* Automatic Update flag */
3585 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3587 // ----- create actions --------------
3589 //createSMESHAction( 111, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3590 createSMESHAction( 112, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3591 createSMESHAction( 113, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3592 createSMESHAction( 114, "NUM" );
3593 createSMESHAction( 115, "IMPORT_STL" );
3594 createSMESHAction( 116, "IMPORT_CGNS" );
3595 createSMESHAction( 117, "IMPORT_SAUV" );
3596 createSMESHAction( 118, "IMPORT_GMF" );
3597 createSMESHAction( 121, "DAT" );
3598 createSMESHAction( 122, "MED" );
3599 createSMESHAction( 123, "UNV" );
3600 createSMESHAction( 140, "STL" );
3601 createSMESHAction( 142, "CGNS");
3602 createSMESHAction( 144, "SAUV");
3603 createSMESHAction( 146, "GMF" );
3604 createSMESHAction( 124, "DAT" );
3605 createSMESHAction( 125, "MED" );
3606 createSMESHAction( 126, "UNV" );
3607 createSMESHAction( 141, "STL" );
3608 createSMESHAction( 143, "CGNS");
3609 createSMESHAction( 145, "SAUV");
3610 createSMESHAction( 147, "GMF" );
3611 createSMESHAction( 150, "FILE_INFO" );
3612 createSMESHAction( 33, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3613 createSMESHAction( 5105, "SEL_FILTER_LIB" );
3614 createSMESHAction( 701, "COMPUTE", "ICON_COMPUTE" );
3615 createSMESHAction( 702, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3616 createSMESHAction( 703, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3617 createSMESHAction( 704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3618 createSMESHAction( 705, "COPY_MESH", "ICON_COPY_MESH" );
3619 createSMESHAction( 710, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3620 createSMESHAction( 711, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3621 createSMESHAction( 712, "EVALUATE", "ICON_COMPUTE" );
3622 createSMESHAction( 713, "MESH_ORDER", "ICON_COMPUTE" );
3623 createSMESHAction( 806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3624 createSMESHAction( 801, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3625 createSMESHAction( 802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3626 createSMESHAction( 803, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3627 createSMESHAction( 815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3628 createSMESHAction( 804, "ADD" );
3629 createSMESHAction( 805, "REMOVE" );
3630 createSMESHAction( 810, "UN_GROUP", "ICON_UNION" );
3631 createSMESHAction( 811, "INT_GROUP", "ICON_INTERSECT" );
3632 createSMESHAction( 812, "CUT_GROUP", "ICON_CUT" );
3633 createSMESHAction( 814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3634 createSMESHAction( 813, "DEL_GROUP", "ICON_DEL_GROUP" );
3635 createSMESHAction( 900, "ADV_INFO", "ICON_ADV_INFO" );
3636 //createSMESHAction( 902, "STD_INFO", "ICON_STD_INFO" );
3637 //createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3638 createSMESHAction( 904, "FIND_ELEM", "ICON_FIND_ELEM" );
3639 createSMESHAction( 6001, "LENGTH", "ICON_LENGTH", 0, true );
3640 createSMESHAction( 6002, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3641 createSMESHAction( 6021, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3642 createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3643 createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3644 createSMESHAction( 6024, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3645 createSMESHAction( 6025, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3646 createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3647 createSMESHAction( 6027, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3648 createSMESHAction( 6028, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3649 createSMESHAction( 6029, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3650 createSMESHAction( 6030, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3651 createSMESHAction( 6031, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3652 createSMESHAction( 6003, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3653 createSMESHAction( 6004, "CONNECTION", "ICON_CONNECTION", 0, true );
3654 createSMESHAction( 6005, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3655 createSMESHAction( 6011, "AREA", "ICON_AREA", 0, true );
3656 createSMESHAction( 6012, "TAPER", "ICON_TAPER", 0, true );
3657 createSMESHAction( 6013, "ASPECT", "ICON_ASPECT", 0, true );
3658 createSMESHAction( 6014, "MIN_ANG", "ICON_ANGLE", 0, true );
3659 createSMESHAction( 6015, "WARP", "ICON_WARP", 0, true );
3660 createSMESHAction( 6016, "SKEW", "ICON_SKEW", 0, true );
3661 createSMESHAction( 6017, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3662 createSMESHAction( 6018, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3663 createSMESHAction( 6019, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3664 createSMESHAction( 6009, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3665 createSMESHAction( 4000, "NODE", "ICON_DLG_NODE" );
3666 createSMESHAction( 4009, "ELEM0D", "ICON_DLG_ELEM0D" );
3667 createSMESHAction( 4008, "BALL", "ICON_DLG_BALL" );
3668 createSMESHAction( 4010, "EDGE", "ICON_DLG_EDGE" );
3669 createSMESHAction( 4021, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3670 createSMESHAction( 4022, "QUAD", "ICON_DLG_QUADRANGLE" );
3671 createSMESHAction( 4023, "POLYGON", "ICON_DLG_POLYGON" );
3672 createSMESHAction( 4031, "TETRA", "ICON_DLG_TETRAS" );
3673 createSMESHAction( 4032, "HEXA", "ICON_DLG_HEXAS" );
3674 createSMESHAction( 4133, "PENTA", "ICON_DLG_PENTA" );
3675 createSMESHAction( 4134, "PYRAMID", "ICON_DLG_PYRAMID" );
3676 createSMESHAction( 4135, "OCTA", "ICON_DLG_OCTA" );
3677 createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3678 createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3679 createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3680 createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3681 createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3682 createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3683 createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3684 createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3685 createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3686 createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3687 createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3688 createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3689 createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3690 createSMESHAction( 4043, "CLEAR_MESH" , "ICON_CLEAR_MESH" );
3691 createSMESHAction( 4051, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3692 createSMESHAction( 4052, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3693 createSMESHAction( 4061, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3694 createSMESHAction( 4062, "ROT", "ICON_DLG_MESH_ROTATION" );
3695 createSMESHAction( 4063, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3696 createSMESHAction( 4064, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3697 createSMESHAction( 4065, "MERGE", "ICON_SMESH_MERGE_NODES" );
3698 createSMESHAction( 4066, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3699 createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3700 createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" );
3701 createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3702 createSMESHAction( 4070, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3703 createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" );
3704 createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" );
3705 createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3706 createSMESHAction( 410, "UNION", "ICON_UNIONTRI" );
3707 createSMESHAction( 411, "CUT", "ICON_CUTQUAD" );
3708 createSMESHAction( 412, "SMOOTH", "ICON_DLG_SMOOTHING" );
3709 createSMESHAction( 413, "EXTRUSION", "ICON_EXTRUSION" );
3710 createSMESHAction( 414, "REVOLUTION", "ICON_REVOLUTION" );
3711 createSMESHAction( 415, "MAP", "ICON_MAP" );
3712 createSMESHAction( 416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3713 createSMESHAction( 417, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3714 createSMESHAction( 418, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3715 createSMESHAction( 419, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3716 createSMESHAction( 420, "REORIENT_2D", "ICON_REORIENT_2D" );
3717 createSMESHAction( 200, "RESET" );
3718 createSMESHAction( 201, "SCALAR_BAR_PROP" );
3719 createSMESHAction( 2021, "SAVE_DISTRIBUTION" );
3720 createSMESHAction( 2022, "SHOW_DISTRIBUTION","",0, true );
3721 #ifndef DISABLE_PLOT2DVIEWER
3722 createSMESHAction( 2023, "PLOT_DISTRIBUTION" );
3724 createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true );
3725 createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true );
3726 createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true );
3727 createSMESHAction( 214, "UPDATE", "ICON_UPDATE" );
3728 createSMESHAction( 215, "NODES", "ICON_POINTS", 0, true );
3729 createSMESHAction( 222, "BALLS", "ICON_DLG_BALL", 0, true );
3730 createSMESHAction( 216, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3731 createSMESHAction( 217, "EDGES", "ICON_DLG_EDGE", 0, true );
3732 createSMESHAction( 218, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3733 createSMESHAction( 219, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3734 createSMESHAction( 220, "ALL" );
3735 createSMESHAction( 221, "FACE_ORIENTATION", "", 0, true );
3737 createSMESHAction( 231, "LINE_REPRESENTATION", "", 0, true );
3738 createSMESHAction( 232, "ARC_REPRESENTATION", "", 0, true );
3740 createSMESHAction( 1100, "EDIT_HYPO" );
3741 createSMESHAction( 1102, "UNASSIGN" );
3742 createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3743 createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3744 createSMESHAction( 1131, "DISPMODE" );
3745 createSMESHAction( 1132, "COLORS" );
3746 createSMESHAction( 1133, "TRANSP" );
3747 createSMESHAction( 1134, "CLIP" );
3748 createSMESHAction( 1135, "DISP_ENT" );
3749 createSMESHAction( 1136, "AUTO_COLOR" );
3750 createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3751 createSMESHAction( 2000, "CTRL" );
3753 createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3754 createSMESHAction( 502, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3756 createSMESHAction( 300, "HIDE" );
3757 createSMESHAction( 301, "SHOW" );
3758 createSMESHAction( 302, "DISPLAY_ONLY" );
3760 // ----- create menu --------------
3761 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3762 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3763 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3764 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3765 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3766 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3767 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3768 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3770 createMenu( separator(), fileId );
3772 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3773 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3774 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3775 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3776 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3777 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3778 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3779 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3780 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3781 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3783 //createMenu( 111, importId, -1 );
3784 createMenu( 112, importId, -1 );
3785 createMenu( 113, importId, -1 );
3786 createMenu( 115, importId, -1 );
3788 createMenu( 116, importId, -1 );
3790 createMenu( 117, importId, -1 );
3791 createMenu( 118, importId, -1 );
3792 createMenu( 121, exportId, -1 );
3793 createMenu( 122, exportId, -1 );
3794 createMenu( 123, exportId, -1 );
3795 createMenu( 140, exportId, -1 ); // export to STL
3797 createMenu( 142, exportId, -1 ); // export to CGNS
3799 createMenu( 144, exportId, -1 ); // export to SAUV
3800 createMenu( 146, exportId, -1 ); // export to GMF
3801 createMenu( separator(), fileId, 10 );
3803 createMenu( 33, editId, -1 );
3805 createMenu( 5105, toolsId, -1 );
3807 createMenu( 702, meshId, -1 ); // "Mesh" menu
3808 createMenu( 703, meshId, -1 );
3809 createMenu( 704, meshId, -1 );
3810 createMenu( 710, meshId, -1 );
3811 createMenu( 705, meshId, -1 );
3812 createMenu( separator(), meshId, -1 );
3813 createMenu( 701, meshId, -1 );
3814 createMenu( 711, meshId, -1 );
3815 createMenu( 712, meshId, -1 );
3816 createMenu( 713, meshId, -1 );
3817 createMenu( separator(), meshId, -1 );
3818 createMenu( 801, meshId, -1 );
3819 createMenu( 806, meshId, -1 );
3820 createMenu( 802, meshId, -1 );
3821 createMenu( 803, meshId, -1 );
3822 createMenu( 815, meshId, -1 );
3823 createMenu( separator(), meshId, -1 );
3824 createMenu( 810, meshId, -1 );
3825 createMenu( 811, meshId, -1 );
3826 createMenu( 812, meshId, -1 );
3827 createMenu( separator(), meshId, -1 );
3828 createMenu( 814, meshId, -1 );
3829 createMenu( separator(), meshId, -1 );
3830 createMenu( 900, meshId, -1 );
3831 //createMenu( 902, meshId, -1 );
3832 //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3833 createMenu( 904, meshId, -1 );
3834 createMenu( separator(), meshId, -1 );
3836 createMenu( 6005, nodeId, -1 );
3837 createMenu( 6028, nodeId, -1 );
3838 createMenu( 6002, edgeId, -1 );
3839 createMenu( 6003, edgeId, -1 );
3840 createMenu( 6001, edgeId, -1 );
3841 createMenu( 6004, edgeId, -1 );
3842 createMenu( 6029, edgeId, -1 );
3843 createMenu( 6021, faceId, -1 );
3844 createMenu( 6025, faceId, -1 );
3845 createMenu( 6027, faceId, -1 );
3846 createMenu( 6018, faceId, -1 );
3847 createMenu( 6019, faceId, -1 );
3848 createMenu( 6011, faceId, -1 );
3849 createMenu( 6012, faceId, -1 );
3850 createMenu( 6013, faceId, -1 );
3851 createMenu( 6014, faceId, -1 );
3852 createMenu( 6015, faceId, -1 );
3853 createMenu( 6016, faceId, -1 );
3854 createMenu( 6022, faceId, -1 );
3855 createMenu( 6030, faceId, -1 );
3856 createMenu( 6017, volumeId, -1 );
3857 createMenu( 6009, volumeId, -1 );
3858 createMenu( 6023, volumeId, -1 );
3859 createMenu( 6024, volumeId, -1 );
3860 createMenu( 6026, volumeId, -1 );
3861 createMenu( 6031, volumeId, -1 );
3863 createMenu( 4000, addId, -1 );
3864 createMenu( 4009, addId, -1 );
3865 createMenu( 4070, addId, -1 );
3866 createMenu( 4008, addId, -1 );
3867 createMenu( 4010, addId, -1 );
3868 createMenu( 4021, addId, -1 );
3869 createMenu( 4022, addId, -1 );
3870 createMenu( 4023, addId, -1 );
3871 createMenu( 4031, addId, -1 );
3872 createMenu( 4032, addId, -1 );
3873 createMenu( 4133, addId, -1 );
3874 createMenu( 4134, addId, -1 );
3875 createMenu( 4135, addId, -1 );
3876 createMenu( 4033, addId, -1 );
3877 createMenu( separator(), addId, -1 );
3878 createMenu( 4034, addId, -1 );
3879 createMenu( 4035, addId, -1 );
3880 createMenu( 4036, addId, -1 );
3881 createMenu( 4136, addId, -1 );
3882 createMenu( 4037, addId, -1 );
3883 createMenu( 4038, addId, -1 );
3884 createMenu( 4039, addId, -1 );
3885 createMenu( 4040, addId, -1 );
3886 createMenu( 4140, addId, -1 );
3888 createMenu( 4041, removeId, -1 );
3889 createMenu( 4042, removeId, -1 );
3890 createMenu( 4044, removeId, -1 );
3891 createMenu( separator(), removeId, -1 );
3892 createMenu( 813, removeId, -1 );
3893 createMenu( separator(), removeId, -1 );
3894 createMenu( 4043, removeId, -1 );
3896 createMenu( 4051, renumId, -1 );
3897 createMenu( 4052, renumId, -1 );
3899 createMenu( 4061, transfId, -1 );
3900 createMenu( 4062, transfId, -1 );
3901 createMenu( 4063, transfId, -1 );
3902 createMenu( 4068, transfId, -1 );
3903 createMenu( 4064, transfId, -1 );
3904 createMenu( 4065, transfId, -1 );
3905 createMenu( 4066, transfId, -1 );
3906 createMenu( 4069, transfId, -1 );
3908 createMenu( 4067,modifyId, -1 );
3909 createMenu( 407, modifyId, -1 );
3910 createMenu( 408, modifyId, -1 );
3911 createMenu( 409, modifyId, -1 );
3912 createMenu( 420, modifyId, -1 );
3913 createMenu( 410, modifyId, -1 );
3914 createMenu( 411, modifyId, -1 );
3915 createMenu( 419, modifyId, -1 );
3916 createMenu( 412, modifyId, -1 );
3917 createMenu( 413, modifyId, -1 );
3918 createMenu( 416, modifyId, -1 );
3919 createMenu( 414, modifyId, -1 );
3920 createMenu( 415, modifyId, -1 );
3921 createMenu( 417, modifyId, -1 );
3922 createMenu( 418, modifyId, -1 );
3924 createMenu( 501, measureId, -1 );
3925 createMenu( 502, measureId, -1 );
3926 createMenu( 214, viewId, -1 );
3928 // ----- create toolbars --------------
3929 int meshTb = createTool( tr( "TB_MESH" ) ),
3930 ctrlTb = createTool( tr( "TB_CTRL" ) ),
3931 addRemTb = createTool( tr( "TB_ADD_REMOVE" ) ),
3932 modifyTb = createTool( tr( "TB_MODIFY" ) ),
3933 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
3935 createTool( 702, meshTb );
3936 createTool( 703, meshTb );
3937 createTool( 704, meshTb );
3938 createTool( 710, meshTb );
3939 createTool( 705, meshTb );
3940 createTool( separator(), meshTb );
3941 createTool( 701, meshTb );
3942 createTool( 711, meshTb );
3943 createTool( 712, meshTb );
3944 createTool( 713, meshTb );
3945 createTool( separator(), meshTb );
3946 createTool( 801, meshTb );
3947 createTool( 806, meshTb );
3948 createTool( 802, meshTb );
3949 createTool( 803, meshTb );
3950 //createTool( 815, meshTb );
3951 createTool( separator(), meshTb );
3952 createTool( 900, meshTb );
3953 //createTool( 902, meshTb );
3954 //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3955 createTool( 904, meshTb );
3956 createTool( separator(), meshTb );
3958 createTool( 6005, ctrlTb );
3959 createTool( 6028, ctrlTb );
3960 createTool( separator(), ctrlTb );
3961 createTool( 6002, ctrlTb );
3962 createTool( 6003, ctrlTb );
3963 createTool( 6001, ctrlTb );
3964 createTool( 6004, ctrlTb );
3965 createTool( 6029, ctrlTb );
3966 createTool( separator(), ctrlTb );
3967 createTool( 6021, ctrlTb );
3968 createTool( 6025, ctrlTb );
3969 createTool( 6027, ctrlTb );
3970 createTool( 6018, ctrlTb );
3971 createTool( 6019, ctrlTb );
3972 createTool( 6011, ctrlTb );
3973 createTool( 6012, ctrlTb );
3974 createTool( 6013, ctrlTb );
3975 createTool( 6014, ctrlTb );
3976 createTool( 6015, ctrlTb );
3977 createTool( 6016, ctrlTb );
3978 createTool( 6022, ctrlTb );
3979 createTool( 6030, ctrlTb );
3980 createTool( separator(), ctrlTb );
3981 createTool( 6017, ctrlTb );
3982 createTool( 6009, ctrlTb );
3983 createTool( 6023, ctrlTb );
3984 createTool( 6024, ctrlTb );
3985 createTool( 6026, ctrlTb );
3986 createTool( 6031, ctrlTb );
3987 createTool( separator(), ctrlTb );
3989 createTool( 4000, addRemTb );
3990 createTool( 4009, addRemTb );
3991 createTool( 4070, addRemTb );
3992 createTool( 4008, addRemTb );
3993 createTool( 4010, addRemTb );
3994 createTool( 4021, addRemTb );
3995 createTool( 4022, addRemTb );
3996 createTool( 4023, addRemTb );
3997 createTool( 4031, addRemTb );
3998 createTool( 4032, addRemTb );
3999 createTool( 4133, addRemTb );
4000 createTool( 4134, addRemTb );
4001 createTool( 4135, addRemTb );
4002 createTool( 4033, addRemTb );
4003 createTool( separator(), addRemTb );
4004 createTool( 4034, addRemTb );
4005 createTool( 4035, addRemTb );
4006 createTool( 4036, addRemTb );
4007 createTool( 4136, addRemTb );
4008 createTool( 4037, addRemTb );
4009 createTool( 4038, addRemTb );
4010 createTool( 4039, addRemTb );
4011 createTool( 4040, addRemTb );
4012 createTool( 4140, addRemTb );
4013 createTool( separator(), addRemTb );
4014 createTool( 4041, addRemTb );
4015 createTool( 4042, addRemTb );
4016 createTool( 4044, addRemTb );
4017 createTool( 4043, addRemTb );
4018 createTool( separator(), addRemTb );
4019 createTool( 4051, addRemTb );
4020 createTool( 4052, addRemTb );
4021 createTool( separator(), addRemTb );
4022 createTool( 4061, addRemTb );
4023 createTool( 4062, addRemTb );
4024 createTool( 4063, addRemTb );
4025 createTool( 4068, addRemTb );
4026 createTool( 4064, addRemTb );
4027 createTool( 4065, addRemTb );
4028 createTool( 4066, addRemTb );
4029 createTool( 4069, addRemTb );
4030 createTool( separator(), addRemTb );
4032 createTool( 4067,modifyTb );
4033 createTool( 407, modifyTb );
4034 createTool( 408, modifyTb );
4035 createTool( 409, modifyTb );
4036 createTool( 420, modifyTb );
4037 createTool( 410, modifyTb );
4038 createTool( 411, modifyTb );
4039 createTool( 419, modifyTb );
4040 createTool( 412, modifyTb );
4041 createTool( 413, modifyTb );
4042 createTool( 416, modifyTb );
4043 createTool( 414, modifyTb );
4044 createTool( 415, modifyTb );
4045 createTool( 417, modifyTb );
4046 createTool( 418, modifyTb );
4048 createTool( 214, dispModeTb );
4050 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4051 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4054 QString OB = "'ObjectBrowser'",
4055 View = "'" + SVTK_Viewer::Type() + "'",
4057 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4058 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4059 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4060 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4061 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4062 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4063 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4064 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4065 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4066 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4067 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4069 mesh_part = mesh + " " + subMesh + " " + group,
4070 mesh_group = mesh + " " + group,
4071 hyp_alg = hypo + " " + algo;
4073 // popup for object browser
4075 isInvisible("not( isVisible )"),
4076 isEmpty("numberOfNodes = 0"),
4077 isNotEmpty("numberOfNodes <> 0"),
4079 // has nodes, edges, etc in VISIBLE! actor
4080 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4081 hasElems("(count( elemTypes ) > 0)"),
4082 hasDifferentElems("(count( elemTypes ) > 1)"),
4083 hasBalls("({'BallElem'} in elemTypes)"),
4084 hasElems0d("({'Elem0d'} in elemTypes)"),
4085 hasEdges("({'Edge'} in elemTypes)"),
4086 hasFaces("({'Face'} in elemTypes)"),
4087 hasVolumes("({'Volume'} in elemTypes)");
4089 createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
4090 createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
4091 createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
4092 createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
4093 createPopupItem( 803, OB, group ); // EDIT_GROUP
4094 createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
4096 popupMgr()->insert( separator(), -1, 0 );
4097 createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
4098 createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
4099 createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
4100 createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
4101 createPopupItem( 214, OB, mesh_part ); // UPDATE
4102 createPopupItem( 900, OB, mesh_part ); // ADV_INFO
4103 createPopupItem( 904, OB, mesh_group ); // FIND_ELEM
4104 popupMgr()->insert( separator(), -1, 0 );
4105 createPopupItem( 801, OB, mesh ); // CREATE_GROUP
4106 createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
4107 createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
4108 popupMgr()->insert( separator(), -1, 0 );
4109 createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
4110 createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4111 popupMgr()->insert( separator(), -1, 0 );
4112 createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
4113 popupMgr()->insert( separator(), -1, 0 );
4114 createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
4115 createPopupItem( 418, OB, mesh + " " + group, // create 2D mesh from 3D
4117 popupMgr()->insert( separator(), -1, 0 );
4119 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4120 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4121 QString only_one_2D = only_one_non_empty + " && dim>1";
4123 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4124 createPopupItem( 125, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_MED
4125 createPopupItem( 126, OB, mesh_group, only_one_non_empty, anId ); // EXPORT_UNV
4126 createPopupItem( 141, OB, mesh_group, only_one_2D, anId ); // EXPORT_STL
4128 createPopupItem( 143, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_CGNS
4130 createPopupItem( 145, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_SAUV
4131 createPopupItem( 147, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_GMF
4132 createPopupItem( 124, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_DAT
4133 createPopupItem( 33, OB, mesh_part + " " + hyp_alg ); // DELETE
4134 createPopupItem( 813, OB, group ); // DEL_GROUP with contents
4135 popupMgr()->insert( separator(), -1, 0 );
4138 createPopupItem( 803, View, group ); // EDIT_GROUP
4139 createPopupItem( 804, View, elems ); // ADD
4140 createPopupItem( 805, View, elems ); // REMOVE
4142 popupMgr()->insert( separator(), -1, 0 );
4143 createPopupItem( 214, View, mesh_part ); // UPDATE
4144 createPopupItem( 900, View, mesh_part ); // ADV_INFO
4145 createPopupItem( 904, View, mesh ); // FIND_ELEM
4146 popupMgr()->insert( separator(), -1, 0 );
4148 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
4149 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
4150 popupMgr()->insert( separator(), -1, 0 );
4152 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4153 QString aType = QString( "%1type in {%2}" ).arg( lc );
4154 aType = aType.arg( mesh_part );
4155 QString aMeshInVTK = aClient + "&&" + aType;
4157 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4158 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4159 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4161 //-------------------------------------------------
4163 //-------------------------------------------------
4164 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4166 popupMgr()->insert( action( 9010 ), anId, -1 );
4167 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4168 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4170 popupMgr()->insert( action( 9011 ), anId, -1 );
4171 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4172 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4174 popupMgr()->insert( separator(), -1, -1 );
4176 //-------------------------------------------------
4178 //-------------------------------------------------
4179 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4181 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4182 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4183 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4185 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4186 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4187 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4189 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4190 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4191 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4193 popupMgr()->insert( separator(), anId, -1 );
4195 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4196 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4197 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4199 //-------------------------------------------------
4201 //-------------------------------------------------
4202 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4204 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4206 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4207 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4208 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4210 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4211 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4212 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4214 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4215 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4216 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4218 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4219 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4220 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4222 popupMgr()->insert( action( 222 ), anId, -1 ); // BALLS
4223 popupMgr()->setRule( action( 222 ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4224 popupMgr()->setRule( action( 222 ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4226 popupMgr()->insert( separator(), anId, -1 );
4228 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4229 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4232 //-------------------------------------------------
4233 // Representation of the 2D Quadratic elements
4234 //-------------------------------------------------
4235 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4236 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4237 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4238 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4240 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4241 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4242 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4244 //-------------------------------------------------
4245 // Orientation of faces
4246 //-------------------------------------------------
4247 popupMgr()->insert( action( 221 ), -1, -1 );
4248 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4249 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4251 //-------------------------------------------------
4253 //-------------------------------------------------
4254 popupMgr()->insert( action( 1132 ), -1, -1 );
4255 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4257 //-------------------------------------------------
4259 //-------------------------------------------------
4260 popupMgr()->insert( action( 1133 ), -1, -1 );
4261 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4263 //-------------------------------------------------
4265 //-------------------------------------------------
4267 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4268 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4269 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4270 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4272 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4274 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4275 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4277 popupMgr()->insert( separator(), anId, -1 );
4279 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4281 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4282 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4283 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4285 popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4286 popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4287 popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4289 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4291 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4292 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4293 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4295 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4296 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4297 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4299 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4300 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4301 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4303 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4304 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4305 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4306 popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4307 popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4308 popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4310 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4312 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4313 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4314 QtxPopupMgr::VisibleRule );
4315 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4317 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4318 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4319 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4321 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4322 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4323 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4325 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4326 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4327 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4329 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4330 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4331 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4333 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4334 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4335 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4337 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4338 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4339 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4341 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4342 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4343 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4345 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4346 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4347 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4349 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4350 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4351 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4353 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4354 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4355 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4357 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4358 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4359 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4360 popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4361 popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4362 popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4364 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4366 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4367 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4368 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4370 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4371 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4372 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4374 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4375 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4376 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4378 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4379 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4380 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4382 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4383 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4384 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4386 popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4387 popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4388 popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4390 popupMgr()->insert( separator(), anId, -1 );
4392 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4393 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4395 popupMgr()->insert( separator(), anId, -1 );
4397 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4399 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4400 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4402 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4403 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4404 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4406 #ifndef DISABLE_PLOT2DVIEWER
4407 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4408 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4411 //-------------------------------------------------
4413 //-------------------------------------------------
4414 popupMgr()->insert( separator(), -1, -1 );
4415 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4416 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4417 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4418 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4420 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4421 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4423 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4424 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4426 popupMgr()->insert( separator(), -1, -1 );
4428 //-------------------------------------------------
4430 //-------------------------------------------------
4431 popupMgr()->insert( action( 1134 ), -1, -1 );
4432 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4434 popupMgr()->insert( separator(), -1, -1 );
4436 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4437 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4439 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4440 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4443 //================================================================================
4445 * \brief Return true if SMESH or GEOM objects are selected.
4446 * Is called form LightApp_Module::activateModule() which clear selection if
4447 * not isSelectionCompatible()
4449 //================================================================================
4451 bool SMESHGUI::isSelectionCompatible()
4453 bool isCompatible = true;
4454 SALOME_ListIO selected;
4455 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4456 Sel->selectedObjects( selected );
4458 SALOME_ListIteratorOfListIO It( selected );
4459 for ( ; isCompatible && It.More(); It.Next())
4461 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4462 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4464 return isCompatible;
4468 bool SMESHGUI::reusableOperation( const int id )
4470 // compute, evaluate and precompute are not reusable operations
4471 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4474 bool SMESHGUI::activateModule( SUIT_Study* study )
4476 bool res = SalomeApp_Module::activateModule( study );
4478 setMenuShown( true );
4479 setToolShown( true );
4481 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4482 PyGILState_STATE gstate = PyGILState_Ensure();
4483 PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4484 if(pluginsmanager==NULL)
4488 PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4493 PyGILState_Release(gstate);
4494 // end of GEOM plugins loading
4496 // Reset actions accelerator keys
4497 //action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4498 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4499 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4501 action( 33)->setEnabled(true); // Delete: Key_Delete
4503 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4504 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4505 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4506 if ( _PTR(Study) aStudy = s->studyDS()) {
4507 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4508 updateObjBrowser(); // objects can be removed
4511 // get all view currently opened in the study and connect their signals to
4512 // the corresponding slots of the class.
4513 SUIT_Desktop* aDesk = study->application()->desktop();
4515 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4516 SUIT_ViewWindow* wnd;
4517 foreach ( wnd, wndList )
4524 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4526 setMenuShown( false );
4527 setToolShown( false );
4529 EmitSignalCloseAllDialogs();
4531 // Unset actions accelerator keys
4532 //action(111)->setShortcut(QKeySequence()); // Import DAT
4533 action(112)->setShortcut(QKeySequence()); // Import UNV
4534 action(113)->setShortcut(QKeySequence()); // Import MED
4536 action( 33)->setEnabled(false); // Delete: Key_Delete
4538 return SalomeApp_Module::deactivateModule( study );
4541 void SMESHGUI::studyClosed( SUIT_Study* s )
4543 SMESH::RemoveVisuData( s->id() );
4544 SalomeApp_Module::studyClosed( s );
4547 void SMESHGUI::OnGUIEvent()
4549 const QObject* obj = sender();
4550 if ( !obj || !obj->inherits( "QAction" ) )
4552 int id = actionId((QAction*)obj);
4557 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4559 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4560 if ( CORBA::is_nil( myComponentSMESH ) )
4562 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4564 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4565 return aGUI.myComponentSMESH;
4568 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4569 return myComponentSMESH;
4572 QString SMESHGUI::engineIOR() const
4574 CORBA::ORB_var anORB = getApp()->orb();
4575 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4576 return QString( anIOR.in() );
4579 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4581 SalomeApp_Module::contextMenuPopup( client, menu, title );
4583 selectionMgr()->selectedObjects( lst );
4584 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4585 Handle(SALOME_InteractiveObject) io = lst.First();
4586 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4587 _PTR(Study) study = appStudy->studyDS();
4588 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4590 QString aName = QString( obj->GetName().c_str() );
4591 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4592 aName.remove( (aName.length() - 1), 1 );
4598 LightApp_Selection* SMESHGUI::createSelection() const
4600 return new SMESHGUI_Selection();
4603 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4605 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4606 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4609 void SMESHGUI::viewManagers( QStringList& list ) const
4611 list.append( SVTK_Viewer::Type() );
4614 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4616 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4617 SMESH::UpdateSelectionProp( this );
4619 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4620 for(int i = 0; i < aViews.count() ; i++){
4621 SUIT_ViewWindow *sf = aViews[i];
4627 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4629 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4630 myClippingPlaneInfoMap.erase( theViewManager );
4633 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4635 theActor->AddObserver( SMESH::DeleteActorEvent,
4636 myEventCallbackCommand.GetPointer(),
4640 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4641 unsigned long theEvent,
4642 void* theClientData,
4645 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4646 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4647 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4648 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4649 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4650 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4651 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4652 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4653 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4654 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4655 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4656 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4657 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4658 if( anActor == *anIter3 ) {
4659 anActorList.erase( anIter3 );
4670 void SMESHGUI::createPreferences()
4672 // General tab ------------------------------------------------------------------------
4673 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4675 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4676 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4677 setPreferenceProperty( lim, "min", 0 );
4678 setPreferenceProperty( lim, "max", 100000000 );
4679 setPreferenceProperty( lim, "step", 1000 );
4680 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4682 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4683 setPreferenceProperty( qaGroup, "columns", 2 );
4684 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4685 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4686 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4687 setPreferenceProperty( prec, "min", 0 );
4688 setPreferenceProperty( prec, "max", 16 );
4689 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4690 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4691 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4692 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4693 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4695 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4696 setPreferenceProperty( dispgroup, "columns", 2 );
4697 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4699 modes.append( tr("MEN_WIRE") );
4700 modes.append( tr("MEN_SHADE") );
4701 modes.append( tr("MEN_NODES") );
4702 modes.append( tr("MEN_SHRINK") );
4703 QList<QVariant> indices;
4704 indices.append( 0 );
4705 indices.append( 1 );
4706 indices.append( 2 );
4707 indices.append( 3 );
4708 setPreferenceProperty( dispmode, "strings", modes );
4709 setPreferenceProperty( dispmode, "indexes", indices );
4711 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4712 setPreferenceProperty( arcgroup, "columns", 2 );
4713 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4714 QStringList quadraticModes;
4715 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4716 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4718 indices.append( 0 );
4719 indices.append( 1 );
4720 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4721 setPreferenceProperty( quadraticmode, "indexes", indices );
4723 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4724 "SMESH", "max_angle" );
4725 setPreferenceProperty( maxAngle, "min", 1 );
4726 setPreferenceProperty( maxAngle, "max", 90 );
4730 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4731 setPreferenceProperty( exportgroup, "columns", 2 );
4732 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4733 addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4735 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4736 setPreferenceProperty( computeGroup, "columns", 2 );
4737 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4739 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4740 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4741 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4743 indices.append( 0 );
4744 indices.append( 1 );
4745 indices.append( 2 );
4746 setPreferenceProperty( notifyMode, "strings", modes );
4747 setPreferenceProperty( notifyMode, "indexes", indices );
4749 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4750 setPreferenceProperty( infoGroup, "columns", 4 );
4751 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4753 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4754 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4756 indices.append( 0 );
4757 indices.append( 1 );
4758 setPreferenceProperty( elemInfo, "strings", modes );
4759 setPreferenceProperty( elemInfo, "indexes", indices );
4760 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4761 setPreferenceProperty( nodesLim, "min", 0 );
4762 setPreferenceProperty( nodesLim, "max", 10000000 );
4763 setPreferenceProperty( nodesLim, "step", 10000 );
4764 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4766 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4767 setPreferenceProperty( segGroup, "columns", 2 );
4768 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4769 "SMESH", "segmentation" );
4770 setPreferenceProperty( segLen, "min", 1 );
4771 setPreferenceProperty( segLen, "max", 10000000 );
4772 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4773 "SMESH", "nb_segments_per_edge" );
4774 setPreferenceProperty( nbSeg, "min", 1 );
4775 setPreferenceProperty( nbSeg, "max", 10000000 );
4777 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4778 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4779 "SMESH", "forget_mesh_on_hyp_modif" );
4782 // Quantities with individual precision settings
4783 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4784 setPreferenceProperty( precGroup, "columns", 2 );
4786 const int nbQuantities = 6;
4787 int precs[nbQuantities], ii = 0;
4788 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4789 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4790 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4791 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4792 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4793 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4794 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4795 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4796 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4797 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4798 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4799 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4801 // Set property for precision value for spinboxes
4802 for ( ii = 0; ii < nbQuantities; ii++ ){
4803 setPreferenceProperty( precs[ii], "min", -14 );
4804 setPreferenceProperty( precs[ii], "max", 14 );
4805 setPreferenceProperty( precs[ii], "precision", 2 );
4808 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4809 setPreferenceProperty( previewGroup, "columns", 2 );
4810 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4811 setPreferenceProperty( chunkSize, "min", 1 );
4812 setPreferenceProperty( chunkSize, "max", 1000 );
4813 setPreferenceProperty( chunkSize, "step", 50 );
4815 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4816 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4818 // Mesh tab ------------------------------------------------------------------------
4819 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4820 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4821 setPreferenceProperty( nodeGroup, "columns", 3 );
4823 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4825 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4827 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4828 QList<QVariant> aMarkerTypeIndicesList;
4829 QList<QVariant> aMarkerTypeIconsList;
4830 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4831 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4832 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4833 aMarkerTypeIndicesList << i;
4834 aMarkerTypeIconsList << pixmap;
4836 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4837 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4839 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4841 QList<QVariant> aMarkerScaleIndicesList;
4842 QStringList aMarkerScaleValuesList;
4843 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4844 aMarkerScaleIndicesList << i;
4845 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4847 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4848 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4850 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4851 //setPreferenceProperty( elemGroup, "columns", 2 );
4853 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4854 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4855 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
4856 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
4857 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4858 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
4859 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4860 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4863 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4864 setPreferenceProperty( grpGroup, "columns", 2 );
4866 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4867 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
4869 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4870 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4871 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
4872 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
4873 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4874 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4875 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
4876 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
4877 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4878 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4880 setPreferenceProperty( size0d, "min", 1 );
4881 setPreferenceProperty( size0d, "max", 10 );
4883 setPreferenceProperty( ballSize, "min", 1 );
4884 setPreferenceProperty( ballSize, "max", 10 );
4886 setPreferenceProperty( elemW, "min", 1 );
4887 setPreferenceProperty( elemW, "max", 5 );
4889 setPreferenceProperty( outW, "min", 1 );
4890 setPreferenceProperty( outW, "max", 5 );
4892 setPreferenceProperty( shrink, "min", 0 );
4893 setPreferenceProperty( shrink, "max", 100 );
4895 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4896 setPreferenceProperty( orientGroup, "columns", 1 );
4898 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4899 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4901 setPreferenceProperty( orientScale, "min", 0.05 );
4902 setPreferenceProperty( orientScale, "max", 0.5 );
4903 setPreferenceProperty( orientScale, "step", 0.05 );
4905 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4907 // Selection tab ------------------------------------------------------------------------
4908 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4910 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4911 setPreferenceProperty( selGroup, "columns", 2 );
4913 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4914 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4916 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4917 setPreferenceProperty( preGroup, "columns", 2 );
4919 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4921 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4922 setPreferenceProperty( precSelGroup, "columns", 2 );
4924 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4925 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4926 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4928 // Scalar Bar tab ------------------------------------------------------------------------
4929 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4930 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4931 setPreferenceProperty( fontGr, "columns", 2 );
4933 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4934 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4936 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4937 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4939 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4940 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4942 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4943 setPreferenceProperty( numcol, "min", 2 );
4944 setPreferenceProperty( numcol, "max", 256 );
4946 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4947 setPreferenceProperty( numlab, "min", 2 );
4948 setPreferenceProperty( numlab, "max", 65 );
4950 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4951 setPreferenceProperty( orientGr, "columns", 2 );
4952 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4953 QStringList orients;
4954 orients.append( tr( "SMESH_VERTICAL" ) );
4955 orients.append( tr( "SMESH_HORIZONTAL" ) );
4956 indices.clear(); indices.append( 0 ); indices.append( 1 );
4957 setPreferenceProperty( orient, "strings", orients );
4958 setPreferenceProperty( orient, "indexes", indices );
4960 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4961 setPreferenceProperty( posVSizeGr, "columns", 2 );
4962 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4963 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4964 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4965 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4966 setPreferenceProperty( xv, "step", 0.1 );
4967 setPreferenceProperty( xv, "min", 0.0 );
4968 setPreferenceProperty( xv, "max", 1.0 );
4969 setPreferenceProperty( yv, "step", 0.1 );
4970 setPreferenceProperty( yv, "min", 0.0 );
4971 setPreferenceProperty( yv, "max", 1.0 );
4972 setPreferenceProperty( wv, "step", 0.1 );
4973 setPreferenceProperty( wv, "min", 0.0 );
4974 setPreferenceProperty( wv, "max", 1.0 );
4975 setPreferenceProperty( hv, "min", 0.0 );
4976 setPreferenceProperty( hv, "max", 1.0 );
4977 setPreferenceProperty( hv, "step", 0.1 );
4979 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
4980 setPreferenceProperty( posHSizeGr, "columns", 2 );
4981 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
4982 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
4983 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
4984 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
4985 setPreferenceProperty( xv, "min", 0.0 );
4986 setPreferenceProperty( xv, "max", 1.0 );
4987 setPreferenceProperty( xv, "step", 0.1 );
4988 setPreferenceProperty( xh, "min", 0.0 );
4989 setPreferenceProperty( xh, "max", 1.0 );
4990 setPreferenceProperty( xh, "step", 0.1 );
4991 setPreferenceProperty( yh, "min", 0.0 );
4992 setPreferenceProperty( yh, "max", 1.0 );
4993 setPreferenceProperty( yh, "step", 0.1 );
4994 setPreferenceProperty( wh, "min", 0.0 );
4995 setPreferenceProperty( wh, "max", 1.0 );
4996 setPreferenceProperty( wh, "step", 0.1 );
4997 setPreferenceProperty( hh, "min", 0.0 );
4998 setPreferenceProperty( hh, "max", 1.0 );
4999 setPreferenceProperty( hh, "step", 0.1 );
5001 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5002 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5003 setPreferenceProperty( distributionGr, "columns", 3 );
5005 types.append( tr( "SMESH_MONOCOLOR" ) );
5006 types.append( tr( "SMESH_MULTICOLOR" ) );
5007 indices.clear(); indices.append( 0 ); indices.append( 1 );
5008 setPreferenceProperty( coloringType, "strings", types );
5009 setPreferenceProperty( coloringType, "indexes", indices );
5010 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5014 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5016 if( sect=="SMESH" ) {
5017 float sbX1,sbY1,sbW,sbH;
5018 float aTol = 1.00000009999999;
5019 std::string aWarning;
5020 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5021 if( name=="selection_object_color" || name=="selection_element_color" ||
5022 name=="highlight_color" ||
5023 name=="selection_precision_node" || name=="selection_precision_element" ||
5024 name=="selection_precision_object")
5025 SMESH::UpdateSelectionProp( this );
5026 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5027 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5028 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5029 if(sbX1+sbW > aTol){
5030 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5033 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5034 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5037 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5038 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5039 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5040 if(sbY1+sbH > aTol){
5041 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5042 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5043 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5046 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5047 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5048 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5049 if(sbX1+sbW > aTol){
5050 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5053 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5054 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5057 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5058 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5059 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5060 if(sbY1+sbH > aTol){
5061 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5064 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5065 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5068 else if ( name == "segmentation" ) {
5069 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5070 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5072 else if ( name == "nb_segments_per_edge" ) {
5073 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5074 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5076 else if ( name == "historical_python_dump" ||
5077 name == "forget_mesh_on_hyp_modif") {
5078 QString val = aResourceMgr->stringValue( "SMESH", name );
5079 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5082 if(aWarning.size() != 0){
5083 aWarning += "The default values are applied instead.";
5084 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5085 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5086 QObject::tr(aWarning.c_str()));
5091 //================================================================================
5093 * \brief Update something in accordance with update flags
5094 * \param theFlags - update flags
5096 * Update viewer or/and object browser etc. in accordance with update flags ( see
5097 * LightApp_UpdateFlags enumeration ).
5099 //================================================================================
5100 void SMESHGUI::update( const int flags )
5102 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5103 SMESH::UpdateView();
5105 SalomeApp_Module::update( flags );
5108 //================================================================================
5110 * \brief Set default selection mode
5112 * SLOT called when operation commited. Sets default selection mode
5114 //================================================================================
5115 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5117 SVTK_ViewWindow* vtkWnd =
5118 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5120 vtkWnd->SetSelectionMode( ActorSelection );
5123 //================================================================================
5125 * \brief Set default selection mode
5127 * SLOT called when operation aborted. Sets default selection mode
5129 //================================================================================
5130 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5132 SVTK_ViewWindow* vtkWnd =
5133 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5135 vtkWnd->SetSelectionMode( ActorSelection );
5138 //================================================================================
5140 * \brief Creates operation with given identifier
5141 * \param id - identifier of operation to be started
5142 * \return Pointer on created operation or NULL if operation is not created
5144 * Virtual method redefined from the base class creates operation with given id.
5145 * It is called called automatically from startOperation method of base class.
5147 //================================================================================
5148 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5150 LightApp_Operation* op = 0;
5151 // to do : create operation here
5154 case 417: //convert to quadratic
5155 op = new SMESHGUI_ConvToQuadOp();
5157 case 418: // create 2D mesh as boundary on 3D
5158 op = new SMESHGUI_Make2DFrom3DOp();
5160 case 420: // Reorient faces
5161 op = new SMESHGUI_ReorientFacesOp();
5163 case 701: // Compute mesh
5164 op = new SMESHGUI_ComputeOp();
5166 case 702: // Create mesh
5167 op = new SMESHGUI_MeshOp( true, true );
5169 case 703: // Create sub-mesh
5170 op = new SMESHGUI_MeshOp( true, false );
5172 case 704: // Edit mesh/sub-mesh
5173 op = new SMESHGUI_MeshOp( false );
5175 case 711: // Precompute mesh
5176 op = new SMESHGUI_PrecomputeOp();
5178 case 712: // Evaluate mesh
5179 op = new SMESHGUI_EvaluateOp();
5181 case 713: // Evaluate mesh
5182 op = new SMESHGUI_MeshOrderOp();
5184 case 806: // Create group on geom
5185 op = new SMESHGUI_GroupOnShapeOp();
5187 case 904: // Find element
5188 op = new SMESHGUI_FindElemByPointOp();
5190 case 4067: // Make mesh pass through point
5191 op = new SMESHGUI_MakeNodeAtPointOp();
5193 case 4070: // Create 0D elements on all nodes
5194 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5201 op = SalomeApp_Module::createOperation( id );
5205 //================================================================================
5207 * \brief Stops current operations and starts a given one
5208 * \param id - The id of the operation to start
5210 //================================================================================
5212 void SMESHGUI::switchToOperation(int id)
5214 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5215 activeStudy()->abortAllOperations();
5216 startOperation( id );
5219 LightApp_Displayer* SMESHGUI::displayer()
5222 myDisplayer = new SMESHGUI_Displayer( getApp() );
5226 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5229 int aTolerance = 64;
5230 int anIterations = 0;
5236 if( anIterations % aPeriod == 0 )
5239 if( aTolerance < 1 )
5243 aHue = (int)( 360.0 * rand() / RAND_MAX );
5246 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5247 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5248 for( ; it != itEnd; ++it )
5250 SALOMEDS::Color anAutoColor = *it;
5251 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5254 aQColor.getHsv( &h, &s, &v );
5255 if( abs( h - aHue ) < aTolerance )
5267 aColor.setHsv( aHue, 255, 255 );
5269 SALOMEDS::Color aSColor;
5270 aSColor.R = aColor.redF();
5271 aSColor.G = aColor.greenF();
5272 aSColor.B = aColor.blueF();
5277 const char* gSeparator = "_"; // character used to separate parameter names
5278 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5279 const char* gPathSep = "|"; // character used to separate paths
5282 * \brief Store visual parameters
5284 * This method is called just before the study document is saved.
5285 * Store visual parameters in AttributeParameter attribue(s)
5287 void SMESHGUI::storeVisualParameters (int savePoint)
5290 Kernel_Utils::Localizer loc;
5292 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5293 if (!appStudy || !appStudy->studyDS())
5295 _PTR(Study) studyDS = appStudy->studyDS();
5297 // componentName is used for encoding of entries when storing them in IParameters
5298 std::string componentName = myComponentSMESH->ComponentDataType();
5299 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5300 //if (!aSComponent) return;
5303 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5304 componentName.c_str(),
5306 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5308 // store map of custom markers
5309 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5310 if( !aMarkerMap.empty() )
5312 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5313 for( ; anIter != aMarkerMap.end(); anIter++ )
5315 int anId = anIter->first;
5316 VTK::MarkerData aMarkerData = anIter->second;
5317 std::string aMarkerFileName = aMarkerData.first;
5318 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5319 if( aMarkerTexture.size() < 3 )
5320 continue; // should contain at least width, height and the first value
5322 QString aPropertyName( "texture" );
5323 aPropertyName += gSeparator;
5324 aPropertyName += QString::number( anId );
5326 QString aPropertyValue = aMarkerFileName.c_str();
5327 aPropertyValue += gPathSep;
5329 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5330 ushort aWidth = *aTextureIter++;
5331 ushort aHeight = *aTextureIter++;
5332 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5333 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5334 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5335 aPropertyValue += QString::number( *aTextureIter );
5337 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5341 // viewers counters are used for storing view_numbers in IParameters
5344 // main cycle to store parameters of displayed objects
5345 QList<SUIT_ViewManager*> lst;
5346 QList<SUIT_ViewManager*>::Iterator it;
5347 getApp()->viewManagers(lst);
5348 for (it = lst.begin(); it != lst.end(); it++)
5350 SUIT_ViewManager* vman = *it;
5351 QString vType = vman->getType();
5353 // saving VTK actors properties
5354 if (vType == SVTK_Viewer::Type())
5356 // store the clipping planes attached to the view manager
5357 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5358 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5359 if( anIter != myClippingPlaneInfoMap.end() )
5360 aClippingPlaneInfoList = anIter->second;
5362 if( !aClippingPlaneInfoList.empty() ) {
5363 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5364 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5366 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5367 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5369 QString aPropertyName( "ClippingPlane" );
5370 aPropertyName += gSeparator;
5371 aPropertyName += QString::number( vtkViewers );
5372 aPropertyName += gSeparator;
5373 aPropertyName += QString::number( anId );
5375 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5376 aPropertyValue += gDigitsSep;
5377 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5378 aPropertyValue += gDigitsSep;
5379 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5380 aPropertyValue += gDigitsSep;
5381 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5383 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5387 QVector<SUIT_ViewWindow*> views = vman->getViews();
5388 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5390 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5392 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5393 vtkActorCollection* allActors = aCopy.GetActors();
5394 allActors->InitTraversal();
5395 while (vtkActor* actor = allActors->GetNextActor())
5397 if (actor->GetVisibility()) // store only visible actors
5399 SMESH_Actor* aSmeshActor = 0;
5400 if (actor->IsA("SMESH_Actor"))
5401 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5402 if (aSmeshActor && aSmeshActor->hasIO())
5404 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5407 // entry is "encoded" = it does NOT contain component adress,
5408 // since it is a subject to change on next component loading
5409 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5411 std::string param, vtkParam = vType.toLatin1().data();
5412 vtkParam += gSeparator;
5413 vtkParam += QString::number(vtkViewers).toLatin1().data();
5414 vtkParam += gSeparator;
5417 param = vtkParam + "Visibility";
5418 ip->setParameter(entry, param, "On");
5421 param = vtkParam + "Representation";
5422 ip->setParameter(entry, param, QString::number
5423 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5426 param = vtkParam + "IsShrunk";
5427 ip->setParameter(entry, param, QString::number
5428 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5430 // Displayed entities
5431 unsigned int aMode = aSmeshActor->GetEntityMode();
5432 bool isE = aMode & SMESH_Actor::eEdges;
5433 bool isF = aMode & SMESH_Actor::eFaces;
5434 bool isV = aMode & SMESH_Actor::eVolumes;
5435 bool is0d = aMode & SMESH_Actor::e0DElements;
5436 bool isB = aMode & SMESH_Actor::eBallElem;
5438 QString modeStr ("e");
5439 modeStr += gDigitsSep; modeStr += QString::number(isE);
5440 modeStr += gDigitsSep; modeStr += "f";
5441 modeStr += gDigitsSep; modeStr += QString::number(isF);
5442 modeStr += gDigitsSep; modeStr += "v";
5443 modeStr += gDigitsSep; modeStr += QString::number(isV);
5444 modeStr += gDigitsSep; modeStr += "0d";
5445 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5446 modeStr += gDigitsSep; modeStr += "b";
5447 modeStr += gDigitsSep; modeStr += QString::number(isB);
5449 param = vtkParam + "Entities";
5450 ip->setParameter(entry, param, modeStr.toLatin1().data());
5453 vtkFloatingPointType r, g, b;
5456 aSmeshActor->GetSufaceColor(r, g, b, delta);
5457 QStringList colorStr;
5458 colorStr << "surface";
5459 colorStr << QString::number(r);
5460 colorStr << QString::number(g);
5461 colorStr << QString::number(b);
5463 colorStr << "backsurface";
5464 colorStr << QString::number(delta);
5466 aSmeshActor->GetVolumeColor(r, g, b, delta);
5467 colorStr << "volume";
5468 colorStr << QString::number(r);
5469 colorStr << QString::number(g);
5470 colorStr << QString::number(b);
5471 colorStr << QString::number(delta);
5473 aSmeshActor->GetEdgeColor(r, g, b);
5475 colorStr << QString::number(r);
5476 colorStr << QString::number(g);
5477 colorStr << QString::number(b);
5479 aSmeshActor->GetNodeColor(r, g, b);
5481 colorStr << QString::number(r);
5482 colorStr << QString::number(g);
5483 colorStr << QString::number(b);
5485 aSmeshActor->GetOutlineColor(r, g, b);
5486 colorStr << "outline";
5487 colorStr << QString::number(r);
5488 colorStr << QString::number(g);
5489 colorStr << QString::number(b);
5491 aSmeshActor->Get0DColor(r, g, b);
5492 colorStr << "elem0d";
5493 colorStr << QString::number(r);
5494 colorStr << QString::number(g);
5495 colorStr << QString::number(b);
5497 aSmeshActor->GetBallColor(r, g, b);
5499 colorStr << QString::number(r);
5500 colorStr << QString::number(g);
5501 colorStr << QString::number(b);
5503 aSmeshActor->GetFacesOrientationColor(r, g, b);
5504 colorStr << "orientation";
5505 colorStr << QString::number(r);
5506 colorStr << QString::number(g);
5507 colorStr << QString::number(b);
5509 param = vtkParam + "Colors";
5510 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5513 QStringList sizeStr;
5515 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5516 sizeStr << "outline";
5517 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5518 sizeStr << "elem0d";
5519 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5521 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5522 sizeStr << "shrink";
5523 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5524 sizeStr << "orientation";
5525 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5526 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5528 param = vtkParam + "Sizes";
5529 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5534 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5535 if( aMarkerType == VTK::MT_USER ) {
5536 markerStr += "custom";
5537 markerStr += gDigitsSep;
5538 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5542 markerStr += gDigitsSep;
5543 markerStr += QString::number( (int)aMarkerType );
5544 markerStr += gDigitsSep;
5545 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5548 param = vtkParam + "PointMarker";
5549 ip->setParameter(entry, param, markerStr.toLatin1().data());
5552 param = vtkParam + "Opacity";
5553 ip->setParameter(entry, param,
5554 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5557 param = vtkParam + "ClippingPlane";
5559 if( !aClippingPlaneInfoList.empty() ) {
5560 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5561 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5563 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5564 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5565 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5566 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5567 if( aSmeshActor == *anIter2 ) {
5568 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5569 QString::number( anId ).toLatin1().constData() );
5576 ip->setParameter( entry, param, "Off" );
5577 } // if (io->hasEntry())
5578 } // SMESH_Actor && hasIO
5580 } // while.. actors traversal
5584 } // if (SVTK view model)
5585 } // for (viewManagers)
5588 // data structures for clipping planes processing
5591 vtkIdType Orientation;
5592 vtkFloatingPointType Distance;
5593 vtkFloatingPointType Angle[2];
5595 typedef std::list<TPlaneData> TPlaneDataList;
5596 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5598 typedef std::list<vtkActor*> TActorList;
5601 TActorList ActorList;
5602 SUIT_ViewManager* ViewManager;
5604 typedef std::list<TPlaneInfo> TPlaneInfoList;
5605 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5608 * \brief Restore visual parameters
5610 * This method is called after the study document is opened.
5611 * Restore visual parameters from AttributeParameter attribue(s)
5613 void SMESHGUI::restoreVisualParameters (int savePoint)
5616 Kernel_Utils::Localizer loc;
5618 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5619 if (!appStudy || !appStudy->studyDS())
5621 _PTR(Study) studyDS = appStudy->studyDS();
5623 // componentName is used for encoding of entries when storing them in IParameters
5624 std::string componentName = myComponentSMESH->ComponentDataType();
5625 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5626 //if (!aSComponent) return;
5629 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5630 componentName.c_str(),
5632 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5634 // restore map of custom markers and map of clipping planes
5635 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5636 TPlaneDataMap aPlaneDataMap;
5638 std::vector<std::string> properties = ip->getProperties();
5639 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5641 std::string property = *propIt;
5642 QString aPropertyName( property.c_str() );
5643 QString aPropertyValue( ip->getProperty( property ).c_str() );
5645 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5646 if( aPropertyNameList.isEmpty() )
5649 QString aPropertyType = aPropertyNameList[0];
5650 if( aPropertyType == "texture" )
5652 if( aPropertyNameList.size() != 2 )
5656 int anId = aPropertyNameList[1].toInt( &ok );
5657 if( !ok || anId < 1 )
5660 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5661 if( aPropertyValueList.size() != 2 )
5664 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5665 QString aMarkerTextureString = aPropertyValueList[1];
5666 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5667 if( aMarkerTextureStringList.size() != 3 )
5671 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5676 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5680 VTK::MarkerTexture aMarkerTexture;
5681 aMarkerTexture.push_back( aWidth );
5682 aMarkerTexture.push_back( aHeight );
5684 QString aMarkerTextureData = aMarkerTextureStringList[2];
5685 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5687 QChar aChar = aMarkerTextureData.at( i );
5688 if( aChar.isDigit() )
5689 aMarkerTexture.push_back( aChar.digitValue() );
5692 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5694 else if( aPropertyType == "ClippingPlane" )
5696 if( aPropertyNameList.size() != 3 )
5700 int aViewId = aPropertyNameList[1].toInt( &ok );
5701 if( !ok || aViewId < 0 )
5705 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5706 if( !ok || aClippingPlaneId < 0 )
5709 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5710 if( aPropertyValueList.size() != 4 )
5713 TPlaneData aPlaneData;
5714 aPlaneData.Id = aClippingPlaneId;
5717 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5722 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5727 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5732 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5736 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5737 aPlaneDataList.push_back( aPlaneData );
5741 TPlaneInfoMap aPlaneInfoMap;
5743 std::vector<std::string> entries = ip->getEntries();
5745 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5747 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5748 QString entry (ip->decodeEntry(*entIt).c_str());
5750 // Check that the entry corresponds to a real object in the Study
5751 // as the object may be deleted or modified after the visual state is saved.
5752 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5753 if (!so) continue; //Skip the not existent entry
5755 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5756 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5758 std::vector<std::string>::iterator namesIt = paramNames.begin();
5759 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5761 // actors are stored in a map after displaying of them for
5762 // quicker access in the future: map < viewID to actor >
5763 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5765 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5767 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5768 // '_' is used as separator and should not be used in viewer type or parameter names.
5769 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5770 if (lst.size() != 3)
5773 QString viewerTypStr = lst[0];
5774 QString viewIndexStr = lst[1];
5775 QString paramNameStr = lst[2];
5778 int viewIndex = viewIndexStr.toUInt(&ok);
5779 if (!ok) // bad conversion of view index to integer
5783 if (viewerTypStr == SVTK_Viewer::Type())
5785 SMESH_Actor* aSmeshActor = 0;
5786 if (vtkActors.IsBound(viewIndex))
5787 aSmeshActor = vtkActors.Find(viewIndex);
5789 QList<SUIT_ViewManager*> lst;
5790 getApp()->viewManagers(viewerTypStr, lst);
5792 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5793 SUIT_ViewManager* vman = NULL;
5794 if (viewIndex >= 0 && viewIndex < lst.count())
5795 vman = lst.at(viewIndex);
5797 if (paramNameStr == "Visibility")
5799 if (!aSmeshActor && displayer() && vman)
5801 SUIT_ViewModel* vmodel = vman->getViewModel();
5802 // SVTK view model can be casted to SALOME_View
5803 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5805 // store displayed actor in a temporary map for quicker
5806 // access later when restoring other parameters
5807 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5808 vtkRenderer* Renderer = vtkView->getRenderer();
5809 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5810 vtkActorCollection* theActors = aCopy.GetActors();
5811 theActors->InitTraversal();
5812 bool isFound = false;
5813 vtkActor *ac = theActors->GetNextActor();
5814 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5815 if (ac->IsA("SMESH_Actor")) {
5816 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5817 if (aGeomAc->hasIO()) {
5818 Handle(SALOME_InteractiveObject) io =
5819 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5820 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5822 vtkActors.Bind(viewIndex, aGeomAc);
5828 } // if (paramNameStr == "Visibility")
5831 // the rest properties "work" with SMESH_Actor
5834 QString val ((*valuesIt).c_str());
5837 if (paramNameStr == "Representation") {
5838 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5841 else if (paramNameStr == "IsShrunk") {
5843 if (!aSmeshActor->IsShrunk())
5844 aSmeshActor->SetShrink();
5847 if (aSmeshActor->IsShrunk())
5848 aSmeshActor->UnShrink();
5851 // Displayed entities
5852 else if (paramNameStr == "Entities") {
5853 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5854 int aEntityMode = SMESH_Actor::eAllEntity;
5855 for ( int i = 0; i < mode.count(); i+=2 ) {
5856 if ( i < mode.count()-1 ) {
5857 QString type = mode[i];
5858 bool val = mode[i+1].toInt();
5859 if ( type == "e" && !val )
5860 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
5861 else if ( type == "f" && !val )
5862 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
5863 else if ( type == "v" && !val )
5864 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
5865 else if ( type == "0d" && !val )
5866 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
5867 else if ( type == "b" && !val )
5868 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
5871 aSmeshActor->SetEntityMode( aEntityMode );
5874 else if (paramNameStr == "Colors") {
5875 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5882 QColor outlineColor;
5883 QColor orientationColor;
5889 // below lines are required to get default values for delta coefficients
5890 // of backface color for faces and color of reversed volumes
5891 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
5892 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
5893 for ( int i = 0; i < colors.count(); i++ ) {
5894 QString type = colors[i];
5895 if ( type == "surface" ) {
5896 // face color is set by 3 values r:g:b, where
5897 // - r,g,b - is rgb color components
5898 if ( i+1 >= colors.count() ) break; // format error
5899 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5900 if ( i+2 >= colors.count() ) break; // format error
5901 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5902 if ( i+3 >= colors.count() ) break; // format error
5903 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5904 faceColor.setRgbF( r, g, b );
5907 else if ( type == "backsurface" ) {
5908 // backface color can be defined in several ways
5909 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
5910 // - in latest versions, it is set as delta coefficient
5911 bool rgbOk = false, deltaOk;
5912 if ( i+1 >= colors.count() ) break; // format error
5913 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5914 int delta = colors[i+1].toInt( &deltaOk );
5916 if ( i+1 < colors.count() ) // index is shifted to 1
5917 g = colors[i+1].toDouble( &rgbOk );
5918 if ( rgbOk ) i++; // shift index
5919 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
5920 b = colors[i+1].toDouble( &rgbOk );
5922 // - as currently there's no way to set directly backsurface color as it was before,
5923 // we ignore old dump where r,g,b triple was set
5924 // - also we check that delta parameter is set properly
5925 if ( !rgbOk && deltaOk )
5928 else if ( type == "volume" ) {
5929 // volume color is set by 4 values r:g:b:delta, where
5930 // - r,g,b - is a normal volume rgb color components
5931 // - delta - is a reversed volume color delta coefficient
5932 if ( i+1 >= colors.count() ) break; // format error
5933 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5934 if ( i+2 >= colors.count() ) break; // format error
5935 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5936 if ( i+3 >= colors.count() ) break; // format error
5937 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5938 if ( i+4 >= colors.count() ) break; // format error
5939 int delta = colors[i+4].toInt( &bOk );
5940 if ( !bOk ) break; // format error
5941 volumeColor.setRgbF( r, g, b );
5945 else if ( type == "edge" ) {
5946 // edge color is set by 3 values r:g:b, where
5947 // - r,g,b - is rgb color components
5948 if ( i+1 >= colors.count() ) break; // format error
5949 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5950 if ( i+2 >= colors.count() ) break; // format error
5951 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5952 if ( i+3 >= colors.count() ) break; // format error
5953 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5954 edgeColor.setRgbF( r, g, b );
5957 else if ( type == "node" ) {
5958 // node color is set by 3 values r:g:b, where
5959 // - r,g,b - is rgb color components
5960 if ( i+1 >= colors.count() ) break; // format error
5961 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5962 if ( i+2 >= colors.count() ) break; // format error
5963 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5964 if ( i+3 >= colors.count() ) break; // format error
5965 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5966 nodeColor.setRgbF( r, g, b );
5969 else if ( type == "elem0d" ) {
5970 // 0d element color is set by 3 values r:g:b, where
5971 // - r,g,b - is rgb color components
5972 if ( i+1 >= colors.count() ) break; // format error
5973 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5974 if ( i+2 >= colors.count() ) break; // format error
5975 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5976 if ( i+3 >= colors.count() ) break; // format error
5977 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5978 elem0dColor.setRgbF( r, g, b );
5981 else if ( type == "ball" ) {
5982 // ball color is set by 3 values r:g:b, where
5983 // - r,g,b - is rgb color components
5984 if ( i+1 >= colors.count() ) break; // format error
5985 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5986 if ( i+2 >= colors.count() ) break; // format error
5987 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5988 if ( i+3 >= colors.count() ) break; // format error
5989 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5990 ballColor.setRgbF( r, g, b );
5993 else if ( type == "outline" ) {
5994 // outline color is set by 3 values r:g:b, where
5995 // - r,g,b - is rgb color components
5996 if ( i+1 >= colors.count() ) break; // format error
5997 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5998 if ( i+2 >= colors.count() ) break; // format error
5999 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6000 if ( i+3 >= colors.count() ) break; // format error
6001 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6002 outlineColor.setRgbF( r, g, b );
6005 else if ( type == "orientation" ) {
6006 // orientation color is set by 3 values r:g:b, where
6007 // - r,g,b - is rgb color components
6008 if ( i+1 >= colors.count() ) break; // format error
6009 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6010 if ( i+2 >= colors.count() ) break; // format error
6011 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6012 if ( i+3 >= colors.count() ) break; // format error
6013 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6014 orientationColor.setRgbF( r, g, b );
6019 if ( nodeColor.isValid() )
6020 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6022 if ( edgeColor.isValid() )
6023 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6025 if ( faceColor.isValid() )
6026 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6028 if ( volumeColor.isValid() )
6029 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6030 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6031 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6033 if ( elem0dColor.isValid() )
6034 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6036 if ( ballColor.isValid() )
6037 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6039 if ( outlineColor.isValid() )
6040 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6041 // orientation color
6042 if ( orientationColor.isValid() )
6043 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6046 else if (paramNameStr == "Sizes") {
6047 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6050 int outlineWidth = -1;
6051 int elem0dSize = -1;
6053 double shrinkSize = -1;
6054 double orientationSize = -1;
6055 bool orientation3d = false;
6056 for ( int i = 0; i < sizes.count(); i++ ) {
6057 QString type = sizes[i];
6058 if ( type == "line" ) {
6059 // line (wireframe) width is given as single integer value
6060 if ( i+1 >= sizes.count() ) break; // format error
6061 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6065 if ( type == "outline" ) {
6066 // outline width is given as single integer value
6067 if ( i+1 >= sizes.count() ) break; // format error
6068 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6072 else if ( type == "elem0d" ) {
6073 // 0d element size is given as single integer value
6074 if ( i+1 >= sizes.count() ) break; // format error
6075 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6079 else if ( type == "ball" ) {
6080 // ball size is given as single integer value
6081 if ( i+1 >= sizes.count() ) break; // format error
6082 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6086 else if ( type == "shrink" ) {
6087 // shrink factor is given as single floating point value
6088 if ( i+1 >= sizes.count() ) break; // format error
6089 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6093 else if ( type == "orientation" ) {
6094 // orientation vectors are specified by two values size:3d, where
6095 // - size - is a floating point value specifying scale factor
6096 // - 3d - is a boolean
6097 if ( i+1 >= sizes.count() ) break; // format error
6098 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6099 if ( i+2 >= sizes.count() ) break; // format error
6100 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6101 orientationSize = v1;
6102 orientation3d = (bool)v2;
6106 // line (wireframe) width
6107 if ( lineWidth > 0 )
6108 aSmeshActor->SetLineWidth( lineWidth );
6110 if ( outlineWidth > 0 )
6111 aSmeshActor->SetOutlineWidth( outlineWidth );
6112 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6113 aSmeshActor->SetOutlineWidth( lineWidth );
6115 if ( elem0dSize > 0 )
6116 aSmeshActor->Set0DSize( elem0dSize );
6119 aSmeshActor->SetBallSize( ballSize );
6121 if ( shrinkSize > 0 )
6122 aSmeshActor->SetShrinkFactor( shrinkSize );
6123 // orientation vectors
6124 if ( orientationSize > 0 ) {
6125 aSmeshActor->SetFacesOrientationScale( orientationSize );
6126 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6130 else if (paramNameStr == "PointMarker") {
6131 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6132 if( data.count() >= 2 ) {
6134 int aParam1 = data[1].toInt( &ok );
6136 if( data[0] == "std" && data.count() == 3 ) {
6137 int aParam2 = data[2].toInt( &ok );
6138 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6140 else if( data[0] == "custom" ) {
6141 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6142 if( markerIt != aMarkerMap.end() ) {
6143 VTK::MarkerData aMarkerData = markerIt->second;
6144 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6151 else if (paramNameStr == "Opacity") {
6152 aSmeshActor->SetOpacity(val.toFloat());
6155 else if (paramNameStr.startsWith("ClippingPlane")) {
6156 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6157 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
6158 // new format - val looks like "Off" or "0" (plane id)
6159 // (note: in new format "Off" value is used only for consistency,
6160 // so it is processed together with values in old format)
6161 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
6162 if( anIsOldFormat ) {
6163 if (paramNameStr == "ClippingPlane1" || val == "Off")
6164 aSmeshActor->RemoveAllClippingPlanes();
6166 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
6167 double aDistance = vals[1].toFloat();
6168 vtkFloatingPointType anAngle[2];
6169 anAngle[0] = vals[2].toFloat();
6170 anAngle[1] = vals[3].toFloat();
6172 QList<SUIT_ViewManager*> lst;
6173 getApp()->viewManagers(viewerTypStr, lst);
6174 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6175 if (viewIndex >= 0 && viewIndex < lst.count()) {
6176 SUIT_ViewManager* vman = lst.at(viewIndex);
6177 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6179 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6181 SMESH::TActorList anActorList;
6182 anActorList.push_back( aSmeshActor );
6183 SMESH::OrientedPlane* aPlane =
6184 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
6186 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6187 aClippingPlaneInfo.Plane = aPlane;
6188 aClippingPlaneInfo.ActorList = anActorList;
6189 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6196 int aPlaneId = val.toInt( &ok );
6197 if( ok && aPlaneId >= 0 ) {
6198 bool anIsDefinedPlane = false;
6199 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6200 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6201 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6202 TPlaneInfo& aPlaneInfo = *anIter;
6203 if( aPlaneInfo.PlaneId == aPlaneId ) {
6204 aPlaneInfo.ActorList.push_back( aSmeshActor );
6205 anIsDefinedPlane = true;
6209 if( !anIsDefinedPlane ) {
6210 TPlaneInfo aPlaneInfo;
6211 aPlaneInfo.PlaneId = aPlaneId;
6212 aPlaneInfo.ActorList.push_back( aSmeshActor );
6213 aPlaneInfo.ViewManager = vman;
6215 // to make the list sorted by plane id
6216 anIter = aPlaneInfoList.begin();
6217 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6218 const TPlaneInfo& aPlaneInfoRef = *anIter;
6219 if( aPlaneInfoRef.PlaneId > aPlaneId )
6222 aPlaneInfoList.insert( anIter, aPlaneInfo );
6227 } // if (aSmeshActor)
6228 } // other parameters than Visibility
6230 } // for names/parameters iterator
6231 } // for entries iterator
6233 // take into account planes with empty list of actors referred to them
6234 QList<SUIT_ViewManager*> aVMList;
6235 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6237 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6238 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6239 int aViewId = aPlaneDataIter->first;
6240 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6241 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6243 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6245 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6246 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6247 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6248 const TPlaneData& aPlaneData = *anIter2;
6249 int aPlaneId = aPlaneData.Id;
6251 bool anIsFound = false;
6252 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6253 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6254 const TPlaneInfo& aPlaneInfo = *anIter3;
6255 if( aPlaneInfo.PlaneId == aPlaneId ) {
6262 TPlaneInfo aPlaneInfo; // ActorList field is empty
6263 aPlaneInfo.PlaneId = aPlaneId;
6264 aPlaneInfo.ViewManager = aViewManager;
6266 // to make the list sorted by plane id
6267 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6268 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6269 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6270 if( aPlaneInfoRef.PlaneId > aPlaneId )
6273 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6279 // add clipping planes to actors according to the restored parameters
6280 // and update the clipping plane map
6281 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6282 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6283 int aViewId = anIter1->first;
6284 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6286 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6287 if( anIter2 == aPlaneDataMap.end() )
6289 const TPlaneDataList& aPlaneDataList = anIter2->second;
6291 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6292 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6293 const TPlaneInfo& aPlaneInfo = *anIter3;
6294 int aPlaneId = aPlaneInfo.PlaneId;
6295 const TActorList& anActorList = aPlaneInfo.ActorList;
6296 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6300 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6304 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6306 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6307 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6308 const TPlaneData& aPlaneData = *anIter4;
6309 if( aPlaneData.Id == aPlaneId ) {
6310 SMESH::OrientedPlane* aPlane =
6311 SMESHGUI_ClippingDlg::AddPlane( anActorList,
6313 (SMESH::Orientation)aPlaneData.Orientation,
6314 aPlaneData.Distance,
6317 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6318 aClippingPlaneInfo.Plane = aPlane;
6319 aClippingPlaneInfo.ActorList = anActorList;
6320 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6328 // update all VTK views
6329 QList<SUIT_ViewManager*> lst;
6330 getApp()->viewManagers(lst);
6331 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6332 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6333 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6334 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6335 vtkView->getRenderer()->ResetCameraClippingRange();
6342 \brief Adds preferences for dfont of VTK viewer
6344 \param pIf group identifier
6345 \param param parameter
6346 \return identifier of preferences
6348 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
6350 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6352 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6355 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6356 fam.append( tr( "SMESH_FONT_COURIER" ) );
6357 fam.append( tr( "SMESH_FONT_TIMES" ) );
6359 setPreferenceProperty( tfont, "fonts", fam );
6361 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6362 setPreferenceProperty( tfont, "features", f );
6368 \brief Actions after hypothesis edition
6369 Updates object browser after hypothesis edition
6371 void SMESHGUI::onHypothesisEdit( int result )
6374 SMESHGUI::Modified();
6375 updateObjBrowser( true );
6380 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6381 \param pview view being closed
6383 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6384 #ifndef DISABLE_PLOT2DVIEWER
6385 //Crear all Plot2d Viewers if need.
6386 SMESH::ClearPlot2Viewers(pview);
6390 void SMESHGUI::message( const QString& msg )
6393 QStringList data = msg.split("/");
6394 if ( data.count() > 0 ) {
6395 if ( data.first() == "mesh_loading" ) {
6397 QString entry = data.count() > 1 ? data[1] : QString();
6398 if ( entry.isEmpty() )
6401 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6403 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6406 name = obj->GetName().c_str();
6407 if ( name.isEmpty() )
6410 if ( data.last() == "stop" )
6411 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6413 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6414 QApplication::processEvents();
6420 \brief Connects or disconnects signals about activating and cloning view on the module slots
6421 \param pview view which is connected/disconnected
6423 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6427 SUIT_ViewManager* viewMgr = pview->getViewManager();
6429 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6430 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6432 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6433 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6438 \brief Return \c true if object can be renamed
6440 bool SMESHGUI::renameAllowed( const QString& entry) const {
6441 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6445 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6449 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6454 if(appStudy->isComponent(entry) || obj->isReference())
6457 // check type to prevent renaming of inappropriate objects
6458 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6459 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6460 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6461 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6462 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6463 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6470 Rename object by entry.
6471 \param entry entry of the object
6472 \param name new name of the object
6473 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6475 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6477 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6481 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6486 _PTR(Study) aStudy = appStudy->studyDS();
6491 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6493 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6498 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6499 _PTR(GenericAttribute) anAttr;
6500 _PTR(AttributeName) aName;
6502 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6504 // check type to prevent renaming of inappropriate objects
6505 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6506 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6507 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6508 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6509 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6510 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6511 if ( !name.isEmpty() ) {
6512 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6514 // update name of group object and its actor
6515 Handle(SALOME_InteractiveObject) IObject =
6516 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6518 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6519 if( !aGroupObject->_is_nil() ) {
6520 aGroupObject->SetName( qPrintable(name) );
6521 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6522 anActor->setName( qPrintable(name) );