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" )
1896 if ( CORBA::is_nil( myComponentSMESH ) )
1898 CORBA::Boolean anIsEmbeddedMode;
1899 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1900 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1902 // 0019923: EDF 765 SMESH : default values of hypothesis
1903 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1904 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1905 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1906 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1907 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1909 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1910 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1911 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1913 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1914 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1918 myActiveDialogBox = 0;
1919 myFilterLibraryDlg = 0;
1923 myEventCallbackCommand = vtkCallbackCommand::New();
1924 myEventCallbackCommand->Delete();
1925 myEventCallbackCommand->SetClientData( this );
1926 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1929 SMESH::GetFilterManager();
1930 SMESH::GetPattern();
1931 SMESH::GetMeasurements();
1933 /* load resources for all available meshers */
1934 SMESH::InitAvailableHypotheses();
1937 //=============================================================================
1941 //=============================================================================
1942 SMESHGUI::~SMESHGUI()
1944 #ifdef WITHGENERICOBJ
1945 SMESH::GetFilterManager()->UnRegister();
1946 SMESH::GetMeasurements()->UnRegister();
1948 SMESH::GetFilterManager() = SMESH::FilterManager::_nil();
1949 SMESH::GetMeasurements() = SMESH::Measurements::_nil();
1952 //=============================================================================
1956 //=============================================================================
1957 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1959 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1961 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1966 //=============================================================================
1970 //=============================================================================
1971 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1973 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1977 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
1978 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1979 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
1980 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
1981 return autoUpdate && !exceeded;
1984 //=============================================================================
1988 //=============================================================================
1989 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
1991 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
1994 //=============================================================================
1998 //=============================================================================
1999 SMESHGUI* SMESHGUI::GetSMESHGUI()
2001 SMESHGUI* smeshMod = 0;
2002 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2005 CAM_Module* module = app->module( "Mesh" );
2006 smeshMod = dynamic_cast<SMESHGUI*>( module );
2009 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2011 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2014 _PTR(Study) aStudy = study->studyDS();
2016 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2025 Standard_EXPORT SMESHGUI* GetComponentGUI()
2027 return SMESHGUI::GetSMESHGUI();
2031 //=============================================================================
2035 //=============================================================================
2036 void SMESHGUI::SetState(int aState)
2041 //=============================================================================
2045 //=============================================================================
2046 void SMESHGUI::ResetState()
2051 //=============================================================================
2055 //=============================================================================
2056 void SMESHGUI::EmitSignalDeactivateDialog()
2058 emit SignalDeactivateActiveDialog();
2061 //=============================================================================
2065 //=============================================================================
2066 void SMESHGUI::EmitSignalStudyFrameChanged()
2068 emit SignalStudyFrameChanged();
2071 //=============================================================================
2075 //=============================================================================
2076 void SMESHGUI::EmitSignalCloseAllDialogs()
2078 emit SignalCloseAllDialogs();
2081 //=============================================================================
2085 //=============================================================================
2086 void SMESHGUI::EmitSignalVisibilityChanged()
2088 emit SignalVisibilityChanged();
2091 //=============================================================================
2095 //=============================================================================
2096 QDialog *SMESHGUI::GetActiveDialogBox()
2098 return myActiveDialogBox;
2101 //=============================================================================
2105 //=============================================================================
2106 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2108 myActiveDialogBox = (QDialog *) aDlg;
2112 //=============================================================================
2116 //=============================================================================
2117 SUIT_Desktop* SMESHGUI::desktop()
2119 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2121 return app->desktop();
2126 //=============================================================================
2130 //=============================================================================
2131 SalomeApp_Study* SMESHGUI::activeStudy()
2133 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2135 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2140 //=============================================================================
2144 //=============================================================================
2145 void SMESHGUI::Modified( bool theIsUpdateActions )
2147 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2148 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2149 appStudy->Modified();
2150 if( theIsUpdateActions )
2151 app->updateActions();
2156 //=============================================================================
2160 //=============================================================================
2161 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2163 /* Here the position is on the bottom right corner - 10 */
2164 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2166 SUIT_Desktop *PP = desktop();
2167 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2168 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2172 //=============================================================================
2176 //=============================================================================
2177 static int isStudyLocked(_PTR(Study) theStudy){
2178 return theStudy->GetProperties()->IsLocked();
2181 static bool checkLock(_PTR(Study) theStudy) {
2182 if (isStudyLocked(theStudy)) {
2183 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2184 QObject::tr("WRN_WARNING"),
2185 QObject::tr("WRN_STUDY_LOCKED") );
2191 //=======================================================================
2192 //function : CheckActiveStudyLocked
2194 //=======================================================================
2196 bool SMESHGUI::isActiveStudyLocked()
2198 _PTR(Study) aStudy = activeStudy()->studyDS();
2199 return checkLock( aStudy );
2202 //=============================================================================
2206 //=============================================================================
2207 bool SMESHGUI::OnGUIEvent( int theCommandID )
2209 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2213 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2214 SUIT_ResourceMgr* mgr = resourceMgr();
2218 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2219 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2222 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2223 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2225 //QAction* act = action( theCommandID );
2227 switch (theCommandID) {
2229 if(checkLock(aStudy)) break;
2241 if(checkLock(aStudy)) break;
2242 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2246 case 150: //MED FILE INFORMATION
2248 SALOME_ListIO selected;
2249 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2251 aSel->selectedObjects( selected );
2252 if( selected.Extent() )
2254 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2255 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2256 if ( !aMesh->_is_nil() )
2258 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2265 case 122: // EXPORT MED
2280 ::ExportMeshToFile(theCommandID);
2284 case 200: // SCALAR BAR
2286 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2287 SALOME_ListIO selected;
2289 aSel->selectedObjects( selected );
2291 if( selected.Extent() ) {
2292 Handle(SALOME_InteractiveObject) anIO = selected.First();
2293 if( anIO->hasEntry() ) {
2294 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2295 anActor->SetControlMode( SMESH_Actor::eNone );
2296 #ifndef DISABLE_PLOT2DVIEWER
2297 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2306 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2311 // dump control distribution data to the text file
2312 ::SaveDistribution();
2318 // show/ distribution
2319 ::ShowDistribution();
2323 #ifndef DISABLE_PLOT2DVIEWER
2326 // plot distribution
2327 ::PlotDistribution();
2338 ::DisableAutoColor();
2341 case 1134: // Clipping
2342 case 1133: // Tranparency
2343 case 1132: // Display preferences (colors, shrink size, line width, ...)
2350 ::SetDisplayMode(theCommandID, myMarkerMap);
2353 //2D quadratic representation
2356 ::SetDisplayMode(theCommandID, myMarkerMap);
2360 case 216: // 0D elements
2363 case 219: // Volumes
2364 case 220: // All Entity
2366 ::SetDisplayEntity(theCommandID);
2369 case 221: // Orientation of faces
2371 LightApp_SelectionMgr* mgr = selectionMgr();
2372 SALOME_ListIO selected; mgr->selectedObjects( selected );
2374 SALOME_ListIteratorOfListIO it(selected);
2375 for( ; it.More(); it.Next()) {
2376 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2377 if(anIObject->hasEntry()) {
2378 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2379 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2388 if(checkLock(aStudy)) break;
2390 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2393 SMESH::UpdateView();
2395 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2396 SMESH::OnVisuException();
2398 catch (...) { // PAL16774 (Crash after display of many groups)
2399 SMESH::OnVisuException();
2403 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2404 aSel->selectedObjects( l );
2405 aSel->setSelectedObjects( l );
2410 case 301: // DISPLAY
2411 case 302: // DISPLAY ONLY
2413 SMESH::EDisplaing anAction;
2414 switch (theCommandID) {
2415 case 300: anAction = SMESH::eErase; break;
2416 case 301: anAction = SMESH::eDisplay; break;
2417 case 302: anAction = SMESH::eDisplayOnly; break;
2420 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2421 SALOME_ListIO sel_objects, to_process;
2423 aSel->selectedObjects( sel_objects );
2425 if( theCommandID==302 )
2427 MESSAGE("anAction = SMESH::eDisplayOnly");
2428 startOperation( myEraseAll );
2431 extractContainers( sel_objects, to_process );
2434 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2438 SALOME_ListIteratorOfListIO It( to_process );
2439 for ( ; It.More(); It.Next()) {
2441 Handle(SALOME_InteractiveObject) IOS = It.Value();
2442 if (IOS->hasEntry()) {
2444 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2445 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2446 break; // PAL16774 (Crash after display of many groups)
2448 if (anAction == SMESH::eDisplayOnly)
2450 MESSAGE("anAction = SMESH::eDisplayOnly");
2451 anAction = SMESH::eDisplay;
2457 // PAL13338 + PAL15161 -->
2458 if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2459 MESSAGE("anAction = SMESH::eDisplayOnly");
2460 SMESH::UpdateView();
2461 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2463 // PAL13338 + PAL15161 <--
2465 catch (...) { // PAL16774 (Crash after display of many groups)
2466 SMESH::OnVisuException();
2469 if (anAction == SMESH::eErase) {
2470 MESSAGE("anAction == SMESH::eErase");
2472 aSel->setSelectedObjects( l1 );
2475 aSel->setSelectedObjects( to_process );
2482 if(checkLock(aStudy)) break;
2485 EmitSignalDeactivateDialog();
2487 ( new SMESHGUI_NodesDlg( this ) )->show();
2490 SUIT_MessageBox::warning(desktop(),
2491 tr("SMESH_WRN_WARNING"),
2492 tr("SMESH_WRN_VIEWER_VTK"));
2497 case 2151: // FILTER
2501 EmitSignalDeactivateDialog();
2502 ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2507 case 701: // COMPUTE MESH
2508 case 711: // PRECOMPUTE MESH
2509 case 712: // EVALUATE MESH
2510 case 713: // MESH ORDER
2511 case 702: // Create mesh
2512 case 703: // Create sub-mesh
2513 case 704: // Edit mesh/sub-mesh
2514 startOperation( theCommandID );
2516 case 705: // copy mesh
2518 if (checkLock(aStudy)) break;
2519 EmitSignalDeactivateDialog();
2520 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2523 case 710: // Build compound mesh
2525 if (checkLock(aStudy)) break;
2526 EmitSignalDeactivateDialog();
2527 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2531 case 407: // DIAGONAL INVERSION
2532 case 408: // Delete diagonal
2536 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2537 tr( "NOT_A_VTK_VIEWER" ) );
2541 if ( checkLock( aStudy ) )
2544 /*Standard_Boolean aRes;
2545 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2546 if ( aMesh->_is_nil() )
2548 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2549 tr( "SMESH_BAD_SELECTION" ) );
2553 EmitSignalDeactivateDialog();
2554 if ( theCommandID == 407 )
2555 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2557 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2560 case 409: // Change orientation
2561 case 410: // Union of triangles
2562 case 411: // Cutting of quadrangles
2563 case 419: // Splitting volumes into tetrahedra
2567 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2568 tr( "NOT_A_VTK_VIEWER" ) );
2572 if ( checkLock( aStudy ) )
2575 EmitSignalDeactivateDialog();
2576 SMESHGUI_MultiEditDlg* aDlg = NULL;
2577 if ( theCommandID == 409 )
2578 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2579 else if ( theCommandID == 410 )
2580 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2581 else if ( theCommandID == 419 )
2582 aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2584 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2589 case 412: // Smoothing
2591 if(checkLock(aStudy)) break;
2593 EmitSignalDeactivateDialog();
2594 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2597 SUIT_MessageBox::warning(desktop(),
2598 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2602 case 413: // Extrusion
2604 if (checkLock(aStudy)) break;
2606 EmitSignalDeactivateDialog();
2607 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2609 SUIT_MessageBox::warning(desktop(),
2610 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2614 case 414: // Revolution
2616 if(checkLock(aStudy)) break;
2618 EmitSignalDeactivateDialog();
2619 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2622 SUIT_MessageBox::warning(desktop(),
2623 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2627 case 415: // Pattern mapping
2629 if ( checkLock( aStudy ) )
2633 EmitSignalDeactivateDialog();
2634 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2637 SUIT_MessageBox::warning(desktop(),
2638 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2642 case 416: // Extrusion along a path
2644 if (checkLock(aStudy)) break;
2646 EmitSignalDeactivateDialog();
2647 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2649 SUIT_MessageBox::warning(desktop(),
2650 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2654 case 417: // Convert mesh to quadratic
2655 case 418: // create 2D mesh from 3D
2656 case 420: // Reorient faces
2657 case 806: // CREATE GEO GROUP
2659 startOperation( theCommandID );
2662 case 801: // CREATE GROUP
2666 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2667 tr( "NOT_A_VTK_VIEWER" ) );
2671 if(checkLock(aStudy)) break;
2672 EmitSignalDeactivateDialog();
2673 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2675 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2676 SALOME_ListIO selected;
2678 aSel->selectedObjects( selected );
2680 int nbSel = selected.Extent();
2682 // check if mesh is selected
2683 aMesh = SMESH::GetMeshByIO( selected.First() );
2685 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2690 case 802: // CONSTRUCT GROUP
2694 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2695 tr( "NOT_A_VTK_VIEWER" ) );
2699 if(checkLock(aStudy)) break;
2700 EmitSignalDeactivateDialog();
2702 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2703 SALOME_ListIO selected;
2705 aSel->selectedObjects( selected );
2707 int nbSel = selected.Extent();
2709 // check if submesh is selected
2710 Handle(SALOME_InteractiveObject) IObject = selected.First();
2711 if (IObject->hasEntry()) {
2712 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2714 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2715 if (!aSubMesh->_is_nil()) {
2717 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2718 // get submesh elements list by types
2719 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2720 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2721 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2722 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2723 // create group for each type o elements
2724 QString aName = IObject->getName();
2725 QStringList anEntryList;
2726 if (aNodes->length() > 0) {
2727 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2728 aGroup->Add(aNodes.inout());
2729 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2730 anEntryList.append( aSObject->GetID().c_str() );
2732 if (aEdges->length() > 0) {
2733 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2734 aGroup->Add(aEdges.inout());
2735 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2736 anEntryList.append( aSObject->GetID().c_str() );
2738 if (aFaces->length() > 0) {
2739 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2740 aGroup->Add(aFaces.inout());
2741 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2742 anEntryList.append( aSObject->GetID().c_str() );
2744 if (aVolumes->length() > 0) {
2745 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2746 aGroup->Add(aVolumes.inout());
2747 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2748 anEntryList.append( aSObject->GetID().c_str() );
2751 anApp->browseObjects( anEntryList );
2753 catch(const SALOME::SALOME_Exception & S_ex){
2754 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2761 SUIT_MessageBox::warning(desktop(),
2762 tr("SMESH_WRN_WARNING"),
2763 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2768 case 803: // EDIT GROUP
2772 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2773 tr( "NOT_A_VTK_VIEWER" ) );
2777 if(checkLock(aStudy)) break;
2778 EmitSignalDeactivateDialog();
2780 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2781 SALOME_ListIO selected;
2783 aSel->selectedObjects( selected );
2785 SALOME_ListIteratorOfListIO It (selected);
2786 int nbSelectedGroups = 0;
2787 for ( ; It.More(); It.Next() )
2789 SMESH::SMESH_GroupBase_var aGroup =
2790 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2791 if (!aGroup->_is_nil()) {
2793 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2797 if (nbSelectedGroups == 0)
2799 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2805 case 804: // Add elements to group
2807 if(checkLock(aStudy)) break;
2808 if (myState == 800) {
2809 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2810 if (aDlg) aDlg->onAdd();
2815 case 805: // Remove elements from group
2817 if(checkLock(aStudy)) break;
2818 if (myState == 800) {
2819 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2820 if (aDlg) aDlg->onRemove();
2825 case 815: // Edit GEOM GROUP as standalone
2829 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2830 tr( "NOT_A_VTK_VIEWER" ) );
2834 if(checkLock(aStudy)) break;
2835 EmitSignalDeactivateDialog();
2837 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2838 SALOME_ListIO selected;
2840 aSel->selectedObjects( selected );
2842 SALOME_ListIteratorOfListIO It (selected);
2843 for ( ; It.More(); It.Next() )
2845 SMESH::SMESH_GroupOnGeom_var aGroup =
2846 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2847 if (!aGroup->_is_nil()) {
2848 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2853 SMESH::SMESH_GroupOnFilter_var aGroup =
2854 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2855 if (!aGroup->_is_nil()) {
2856 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2864 case 810: // Union Groups
2865 case 811: // Intersect groups
2866 case 812: // Cut groups
2870 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2871 tr( "NOT_A_VTK_VIEWER" ) );
2875 if ( checkLock( aStudy ) )
2878 EmitSignalDeactivateDialog();
2880 SMESHGUI_GroupOpDlg* aDlg = 0;
2881 if ( theCommandID == 810 )
2882 aDlg = new SMESHGUI_UnionGroupsDlg( this );
2883 else if ( theCommandID == 811 )
2884 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2886 aDlg = new SMESHGUI_CutGroupsDlg( this );
2893 case 814: // Create groups of entities from existing groups of superior dimensions
2895 if ( checkLock( aStudy ) )
2898 EmitSignalDeactivateDialog();
2899 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2905 case 813: // Delete groups with their contents
2909 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2910 tr( "NOT_A_VTK_VIEWER" ) );
2914 if ( checkLock( aStudy ) )
2917 EmitSignalDeactivateDialog();
2919 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2923 case 900: // MESH INFOS
2924 case 903: // WHAT IS
2926 int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2927 EmitSignalDeactivateDialog();
2928 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2929 SALOME_ListIO selected;
2931 aSel->selectedObjects( selected );
2933 if ( selected.Extent() > 1 ) { // a dlg for each IO
2934 SALOME_ListIteratorOfListIO It( selected );
2935 for ( ; It.More(); It.Next() ) {
2936 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2937 dlg->showInfo( It.Value() );
2942 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2948 case 904: // FIND ELEM
2950 startOperation( theCommandID );
2954 case 1100: // EDIT HYPOTHESIS
2956 if(checkLock(aStudy)) break;
2958 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2959 SALOME_ListIO selected;
2961 aSel->selectedObjects( selected );
2963 int nbSel = selected.Extent();
2966 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2967 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
2969 /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
2970 /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects */
2971 /* Warning : however by internal mechanism all subMeshes icons are changed ! */
2972 if ( !aHypothesis->_is_nil() )
2975 //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2976 SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2978 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
2988 case 1102: // REMOVE HYPOTHESIS / ALGORITHMS
2990 if(checkLock(aStudy)) break;
2991 SUIT_OverrideCursor wc;
2993 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2994 SALOME_ListIO selected;
2996 aSel->selectedObjects( selected, QString::null, false );
2998 SALOME_ListIteratorOfListIO It(selected);
2999 for (int i = 0; It.More(); It.Next(), i++) {
3000 Handle(SALOME_InteractiveObject) IObject = It.Value();
3001 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3004 aSel->setSelectedObjects( l1 );
3010 case 4009: // ELEM0D
3012 case 4021: // TRIANGLE
3014 case 4023: // POLYGON
3018 case 4134: // PYRAMID
3019 case 4135: // OCTA12
3021 if(checkLock(aStudy)) break;
3023 EmitSignalDeactivateDialog();
3024 SMDSAbs_EntityType type = SMDSEntity_Edge;
3025 switch (theCommandID) {
3026 case 4008: type = SMDSEntity_Ball; break;
3027 case 4009: type = SMDSEntity_0D; break;
3028 case 4021: type = SMDSEntity_Triangle; break;
3029 case 4022: type = SMDSEntity_Quadrangle; break;
3030 case 4031: type = SMDSEntity_Tetra; break;
3031 case 4023: type = SMDSEntity_Polygon; break;
3032 case 4032: type = SMDSEntity_Hexa; break;
3033 case 4133: type = SMDSEntity_Penta; break;
3034 case 4134: type = SMDSEntity_Pyramid; break;
3035 case 4135: type = SMDSEntity_Hexagonal_Prism; break;
3038 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3041 SUIT_MessageBox::warning(desktop(),
3042 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3046 case 4033: // POLYHEDRON
3048 if(checkLock(aStudy)) break;
3050 EmitSignalDeactivateDialog();
3051 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3054 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3055 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3059 case 4034: // QUADRATIC EDGE
3060 case 4035: // QUADRATIC TRIANGLE
3061 case 4036: // QUADRATIC QUADRANGLE
3062 case 4136: // BIQUADRATIC QUADRANGLE
3063 case 4037: // QUADRATIC TETRAHEDRON
3064 case 4038: // QUADRATIC PYRAMID
3065 case 4039: // QUADRATIC PENTAHEDRON
3066 case 4040: // QUADRATIC HEXAHEDRON
3067 case 4140: // TRIQUADRATIC HEXAHEDRON
3069 if(checkLock(aStudy)) break;
3071 EmitSignalDeactivateDialog();
3072 SMDSAbs_EntityType type = SMDSEntity_Last;
3074 switch (theCommandID) {
3076 type = SMDSEntity_Quad_Edge; break;
3078 type = SMDSEntity_Quad_Triangle; break;
3080 type = SMDSEntity_Quad_Quadrangle; break;
3082 type = SMDSEntity_BiQuad_Quadrangle; break;
3084 type = SMDSEntity_Quad_Tetra; break;
3086 type = SMDSEntity_Quad_Pyramid; break;
3088 type = SMDSEntity_Quad_Penta; break;
3090 type = SMDSEntity_Quad_Hexa; break;
3092 type = SMDSEntity_TriQuad_Hexa; break;
3095 if ( type != SMDSEntity_Last )
3096 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3099 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3100 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3104 case 4041: // REMOVES NODES
3106 if(checkLock(aStudy)) break;
3108 EmitSignalDeactivateDialog();
3109 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3112 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3113 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3117 case 4042: // REMOVES ELEMENTS
3119 if(checkLock(aStudy)) break;
3121 EmitSignalDeactivateDialog();
3122 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3126 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3127 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3131 case 4043: { // CLEAR_MESH
3133 if(checkLock(aStudy)) break;
3135 SALOME_ListIO selected;
3136 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3137 aSel->selectedObjects( selected );
3139 SUIT_OverrideCursor wc;
3140 SALOME_ListIteratorOfListIO It (selected);
3141 for ( ; It.More(); It.Next() )
3143 Handle(SALOME_InteractiveObject) IOS = It.Value();
3144 SMESH::SMESH_Mesh_var aMesh =
3145 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3146 if ( aMesh->_is_nil()) continue;
3148 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3150 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3151 SMESH::ModifiedMesh( aMeshSObj, false, true);
3152 // hide groups and submeshes
3153 _PTR(ChildIterator) anIter =
3154 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3155 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3157 _PTR(SObject) so = anIter->Value();
3158 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3161 catch (const SALOME::SALOME_Exception& S_ex){
3163 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3167 SMESH::UpdateView();
3171 case 4044: // REMOVE ORPHAN NODES
3173 if(checkLock(aStudy)) break;
3174 SALOME_ListIO selected;
3175 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3176 aSel->selectedObjects( selected );
3177 if ( selected.Extent() == 1 ) {
3178 Handle(SALOME_InteractiveObject) anIO = selected.First();
3179 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3180 if ( !aMesh->_is_nil() ) {
3181 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3182 tr( "SMESH_WARNING" ),
3183 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3184 SUIT_MessageBox::Yes |
3185 SUIT_MessageBox::No,
3186 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3189 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3190 int removed = aMeshEditor->RemoveOrphanNodes();
3191 SUIT_MessageBox::information(SMESHGUI::desktop(),
3192 tr("SMESH_INFORMATION"),
3193 tr("NB_NODES_REMOVED").arg(removed));
3194 if ( removed > 0 ) {
3195 SMESH::UpdateView();
3196 SMESHGUI::Modified();
3199 catch (const SALOME::SALOME_Exception& S_ex) {
3200 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3209 case 4051: // RENUMBERING NODES
3211 if(checkLock(aStudy)) break;
3213 EmitSignalDeactivateDialog();
3214 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3218 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3219 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3223 case 4052: // RENUMBERING ELEMENTS
3225 if(checkLock(aStudy)) break;
3227 EmitSignalDeactivateDialog();
3228 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3232 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3233 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3237 case 4061: // TRANSLATION
3239 if(checkLock(aStudy)) break;
3241 EmitSignalDeactivateDialog();
3242 ( new SMESHGUI_TranslationDlg( this ) )->show();
3245 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3246 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3250 case 4062: // ROTATION
3252 if(checkLock(aStudy)) break;
3254 EmitSignalDeactivateDialog();
3255 ( new SMESHGUI_RotationDlg( this ) )->show();
3258 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3259 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3263 case 4063: // SYMMETRY
3265 if(checkLock(aStudy)) break;
3267 EmitSignalDeactivateDialog();
3268 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3271 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3272 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3276 case 4064: // SEWING
3278 if(checkLock(aStudy)) break;
3280 EmitSignalDeactivateDialog();
3281 ( new SMESHGUI_SewingDlg( this ) )->show();
3284 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3285 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3289 case 4065: // MERGE NODES
3291 if(checkLock(aStudy)) break;
3293 EmitSignalDeactivateDialog();
3294 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3297 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3298 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3302 case 4066: // MERGE EQUAL ELEMENTS
3304 if (checkLock(aStudy)) break;
3306 EmitSignalDeactivateDialog();
3307 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3309 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3310 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3315 case 4067: // MAKE MESH PASS THROUGH POINT
3316 startOperation( 4067 );
3321 if(checkLock(aStudy)) break;
3323 EmitSignalDeactivateDialog();
3324 ( new SMESHGUI_ScaleDlg( this ) )->show();
3327 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3328 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3333 case 4069: // DUPLICATE NODES
3335 if(checkLock(aStudy)) break;
3337 EmitSignalDeactivateDialog();
3338 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3341 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3342 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3347 case 4070: // 0D_ON_ALL_NODES
3348 startOperation( 4070 );
3351 case 5105: // Library of selection filters
3353 static QList<int> aTypes;
3354 if ( aTypes.isEmpty() )
3356 aTypes.append( SMESH::NODE );
3357 aTypes.append( SMESH::EDGE );
3358 aTypes.append( SMESH::FACE );
3359 aTypes.append( SMESH::VOLUME );
3361 if (!myFilterLibraryDlg)
3362 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3363 else if (myFilterLibraryDlg->isHidden())
3364 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3365 myFilterLibraryDlg->raise();
3369 case 6017: // CONTROLS
3397 LightApp_SelectionMgr* mgr = selectionMgr();
3398 SALOME_ListIO selected; mgr->selectedObjects( selected );
3400 if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3401 _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3403 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3404 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
3405 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3406 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
3407 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3408 ::Control( theCommandID );
3413 SUIT_MessageBox::warning(desktop(),
3414 tr( "SMESH_WRN_WARNING" ),
3415 tr( "SMESH_BAD_SELECTION" ) );
3419 SUIT_MessageBox::warning(desktop(),
3420 tr( "SMESH_WRN_WARNING" ),
3421 tr( "NOT_A_VTK_VIEWER" ) );
3426 LightApp_SelectionMgr* mgr = selectionMgr();
3427 SALOME_ListIO selected; mgr->selectedObjects( selected );
3429 SALOME_ListIteratorOfListIO it(selected);
3430 for( ; it.More(); it.Next()) {
3431 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3432 if(anIObject->hasEntry()) {
3433 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3434 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3442 LightApp_SelectionMgr* mgr = selectionMgr();
3443 SALOME_ListIO selected; mgr->selectedObjects( selected );
3445 SALOME_ListIteratorOfListIO it(selected);
3446 for( ; it.More(); it.Next()) {
3447 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3448 if(anIObject->hasEntry())
3449 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3450 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3458 int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3459 EmitSignalDeactivateDialog();
3460 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3466 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3467 //updateObjBrowser();
3471 //=============================================================================
3475 //=============================================================================
3476 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3481 //=============================================================================
3485 //=============================================================================
3486 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3491 //=============================================================================
3495 //=============================================================================
3496 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3501 //=============================================================================
3502 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3503 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3505 //=============================================================================
3506 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3507 SUIT_ViewWindow* wnd )
3509 if(theIO->hasEntry()){
3510 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3511 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3515 //=======================================================================
3516 // function : createSMESHAction
3518 //=======================================================================
3519 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3520 const int key, const bool toggle, const QString& shortcutAction )
3523 QWidget* parent = application()->desktop();
3524 SUIT_ResourceMgr* resMgr = resourceMgr();
3526 if ( !icon_id.isEmpty() )
3527 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3529 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3530 if ( !pix.isNull() )
3531 icon = QIcon( pix );
3533 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3534 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3535 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3537 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3538 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3541 //=======================================================================
3542 // function : createPopupItem
3544 //=======================================================================
3545 void SMESHGUI::createPopupItem( const int id,
3546 const QString& clients,
3547 const QString& types,
3548 const QString& theRule,
3551 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3552 popupMgr()->insert( action( id ), pId, 0 );
3554 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3555 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3556 QString rule = "(%1) and (%2) and (%3)";
3557 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3558 if( clients.isEmpty() )
3559 rule = rule.arg( QString( "true" ) );
3561 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3562 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3565 bool cont = myRules.contains( id );
3567 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3569 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3570 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3573 //=======================================================================
3574 // function : initialize
3576 //=======================================================================
3577 void SMESHGUI::initialize( CAM_Application* app )
3579 SalomeApp_Module::initialize( app );
3581 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3583 /* Automatic Update flag */
3584 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3586 // ----- create actions --------------
3588 //createSMESHAction( 111, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3589 createSMESHAction( 112, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3590 createSMESHAction( 113, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3591 createSMESHAction( 114, "NUM" );
3592 createSMESHAction( 115, "IMPORT_STL" );
3593 createSMESHAction( 116, "IMPORT_CGNS" );
3594 createSMESHAction( 117, "IMPORT_SAUV" );
3595 createSMESHAction( 118, "IMPORT_GMF" );
3596 createSMESHAction( 121, "DAT" );
3597 createSMESHAction( 122, "MED" );
3598 createSMESHAction( 123, "UNV" );
3599 createSMESHAction( 140, "STL" );
3600 createSMESHAction( 142, "CGNS");
3601 createSMESHAction( 144, "SAUV");
3602 createSMESHAction( 146, "GMF" );
3603 createSMESHAction( 124, "DAT" );
3604 createSMESHAction( 125, "MED" );
3605 createSMESHAction( 126, "UNV" );
3606 createSMESHAction( 141, "STL" );
3607 createSMESHAction( 143, "CGNS");
3608 createSMESHAction( 145, "SAUV");
3609 createSMESHAction( 147, "GMF" );
3610 createSMESHAction( 150, "FILE_INFO" );
3611 createSMESHAction( 33, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3612 createSMESHAction( 5105, "SEL_FILTER_LIB" );
3613 createSMESHAction( 701, "COMPUTE", "ICON_COMPUTE" );
3614 createSMESHAction( 702, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3615 createSMESHAction( 703, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3616 createSMESHAction( 704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3617 createSMESHAction( 705, "COPY_MESH", "ICON_COPY_MESH" );
3618 createSMESHAction( 710, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3619 createSMESHAction( 711, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3620 createSMESHAction( 712, "EVALUATE", "ICON_COMPUTE" );
3621 createSMESHAction( 713, "MESH_ORDER", "ICON_COMPUTE" );
3622 createSMESHAction( 806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3623 createSMESHAction( 801, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3624 createSMESHAction( 802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3625 createSMESHAction( 803, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3626 createSMESHAction( 815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3627 createSMESHAction( 804, "ADD" );
3628 createSMESHAction( 805, "REMOVE" );
3629 createSMESHAction( 810, "UN_GROUP", "ICON_UNION" );
3630 createSMESHAction( 811, "INT_GROUP", "ICON_INTERSECT" );
3631 createSMESHAction( 812, "CUT_GROUP", "ICON_CUT" );
3632 createSMESHAction( 814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3633 createSMESHAction( 813, "DEL_GROUP", "ICON_DEL_GROUP" );
3634 createSMESHAction( 900, "ADV_INFO", "ICON_ADV_INFO" );
3635 //createSMESHAction( 902, "STD_INFO", "ICON_STD_INFO" );
3636 //createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3637 createSMESHAction( 904, "FIND_ELEM", "ICON_FIND_ELEM" );
3638 createSMESHAction( 6001, "LENGTH", "ICON_LENGTH", 0, true );
3639 createSMESHAction( 6002, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3640 createSMESHAction( 6021, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3641 createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3642 createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3643 createSMESHAction( 6024, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3644 createSMESHAction( 6025, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3645 createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3646 createSMESHAction( 6027, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3647 createSMESHAction( 6028, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3648 createSMESHAction( 6029, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3649 createSMESHAction( 6030, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3650 createSMESHAction( 6031, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3651 createSMESHAction( 6003, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3652 createSMESHAction( 6004, "CONNECTION", "ICON_CONNECTION", 0, true );
3653 createSMESHAction( 6005, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3654 createSMESHAction( 6011, "AREA", "ICON_AREA", 0, true );
3655 createSMESHAction( 6012, "TAPER", "ICON_TAPER", 0, true );
3656 createSMESHAction( 6013, "ASPECT", "ICON_ASPECT", 0, true );
3657 createSMESHAction( 6014, "MIN_ANG", "ICON_ANGLE", 0, true );
3658 createSMESHAction( 6015, "WARP", "ICON_WARP", 0, true );
3659 createSMESHAction( 6016, "SKEW", "ICON_SKEW", 0, true );
3660 createSMESHAction( 6017, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3661 createSMESHAction( 6018, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3662 createSMESHAction( 6019, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3663 createSMESHAction( 6009, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3664 createSMESHAction( 4000, "NODE", "ICON_DLG_NODE" );
3665 createSMESHAction( 4009, "ELEM0D", "ICON_DLG_ELEM0D" );
3666 createSMESHAction( 4008, "BALL", "ICON_DLG_BALL" );
3667 createSMESHAction( 4010, "EDGE", "ICON_DLG_EDGE" );
3668 createSMESHAction( 4021, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3669 createSMESHAction( 4022, "QUAD", "ICON_DLG_QUADRANGLE" );
3670 createSMESHAction( 4023, "POLYGON", "ICON_DLG_POLYGON" );
3671 createSMESHAction( 4031, "TETRA", "ICON_DLG_TETRAS" );
3672 createSMESHAction( 4032, "HEXA", "ICON_DLG_HEXAS" );
3673 createSMESHAction( 4133, "PENTA", "ICON_DLG_PENTA" );
3674 createSMESHAction( 4134, "PYRAMID", "ICON_DLG_PYRAMID" );
3675 createSMESHAction( 4135, "OCTA", "ICON_DLG_OCTA" );
3676 createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3677 createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3678 createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3679 createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3680 createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3681 createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3682 createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3683 createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3684 createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3685 createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3686 createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3687 createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3688 createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3689 createSMESHAction( 4043, "CLEAR_MESH" , "ICON_CLEAR_MESH" );
3690 createSMESHAction( 4051, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3691 createSMESHAction( 4052, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3692 createSMESHAction( 4061, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3693 createSMESHAction( 4062, "ROT", "ICON_DLG_MESH_ROTATION" );
3694 createSMESHAction( 4063, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3695 createSMESHAction( 4064, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3696 createSMESHAction( 4065, "MERGE", "ICON_SMESH_MERGE_NODES" );
3697 createSMESHAction( 4066, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3698 createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3699 createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" );
3700 createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3701 createSMESHAction( 4070, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3702 createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" );
3703 createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" );
3704 createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3705 createSMESHAction( 410, "UNION", "ICON_UNIONTRI" );
3706 createSMESHAction( 411, "CUT", "ICON_CUTQUAD" );
3707 createSMESHAction( 412, "SMOOTH", "ICON_DLG_SMOOTHING" );
3708 createSMESHAction( 413, "EXTRUSION", "ICON_EXTRUSION" );
3709 createSMESHAction( 414, "REVOLUTION", "ICON_REVOLUTION" );
3710 createSMESHAction( 415, "MAP", "ICON_MAP" );
3711 createSMESHAction( 416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3712 createSMESHAction( 417, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3713 createSMESHAction( 418, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3714 createSMESHAction( 419, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3715 createSMESHAction( 420, "REORIENT_2D", "ICON_REORIENT_2D" );
3716 createSMESHAction( 200, "RESET" );
3717 createSMESHAction( 201, "SCALAR_BAR_PROP" );
3718 createSMESHAction( 2021, "SAVE_DISTRIBUTION" );
3719 createSMESHAction( 2022, "SHOW_DISTRIBUTION","",0, true );
3720 #ifndef DISABLE_PLOT2DVIEWER
3721 createSMESHAction( 2023, "PLOT_DISTRIBUTION" );
3723 createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true );
3724 createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true );
3725 createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true );
3726 createSMESHAction( 214, "UPDATE", "ICON_UPDATE" );
3727 createSMESHAction( 215, "NODES", "ICON_POINTS", 0, true );
3728 createSMESHAction( 222, "BALLS", "ICON_DLG_BALL", 0, true );
3729 createSMESHAction( 216, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3730 createSMESHAction( 217, "EDGES", "ICON_DLG_EDGE", 0, true );
3731 createSMESHAction( 218, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3732 createSMESHAction( 219, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3733 createSMESHAction( 220, "ALL" );
3734 createSMESHAction( 221, "FACE_ORIENTATION", "", 0, true );
3736 createSMESHAction( 231, "LINE_REPRESENTATION", "", 0, true );
3737 createSMESHAction( 232, "ARC_REPRESENTATION", "", 0, true );
3739 createSMESHAction( 1100, "EDIT_HYPO" );
3740 createSMESHAction( 1102, "UNASSIGN" );
3741 createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3742 createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3743 createSMESHAction( 1131, "DISPMODE" );
3744 createSMESHAction( 1132, "COLORS" );
3745 createSMESHAction( 1133, "TRANSP" );
3746 createSMESHAction( 1134, "CLIP" );
3747 createSMESHAction( 1135, "DISP_ENT" );
3748 createSMESHAction( 1136, "AUTO_COLOR" );
3749 createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3750 createSMESHAction( 2000, "CTRL" );
3752 createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3753 createSMESHAction( 502, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3755 createSMESHAction( 300, "HIDE" );
3756 createSMESHAction( 301, "SHOW" );
3757 createSMESHAction( 302, "DISPLAY_ONLY" );
3759 // ----- create menu --------------
3760 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3761 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3762 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3763 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3764 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3765 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3766 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3767 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3769 createMenu( separator(), fileId );
3771 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3772 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3773 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3774 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3775 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3776 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3777 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3778 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3779 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3780 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3782 //createMenu( 111, importId, -1 );
3783 createMenu( 112, importId, -1 );
3784 createMenu( 113, importId, -1 );
3785 createMenu( 115, importId, -1 );
3787 createMenu( 116, importId, -1 );
3789 createMenu( 117, importId, -1 );
3790 createMenu( 118, importId, -1 );
3791 createMenu( 121, exportId, -1 );
3792 createMenu( 122, exportId, -1 );
3793 createMenu( 123, exportId, -1 );
3794 createMenu( 140, exportId, -1 ); // export to STL
3796 createMenu( 142, exportId, -1 ); // export to CGNS
3798 createMenu( 144, exportId, -1 ); // export to SAUV
3799 createMenu( 146, exportId, -1 ); // export to GMF
3800 createMenu( separator(), fileId, 10 );
3802 createMenu( 33, editId, -1 );
3804 createMenu( 5105, toolsId, -1 );
3806 createMenu( 702, meshId, -1 ); // "Mesh" menu
3807 createMenu( 703, meshId, -1 );
3808 createMenu( 704, meshId, -1 );
3809 createMenu( 710, meshId, -1 );
3810 createMenu( 705, meshId, -1 );
3811 createMenu( separator(), meshId, -1 );
3812 createMenu( 701, meshId, -1 );
3813 createMenu( 711, meshId, -1 );
3814 createMenu( 712, meshId, -1 );
3815 createMenu( 713, meshId, -1 );
3816 createMenu( separator(), meshId, -1 );
3817 createMenu( 801, meshId, -1 );
3818 createMenu( 806, meshId, -1 );
3819 createMenu( 802, meshId, -1 );
3820 createMenu( 803, meshId, -1 );
3821 createMenu( 815, meshId, -1 );
3822 createMenu( separator(), meshId, -1 );
3823 createMenu( 810, meshId, -1 );
3824 createMenu( 811, meshId, -1 );
3825 createMenu( 812, meshId, -1 );
3826 createMenu( separator(), meshId, -1 );
3827 createMenu( 814, meshId, -1 );
3828 createMenu( separator(), meshId, -1 );
3829 createMenu( 900, meshId, -1 );
3830 //createMenu( 902, meshId, -1 );
3831 //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3832 createMenu( 904, meshId, -1 );
3833 createMenu( separator(), meshId, -1 );
3835 createMenu( 6005, nodeId, -1 );
3836 createMenu( 6028, nodeId, -1 );
3837 createMenu( 6002, edgeId, -1 );
3838 createMenu( 6003, edgeId, -1 );
3839 createMenu( 6001, edgeId, -1 );
3840 createMenu( 6004, edgeId, -1 );
3841 createMenu( 6029, edgeId, -1 );
3842 createMenu( 6021, faceId, -1 );
3843 createMenu( 6025, faceId, -1 );
3844 createMenu( 6027, faceId, -1 );
3845 createMenu( 6018, faceId, -1 );
3846 createMenu( 6019, faceId, -1 );
3847 createMenu( 6011, faceId, -1 );
3848 createMenu( 6012, faceId, -1 );
3849 createMenu( 6013, faceId, -1 );
3850 createMenu( 6014, faceId, -1 );
3851 createMenu( 6015, faceId, -1 );
3852 createMenu( 6016, faceId, -1 );
3853 createMenu( 6022, faceId, -1 );
3854 createMenu( 6030, faceId, -1 );
3855 createMenu( 6017, volumeId, -1 );
3856 createMenu( 6009, volumeId, -1 );
3857 createMenu( 6023, volumeId, -1 );
3858 createMenu( 6024, volumeId, -1 );
3859 createMenu( 6026, volumeId, -1 );
3860 createMenu( 6031, volumeId, -1 );
3862 createMenu( 4000, addId, -1 );
3863 createMenu( 4009, addId, -1 );
3864 createMenu( 4070, addId, -1 );
3865 createMenu( 4008, addId, -1 );
3866 createMenu( 4010, addId, -1 );
3867 createMenu( 4021, addId, -1 );
3868 createMenu( 4022, addId, -1 );
3869 createMenu( 4023, addId, -1 );
3870 createMenu( 4031, addId, -1 );
3871 createMenu( 4032, addId, -1 );
3872 createMenu( 4133, addId, -1 );
3873 createMenu( 4134, addId, -1 );
3874 createMenu( 4135, addId, -1 );
3875 createMenu( 4033, addId, -1 );
3876 createMenu( separator(), addId, -1 );
3877 createMenu( 4034, addId, -1 );
3878 createMenu( 4035, addId, -1 );
3879 createMenu( 4036, addId, -1 );
3880 createMenu( 4136, addId, -1 );
3881 createMenu( 4037, addId, -1 );
3882 createMenu( 4038, addId, -1 );
3883 createMenu( 4039, addId, -1 );
3884 createMenu( 4040, addId, -1 );
3885 createMenu( 4140, addId, -1 );
3887 createMenu( 4041, removeId, -1 );
3888 createMenu( 4042, removeId, -1 );
3889 createMenu( 4044, removeId, -1 );
3890 createMenu( separator(), removeId, -1 );
3891 createMenu( 813, removeId, -1 );
3892 createMenu( separator(), removeId, -1 );
3893 createMenu( 4043, removeId, -1 );
3895 createMenu( 4051, renumId, -1 );
3896 createMenu( 4052, renumId, -1 );
3898 createMenu( 4061, transfId, -1 );
3899 createMenu( 4062, transfId, -1 );
3900 createMenu( 4063, transfId, -1 );
3901 createMenu( 4068, transfId, -1 );
3902 createMenu( 4064, transfId, -1 );
3903 createMenu( 4065, transfId, -1 );
3904 createMenu( 4066, transfId, -1 );
3905 createMenu( 4069, transfId, -1 );
3907 createMenu( 4067,modifyId, -1 );
3908 createMenu( 407, modifyId, -1 );
3909 createMenu( 408, modifyId, -1 );
3910 createMenu( 409, modifyId, -1 );
3911 createMenu( 420, modifyId, -1 );
3912 createMenu( 410, modifyId, -1 );
3913 createMenu( 411, modifyId, -1 );
3914 createMenu( 419, modifyId, -1 );
3915 createMenu( 412, modifyId, -1 );
3916 createMenu( 413, modifyId, -1 );
3917 createMenu( 416, modifyId, -1 );
3918 createMenu( 414, modifyId, -1 );
3919 createMenu( 415, modifyId, -1 );
3920 createMenu( 417, modifyId, -1 );
3921 createMenu( 418, modifyId, -1 );
3923 createMenu( 501, measureId, -1 );
3924 createMenu( 502, measureId, -1 );
3925 createMenu( 214, viewId, -1 );
3927 // ----- create toolbars --------------
3928 int meshTb = createTool( tr( "TB_MESH" ) ),
3929 ctrlTb = createTool( tr( "TB_CTRL" ) ),
3930 addRemTb = createTool( tr( "TB_ADD_REMOVE" ) ),
3931 modifyTb = createTool( tr( "TB_MODIFY" ) ),
3932 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
3934 createTool( 702, meshTb );
3935 createTool( 703, meshTb );
3936 createTool( 704, meshTb );
3937 createTool( 710, meshTb );
3938 createTool( 705, meshTb );
3939 createTool( separator(), meshTb );
3940 createTool( 701, meshTb );
3941 createTool( 711, meshTb );
3942 createTool( 712, meshTb );
3943 createTool( 713, meshTb );
3944 createTool( separator(), meshTb );
3945 createTool( 801, meshTb );
3946 createTool( 806, meshTb );
3947 createTool( 802, meshTb );
3948 createTool( 803, meshTb );
3949 //createTool( 815, meshTb );
3950 createTool( separator(), meshTb );
3951 createTool( 900, meshTb );
3952 //createTool( 902, meshTb );
3953 //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3954 createTool( 904, meshTb );
3955 createTool( separator(), meshTb );
3957 createTool( 6005, ctrlTb );
3958 createTool( 6028, ctrlTb );
3959 createTool( separator(), ctrlTb );
3960 createTool( 6002, ctrlTb );
3961 createTool( 6003, ctrlTb );
3962 createTool( 6001, ctrlTb );
3963 createTool( 6004, ctrlTb );
3964 createTool( 6029, ctrlTb );
3965 createTool( separator(), ctrlTb );
3966 createTool( 6021, ctrlTb );
3967 createTool( 6025, ctrlTb );
3968 createTool( 6027, ctrlTb );
3969 createTool( 6018, ctrlTb );
3970 createTool( 6019, ctrlTb );
3971 createTool( 6011, ctrlTb );
3972 createTool( 6012, ctrlTb );
3973 createTool( 6013, ctrlTb );
3974 createTool( 6014, ctrlTb );
3975 createTool( 6015, ctrlTb );
3976 createTool( 6016, ctrlTb );
3977 createTool( 6022, ctrlTb );
3978 createTool( 6030, ctrlTb );
3979 createTool( separator(), ctrlTb );
3980 createTool( 6017, ctrlTb );
3981 createTool( 6009, ctrlTb );
3982 createTool( 6023, ctrlTb );
3983 createTool( 6024, ctrlTb );
3984 createTool( 6026, ctrlTb );
3985 createTool( 6031, ctrlTb );
3986 createTool( separator(), ctrlTb );
3988 createTool( 4000, addRemTb );
3989 createTool( 4009, addRemTb );
3990 createTool( 4070, addRemTb );
3991 createTool( 4008, addRemTb );
3992 createTool( 4010, addRemTb );
3993 createTool( 4021, addRemTb );
3994 createTool( 4022, addRemTb );
3995 createTool( 4023, addRemTb );
3996 createTool( 4031, addRemTb );
3997 createTool( 4032, addRemTb );
3998 createTool( 4133, addRemTb );
3999 createTool( 4134, addRemTb );
4000 createTool( 4135, addRemTb );
4001 createTool( 4033, addRemTb );
4002 createTool( separator(), addRemTb );
4003 createTool( 4034, addRemTb );
4004 createTool( 4035, addRemTb );
4005 createTool( 4036, addRemTb );
4006 createTool( 4136, addRemTb );
4007 createTool( 4037, addRemTb );
4008 createTool( 4038, addRemTb );
4009 createTool( 4039, addRemTb );
4010 createTool( 4040, addRemTb );
4011 createTool( 4140, addRemTb );
4012 createTool( separator(), addRemTb );
4013 createTool( 4041, addRemTb );
4014 createTool( 4042, addRemTb );
4015 createTool( 4044, addRemTb );
4016 createTool( 4043, addRemTb );
4017 createTool( separator(), addRemTb );
4018 createTool( 4051, addRemTb );
4019 createTool( 4052, addRemTb );
4020 createTool( separator(), addRemTb );
4021 createTool( 4061, addRemTb );
4022 createTool( 4062, addRemTb );
4023 createTool( 4063, addRemTb );
4024 createTool( 4068, addRemTb );
4025 createTool( 4064, addRemTb );
4026 createTool( 4065, addRemTb );
4027 createTool( 4066, addRemTb );
4028 createTool( 4069, addRemTb );
4029 createTool( separator(), addRemTb );
4031 createTool( 4067,modifyTb );
4032 createTool( 407, modifyTb );
4033 createTool( 408, modifyTb );
4034 createTool( 409, modifyTb );
4035 createTool( 420, modifyTb );
4036 createTool( 410, modifyTb );
4037 createTool( 411, modifyTb );
4038 createTool( 419, modifyTb );
4039 createTool( 412, modifyTb );
4040 createTool( 413, modifyTb );
4041 createTool( 416, modifyTb );
4042 createTool( 414, modifyTb );
4043 createTool( 415, modifyTb );
4044 createTool( 417, modifyTb );
4045 createTool( 418, modifyTb );
4047 createTool( 214, dispModeTb );
4049 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4050 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4053 QString OB = "'ObjectBrowser'",
4054 View = "'" + SVTK_Viewer::Type() + "'",
4056 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4057 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4058 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4059 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4060 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4061 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4062 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4063 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4064 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4065 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4066 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4068 mesh_part = mesh + " " + subMesh + " " + group,
4069 mesh_group = mesh + " " + group,
4070 hyp_alg = hypo + " " + algo;
4072 // popup for object browser
4074 isInvisible("not( isVisible )"),
4075 isEmpty("numberOfNodes = 0"),
4076 isNotEmpty("numberOfNodes <> 0"),
4078 // has nodes, edges, etc in VISIBLE! actor
4079 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4080 hasElems("(count( elemTypes ) > 0)"),
4081 hasDifferentElems("(count( elemTypes ) > 1)"),
4082 hasBalls("({'BallElem'} in elemTypes)"),
4083 hasElems0d("({'Elem0d'} in elemTypes)"),
4084 hasEdges("({'Edge'} in elemTypes)"),
4085 hasFaces("({'Face'} in elemTypes)"),
4086 hasVolumes("({'Volume'} in elemTypes)");
4088 createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
4089 createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
4090 createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
4091 createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
4092 createPopupItem( 803, OB, group ); // EDIT_GROUP
4093 createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
4095 popupMgr()->insert( separator(), -1, 0 );
4096 createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
4097 createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
4098 createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
4099 createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
4100 createPopupItem( 214, OB, mesh_part ); // UPDATE
4101 createPopupItem( 900, OB, mesh_part ); // ADV_INFO
4102 createPopupItem( 904, OB, mesh_group ); // FIND_ELEM
4103 popupMgr()->insert( separator(), -1, 0 );
4104 createPopupItem( 801, OB, mesh ); // CREATE_GROUP
4105 createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
4106 createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
4107 popupMgr()->insert( separator(), -1, 0 );
4108 createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
4109 createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4110 popupMgr()->insert( separator(), -1, 0 );
4111 createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
4112 popupMgr()->insert( separator(), -1, 0 );
4113 createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
4114 createPopupItem( 418, OB, mesh + " " + group, // create 2D mesh from 3D
4116 popupMgr()->insert( separator(), -1, 0 );
4118 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4119 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4120 QString only_one_2D = only_one_non_empty + " && dim>1";
4122 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4123 createPopupItem( 125, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_MED
4124 createPopupItem( 126, OB, mesh_group, only_one_non_empty, anId ); // EXPORT_UNV
4125 createPopupItem( 141, OB, mesh_group, only_one_2D, anId ); // EXPORT_STL
4127 createPopupItem( 143, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_CGNS
4129 createPopupItem( 145, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_SAUV
4130 createPopupItem( 147, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_GMF
4131 createPopupItem( 124, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_DAT
4132 createPopupItem( 33, OB, mesh_part + " " + hyp_alg ); // DELETE
4133 createPopupItem( 813, OB, group ); // DEL_GROUP with contents
4134 popupMgr()->insert( separator(), -1, 0 );
4137 createPopupItem( 803, View, group ); // EDIT_GROUP
4138 createPopupItem( 804, View, elems ); // ADD
4139 createPopupItem( 805, View, elems ); // REMOVE
4141 popupMgr()->insert( separator(), -1, 0 );
4142 createPopupItem( 214, View, mesh_part ); // UPDATE
4143 createPopupItem( 900, View, mesh_part ); // ADV_INFO
4144 createPopupItem( 904, View, mesh ); // FIND_ELEM
4145 popupMgr()->insert( separator(), -1, 0 );
4147 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
4148 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
4149 popupMgr()->insert( separator(), -1, 0 );
4151 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4152 QString aType = QString( "%1type in {%2}" ).arg( lc );
4153 aType = aType.arg( mesh_part );
4154 QString aMeshInVTK = aClient + "&&" + aType;
4156 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4157 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4158 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4160 //-------------------------------------------------
4162 //-------------------------------------------------
4163 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4165 popupMgr()->insert( action( 9010 ), anId, -1 );
4166 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4167 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4169 popupMgr()->insert( action( 9011 ), anId, -1 );
4170 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4171 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4173 popupMgr()->insert( separator(), -1, -1 );
4175 //-------------------------------------------------
4177 //-------------------------------------------------
4178 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4180 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4181 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4182 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4184 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4185 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4186 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4188 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4189 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4190 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4192 popupMgr()->insert( separator(), anId, -1 );
4194 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4195 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4196 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4198 //-------------------------------------------------
4200 //-------------------------------------------------
4201 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4203 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4205 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4206 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4207 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4209 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4210 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4211 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4213 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4214 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4215 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4217 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4218 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4219 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4221 popupMgr()->insert( action( 222 ), anId, -1 ); // BALLS
4222 popupMgr()->setRule( action( 222 ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4223 popupMgr()->setRule( action( 222 ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4225 popupMgr()->insert( separator(), anId, -1 );
4227 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4228 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4231 //-------------------------------------------------
4232 // Representation of the 2D Quadratic elements
4233 //-------------------------------------------------
4234 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4235 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4236 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4237 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4239 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4240 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4241 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4243 //-------------------------------------------------
4244 // Orientation of faces
4245 //-------------------------------------------------
4246 popupMgr()->insert( action( 221 ), -1, -1 );
4247 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4248 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4250 //-------------------------------------------------
4252 //-------------------------------------------------
4253 popupMgr()->insert( action( 1132 ), -1, -1 );
4254 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4256 //-------------------------------------------------
4258 //-------------------------------------------------
4259 popupMgr()->insert( action( 1133 ), -1, -1 );
4260 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4262 //-------------------------------------------------
4264 //-------------------------------------------------
4266 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4267 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4268 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4269 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4271 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4273 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4274 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4276 popupMgr()->insert( separator(), anId, -1 );
4278 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4280 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4281 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4282 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4284 popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4285 popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4286 popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4288 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4290 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4291 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4292 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4294 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4295 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4296 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4298 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4299 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4300 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4302 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4303 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4304 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4305 popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4306 popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4307 popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4309 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4311 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4312 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4313 QtxPopupMgr::VisibleRule );
4314 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4316 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4317 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4318 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4320 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4321 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4322 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4324 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4325 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4326 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4328 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4329 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4330 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4332 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4333 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4334 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4336 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4337 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4338 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4340 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4341 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4342 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4344 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4345 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4346 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4348 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4349 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4350 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4352 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4353 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4354 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4356 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4357 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4358 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4359 popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4360 popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4361 popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4363 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4365 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4366 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4367 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4369 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4370 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4371 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4373 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4374 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4375 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4377 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4378 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4379 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4381 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4382 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4383 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4385 popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4386 popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4387 popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4389 popupMgr()->insert( separator(), anId, -1 );
4391 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4392 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4394 popupMgr()->insert( separator(), anId, -1 );
4396 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4398 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4399 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4401 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4402 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4403 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4405 #ifndef DISABLE_PLOT2DVIEWER
4406 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4407 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4410 //-------------------------------------------------
4412 //-------------------------------------------------
4413 popupMgr()->insert( separator(), -1, -1 );
4414 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4415 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4416 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4417 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4419 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4420 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4422 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4423 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4425 popupMgr()->insert( separator(), -1, -1 );
4427 //-------------------------------------------------
4429 //-------------------------------------------------
4430 popupMgr()->insert( action( 1134 ), -1, -1 );
4431 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4433 popupMgr()->insert( separator(), -1, -1 );
4435 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4436 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4438 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4439 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4442 //================================================================================
4444 * \brief Return true if SMESH or GEOM objects are selected.
4445 * Is called form LightApp_Module::activateModule() which clear selection if
4446 * not isSelectionCompatible()
4448 //================================================================================
4450 bool SMESHGUI::isSelectionCompatible()
4452 bool isCompatible = true;
4453 SALOME_ListIO selected;
4454 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4455 Sel->selectedObjects( selected );
4457 SALOME_ListIteratorOfListIO It( selected );
4458 for ( ; isCompatible && It.More(); It.Next())
4460 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4461 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4463 return isCompatible;
4467 bool SMESHGUI::reusableOperation( const int id )
4469 // compute, evaluate and precompute are not reusable operations
4470 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4473 bool SMESHGUI::activateModule( SUIT_Study* study )
4475 bool res = SalomeApp_Module::activateModule( study );
4477 setMenuShown( true );
4478 setToolShown( true );
4480 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4481 PyGILState_STATE gstate = PyGILState_Ensure();
4482 PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4483 if(pluginsmanager==NULL)
4487 PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4492 PyGILState_Release(gstate);
4493 // end of GEOM plugins loading
4495 // Reset actions accelerator keys
4496 //action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4497 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4498 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4500 action( 33)->setEnabled(true); // Delete: Key_Delete
4502 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4503 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4504 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4505 if ( _PTR(Study) aStudy = s->studyDS()) {
4506 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4507 updateObjBrowser(); // objects can be removed
4510 // get all view currently opened in the study and connect their signals to
4511 // the corresponding slots of the class.
4512 SUIT_Desktop* aDesk = study->application()->desktop();
4514 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4515 SUIT_ViewWindow* wnd;
4516 foreach ( wnd, wndList )
4523 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4525 setMenuShown( false );
4526 setToolShown( false );
4528 EmitSignalCloseAllDialogs();
4530 // Unset actions accelerator keys
4531 //action(111)->setShortcut(QKeySequence()); // Import DAT
4532 action(112)->setShortcut(QKeySequence()); // Import UNV
4533 action(113)->setShortcut(QKeySequence()); // Import MED
4535 action( 33)->setEnabled(false); // Delete: Key_Delete
4537 return SalomeApp_Module::deactivateModule( study );
4540 void SMESHGUI::studyClosed( SUIT_Study* s )
4542 SMESH::RemoveVisuData( s->id() );
4543 SalomeApp_Module::studyClosed( s );
4546 void SMESHGUI::OnGUIEvent()
4548 const QObject* obj = sender();
4549 if ( !obj || !obj->inherits( "QAction" ) )
4551 int id = actionId((QAction*)obj);
4556 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4558 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4559 if ( CORBA::is_nil( myComponentSMESH ) )
4561 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4563 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4564 return aGUI.myComponentSMESH;
4567 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4568 return myComponentSMESH;
4571 QString SMESHGUI::engineIOR() const
4573 CORBA::ORB_var anORB = getApp()->orb();
4574 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4575 return QString( anIOR.in() );
4578 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4580 SalomeApp_Module::contextMenuPopup( client, menu, title );
4582 selectionMgr()->selectedObjects( lst );
4583 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4584 Handle(SALOME_InteractiveObject) io = lst.First();
4585 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4586 _PTR(Study) study = appStudy->studyDS();
4587 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4589 QString aName = QString( obj->GetName().c_str() );
4590 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4591 aName.remove( (aName.length() - 1), 1 );
4597 LightApp_Selection* SMESHGUI::createSelection() const
4599 return new SMESHGUI_Selection();
4602 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4604 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4605 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4608 void SMESHGUI::viewManagers( QStringList& list ) const
4610 list.append( SVTK_Viewer::Type() );
4613 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4615 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4616 SMESH::UpdateSelectionProp( this );
4618 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4619 for(int i = 0; i < aViews.count() ; i++){
4620 SUIT_ViewWindow *sf = aViews[i];
4626 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4628 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4629 myClippingPlaneInfoMap.erase( theViewManager );
4632 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4634 theActor->AddObserver( SMESH::DeleteActorEvent,
4635 myEventCallbackCommand.GetPointer(),
4639 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4640 unsigned long theEvent,
4641 void* theClientData,
4644 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4645 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4646 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4647 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4648 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4649 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4650 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4651 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4652 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4653 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4654 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4655 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4656 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4657 if( anActor == *anIter3 ) {
4658 anActorList.erase( anIter3 );
4669 void SMESHGUI::createPreferences()
4671 // General tab ------------------------------------------------------------------------
4672 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4674 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4675 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4676 setPreferenceProperty( lim, "min", 0 );
4677 setPreferenceProperty( lim, "max", 100000000 );
4678 setPreferenceProperty( lim, "step", 1000 );
4679 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4681 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4682 setPreferenceProperty( qaGroup, "columns", 2 );
4683 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4684 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4685 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4686 setPreferenceProperty( prec, "min", 0 );
4687 setPreferenceProperty( prec, "max", 16 );
4688 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4689 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4690 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4691 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4692 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4694 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4695 setPreferenceProperty( dispgroup, "columns", 2 );
4696 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4698 modes.append( tr("MEN_WIRE") );
4699 modes.append( tr("MEN_SHADE") );
4700 modes.append( tr("MEN_NODES") );
4701 modes.append( tr("MEN_SHRINK") );
4702 QList<QVariant> indices;
4703 indices.append( 0 );
4704 indices.append( 1 );
4705 indices.append( 2 );
4706 indices.append( 3 );
4707 setPreferenceProperty( dispmode, "strings", modes );
4708 setPreferenceProperty( dispmode, "indexes", indices );
4710 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4711 setPreferenceProperty( arcgroup, "columns", 2 );
4712 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4713 QStringList quadraticModes;
4714 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4715 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4717 indices.append( 0 );
4718 indices.append( 1 );
4719 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4720 setPreferenceProperty( quadraticmode, "indexes", indices );
4722 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4723 "SMESH", "max_angle" );
4724 setPreferenceProperty( maxAngle, "min", 1 );
4725 setPreferenceProperty( maxAngle, "max", 90 );
4729 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4730 setPreferenceProperty( exportgroup, "columns", 2 );
4731 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4732 addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4734 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4735 setPreferenceProperty( computeGroup, "columns", 2 );
4736 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4738 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4739 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4740 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4742 indices.append( 0 );
4743 indices.append( 1 );
4744 indices.append( 2 );
4745 setPreferenceProperty( notifyMode, "strings", modes );
4746 setPreferenceProperty( notifyMode, "indexes", indices );
4748 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4749 setPreferenceProperty( infoGroup, "columns", 4 );
4750 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4752 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4753 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4755 indices.append( 0 );
4756 indices.append( 1 );
4757 setPreferenceProperty( elemInfo, "strings", modes );
4758 setPreferenceProperty( elemInfo, "indexes", indices );
4759 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4760 setPreferenceProperty( nodesLim, "min", 0 );
4761 setPreferenceProperty( nodesLim, "max", 10000000 );
4762 setPreferenceProperty( nodesLim, "step", 10000 );
4763 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4765 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4766 setPreferenceProperty( segGroup, "columns", 2 );
4767 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4768 "SMESH", "segmentation" );
4769 setPreferenceProperty( segLen, "min", 1 );
4770 setPreferenceProperty( segLen, "max", 10000000 );
4771 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4772 "SMESH", "nb_segments_per_edge" );
4773 setPreferenceProperty( nbSeg, "min", 1 );
4774 setPreferenceProperty( nbSeg, "max", 10000000 );
4776 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4777 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4778 "SMESH", "forget_mesh_on_hyp_modif" );
4781 // Quantities with individual precision settings
4782 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4783 setPreferenceProperty( precGroup, "columns", 2 );
4785 const int nbQuantities = 6;
4786 int precs[nbQuantities], ii = 0;
4787 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4788 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4789 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4790 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4791 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4792 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4793 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4794 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4795 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4796 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4797 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4798 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4800 // Set property for precision value for spinboxes
4801 for ( ii = 0; ii < nbQuantities; ii++ ){
4802 setPreferenceProperty( precs[ii], "min", -14 );
4803 setPreferenceProperty( precs[ii], "max", 14 );
4804 setPreferenceProperty( precs[ii], "precision", 2 );
4807 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4808 setPreferenceProperty( previewGroup, "columns", 2 );
4809 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4810 setPreferenceProperty( chunkSize, "min", 1 );
4811 setPreferenceProperty( chunkSize, "max", 1000 );
4812 setPreferenceProperty( chunkSize, "step", 50 );
4814 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4815 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4817 // Mesh tab ------------------------------------------------------------------------
4818 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4819 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4820 setPreferenceProperty( nodeGroup, "columns", 3 );
4822 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4824 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4826 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4827 QList<QVariant> aMarkerTypeIndicesList;
4828 QList<QVariant> aMarkerTypeIconsList;
4829 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4830 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4831 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4832 aMarkerTypeIndicesList << i;
4833 aMarkerTypeIconsList << pixmap;
4835 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4836 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4838 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4840 QList<QVariant> aMarkerScaleIndicesList;
4841 QStringList aMarkerScaleValuesList;
4842 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4843 aMarkerScaleIndicesList << i;
4844 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4846 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4847 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4849 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4850 //setPreferenceProperty( elemGroup, "columns", 2 );
4852 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4853 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4854 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
4855 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
4856 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4857 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
4858 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4859 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4862 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4863 setPreferenceProperty( grpGroup, "columns", 2 );
4865 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4866 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
4868 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4869 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4870 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
4871 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
4872 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4873 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4874 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
4875 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
4876 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4877 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4879 setPreferenceProperty( size0d, "min", 1 );
4880 setPreferenceProperty( size0d, "max", 10 );
4882 setPreferenceProperty( ballSize, "min", 1 );
4883 setPreferenceProperty( ballSize, "max", 10 );
4885 setPreferenceProperty( elemW, "min", 1 );
4886 setPreferenceProperty( elemW, "max", 5 );
4888 setPreferenceProperty( outW, "min", 1 );
4889 setPreferenceProperty( outW, "max", 5 );
4891 setPreferenceProperty( shrink, "min", 0 );
4892 setPreferenceProperty( shrink, "max", 100 );
4894 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4895 setPreferenceProperty( orientGroup, "columns", 1 );
4897 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4898 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4900 setPreferenceProperty( orientScale, "min", 0.05 );
4901 setPreferenceProperty( orientScale, "max", 0.5 );
4902 setPreferenceProperty( orientScale, "step", 0.05 );
4904 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4906 // Selection tab ------------------------------------------------------------------------
4907 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4909 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4910 setPreferenceProperty( selGroup, "columns", 2 );
4912 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4913 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4915 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4916 setPreferenceProperty( preGroup, "columns", 2 );
4918 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4920 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4921 setPreferenceProperty( precSelGroup, "columns", 2 );
4923 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4924 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4925 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4927 // Scalar Bar tab ------------------------------------------------------------------------
4928 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4929 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4930 setPreferenceProperty( fontGr, "columns", 2 );
4932 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4933 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4935 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4936 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4938 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4939 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4941 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4942 setPreferenceProperty( numcol, "min", 2 );
4943 setPreferenceProperty( numcol, "max", 256 );
4945 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4946 setPreferenceProperty( numlab, "min", 2 );
4947 setPreferenceProperty( numlab, "max", 65 );
4949 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4950 setPreferenceProperty( orientGr, "columns", 2 );
4951 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4952 QStringList orients;
4953 orients.append( tr( "SMESH_VERTICAL" ) );
4954 orients.append( tr( "SMESH_HORIZONTAL" ) );
4955 indices.clear(); indices.append( 0 ); indices.append( 1 );
4956 setPreferenceProperty( orient, "strings", orients );
4957 setPreferenceProperty( orient, "indexes", indices );
4959 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4960 setPreferenceProperty( posVSizeGr, "columns", 2 );
4961 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4962 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4963 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4964 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4965 setPreferenceProperty( xv, "step", 0.1 );
4966 setPreferenceProperty( xv, "min", 0.0 );
4967 setPreferenceProperty( xv, "max", 1.0 );
4968 setPreferenceProperty( yv, "step", 0.1 );
4969 setPreferenceProperty( yv, "min", 0.0 );
4970 setPreferenceProperty( yv, "max", 1.0 );
4971 setPreferenceProperty( wv, "step", 0.1 );
4972 setPreferenceProperty( wv, "min", 0.0 );
4973 setPreferenceProperty( wv, "max", 1.0 );
4974 setPreferenceProperty( hv, "min", 0.0 );
4975 setPreferenceProperty( hv, "max", 1.0 );
4976 setPreferenceProperty( hv, "step", 0.1 );
4978 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
4979 setPreferenceProperty( posHSizeGr, "columns", 2 );
4980 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
4981 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
4982 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
4983 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
4984 setPreferenceProperty( xv, "min", 0.0 );
4985 setPreferenceProperty( xv, "max", 1.0 );
4986 setPreferenceProperty( xv, "step", 0.1 );
4987 setPreferenceProperty( xh, "min", 0.0 );
4988 setPreferenceProperty( xh, "max", 1.0 );
4989 setPreferenceProperty( xh, "step", 0.1 );
4990 setPreferenceProperty( yh, "min", 0.0 );
4991 setPreferenceProperty( yh, "max", 1.0 );
4992 setPreferenceProperty( yh, "step", 0.1 );
4993 setPreferenceProperty( wh, "min", 0.0 );
4994 setPreferenceProperty( wh, "max", 1.0 );
4995 setPreferenceProperty( wh, "step", 0.1 );
4996 setPreferenceProperty( hh, "min", 0.0 );
4997 setPreferenceProperty( hh, "max", 1.0 );
4998 setPreferenceProperty( hh, "step", 0.1 );
5000 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5001 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5002 setPreferenceProperty( distributionGr, "columns", 3 );
5004 types.append( tr( "SMESH_MONOCOLOR" ) );
5005 types.append( tr( "SMESH_MULTICOLOR" ) );
5006 indices.clear(); indices.append( 0 ); indices.append( 1 );
5007 setPreferenceProperty( coloringType, "strings", types );
5008 setPreferenceProperty( coloringType, "indexes", indices );
5009 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5013 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5015 if( sect=="SMESH" ) {
5016 float sbX1,sbY1,sbW,sbH;
5017 float aTol = 1.00000009999999;
5018 std::string aWarning;
5019 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5020 if( name=="selection_object_color" || name=="selection_element_color" ||
5021 name=="highlight_color" ||
5022 name=="selection_precision_node" || name=="selection_precision_element" ||
5023 name=="selection_precision_object")
5024 SMESH::UpdateSelectionProp( this );
5025 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5026 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5027 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5028 if(sbX1+sbW > aTol){
5029 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5032 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5033 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5036 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5037 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5038 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5039 if(sbY1+sbH > aTol){
5040 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5041 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5042 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5045 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5046 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5047 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5048 if(sbX1+sbW > aTol){
5049 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5052 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5053 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5056 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5057 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5058 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5059 if(sbY1+sbH > aTol){
5060 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5063 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5064 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5067 else if ( name == "segmentation" ) {
5068 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5069 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5071 else if ( name == "nb_segments_per_edge" ) {
5072 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5073 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5075 else if ( name == "historical_python_dump" ||
5076 name == "forget_mesh_on_hyp_modif") {
5077 QString val = aResourceMgr->stringValue( "SMESH", name );
5078 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5081 if(aWarning.size() != 0){
5082 aWarning += "The default values are applied instead.";
5083 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5084 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5085 QObject::tr(aWarning.c_str()));
5090 //================================================================================
5092 * \brief Update something in accordance with update flags
5093 * \param theFlags - update flags
5095 * Update viewer or/and object browser etc. in accordance with update flags ( see
5096 * LightApp_UpdateFlags enumeration ).
5098 //================================================================================
5099 void SMESHGUI::update( const int flags )
5101 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5102 SMESH::UpdateView();
5104 SalomeApp_Module::update( flags );
5107 //================================================================================
5109 * \brief Set default selection mode
5111 * SLOT called when operation commited. Sets default selection mode
5113 //================================================================================
5114 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5116 SVTK_ViewWindow* vtkWnd =
5117 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5119 vtkWnd->SetSelectionMode( ActorSelection );
5122 //================================================================================
5124 * \brief Set default selection mode
5126 * SLOT called when operation aborted. Sets default selection mode
5128 //================================================================================
5129 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5131 SVTK_ViewWindow* vtkWnd =
5132 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5134 vtkWnd->SetSelectionMode( ActorSelection );
5137 //================================================================================
5139 * \brief Creates operation with given identifier
5140 * \param id - identifier of operation to be started
5141 * \return Pointer on created operation or NULL if operation is not created
5143 * Virtual method redefined from the base class creates operation with given id.
5144 * It is called called automatically from startOperation method of base class.
5146 //================================================================================
5147 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5149 LightApp_Operation* op = 0;
5150 // to do : create operation here
5153 case 417: //convert to quadratic
5154 op = new SMESHGUI_ConvToQuadOp();
5156 case 418: // create 2D mesh as boundary on 3D
5157 op = new SMESHGUI_Make2DFrom3DOp();
5159 case 420: // Reorient faces
5160 op = new SMESHGUI_ReorientFacesOp();
5162 case 701: // Compute mesh
5163 op = new SMESHGUI_ComputeOp();
5165 case 702: // Create mesh
5166 op = new SMESHGUI_MeshOp( true, true );
5168 case 703: // Create sub-mesh
5169 op = new SMESHGUI_MeshOp( true, false );
5171 case 704: // Edit mesh/sub-mesh
5172 op = new SMESHGUI_MeshOp( false );
5174 case 711: // Precompute mesh
5175 op = new SMESHGUI_PrecomputeOp();
5177 case 712: // Evaluate mesh
5178 op = new SMESHGUI_EvaluateOp();
5180 case 713: // Evaluate mesh
5181 op = new SMESHGUI_MeshOrderOp();
5183 case 806: // Create group on geom
5184 op = new SMESHGUI_GroupOnShapeOp();
5186 case 904: // Find element
5187 op = new SMESHGUI_FindElemByPointOp();
5189 case 4067: // Make mesh pass through point
5190 op = new SMESHGUI_MakeNodeAtPointOp();
5192 case 4070: // Create 0D elements on all nodes
5193 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5200 op = SalomeApp_Module::createOperation( id );
5204 //================================================================================
5206 * \brief Stops current operations and starts a given one
5207 * \param id - The id of the operation to start
5209 //================================================================================
5211 void SMESHGUI::switchToOperation(int id)
5213 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5214 activeStudy()->abortAllOperations();
5215 startOperation( id );
5218 LightApp_Displayer* SMESHGUI::displayer()
5221 myDisplayer = new SMESHGUI_Displayer( getApp() );
5225 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5228 int aTolerance = 64;
5229 int anIterations = 0;
5235 if( anIterations % aPeriod == 0 )
5238 if( aTolerance < 1 )
5242 aHue = (int)( 360.0 * rand() / RAND_MAX );
5245 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5246 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5247 for( ; it != itEnd; ++it )
5249 SALOMEDS::Color anAutoColor = *it;
5250 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5253 aQColor.getHsv( &h, &s, &v );
5254 if( abs( h - aHue ) < aTolerance )
5266 aColor.setHsv( aHue, 255, 255 );
5268 SALOMEDS::Color aSColor;
5269 aSColor.R = aColor.redF();
5270 aSColor.G = aColor.greenF();
5271 aSColor.B = aColor.blueF();
5276 const char* gSeparator = "_"; // character used to separate parameter names
5277 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5278 const char* gPathSep = "|"; // character used to separate paths
5281 * \brief Store visual parameters
5283 * This method is called just before the study document is saved.
5284 * Store visual parameters in AttributeParameter attribue(s)
5286 void SMESHGUI::storeVisualParameters (int savePoint)
5289 Kernel_Utils::Localizer loc;
5291 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5292 if (!appStudy || !appStudy->studyDS())
5294 _PTR(Study) studyDS = appStudy->studyDS();
5296 // componentName is used for encoding of entries when storing them in IParameters
5297 std::string componentName = myComponentSMESH->ComponentDataType();
5298 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5299 //if (!aSComponent) return;
5302 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5303 componentName.c_str(),
5305 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5307 // store map of custom markers
5308 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5309 if( !aMarkerMap.empty() )
5311 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5312 for( ; anIter != aMarkerMap.end(); anIter++ )
5314 int anId = anIter->first;
5315 VTK::MarkerData aMarkerData = anIter->second;
5316 std::string aMarkerFileName = aMarkerData.first;
5317 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5318 if( aMarkerTexture.size() < 3 )
5319 continue; // should contain at least width, height and the first value
5321 QString aPropertyName( "texture" );
5322 aPropertyName += gSeparator;
5323 aPropertyName += QString::number( anId );
5325 QString aPropertyValue = aMarkerFileName.c_str();
5326 aPropertyValue += gPathSep;
5328 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5329 ushort aWidth = *aTextureIter++;
5330 ushort aHeight = *aTextureIter++;
5331 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5332 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5333 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5334 aPropertyValue += QString::number( *aTextureIter );
5336 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5340 // viewers counters are used for storing view_numbers in IParameters
5343 // main cycle to store parameters of displayed objects
5344 QList<SUIT_ViewManager*> lst;
5345 QList<SUIT_ViewManager*>::Iterator it;
5346 getApp()->viewManagers(lst);
5347 for (it = lst.begin(); it != lst.end(); it++)
5349 SUIT_ViewManager* vman = *it;
5350 QString vType = vman->getType();
5352 // saving VTK actors properties
5353 if (vType == SVTK_Viewer::Type())
5355 // store the clipping planes attached to the view manager
5356 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5357 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5358 if( anIter != myClippingPlaneInfoMap.end() )
5359 aClippingPlaneInfoList = anIter->second;
5361 if( !aClippingPlaneInfoList.empty() ) {
5362 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5363 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5365 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5366 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5368 QString aPropertyName( "ClippingPlane" );
5369 aPropertyName += gSeparator;
5370 aPropertyName += QString::number( vtkViewers );
5371 aPropertyName += gSeparator;
5372 aPropertyName += QString::number( anId );
5374 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5375 aPropertyValue += gDigitsSep;
5376 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5377 aPropertyValue += gDigitsSep;
5378 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5379 aPropertyValue += gDigitsSep;
5380 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5382 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5386 QVector<SUIT_ViewWindow*> views = vman->getViews();
5387 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5389 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5391 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5392 vtkActorCollection* allActors = aCopy.GetActors();
5393 allActors->InitTraversal();
5394 while (vtkActor* actor = allActors->GetNextActor())
5396 if (actor->GetVisibility()) // store only visible actors
5398 SMESH_Actor* aSmeshActor = 0;
5399 if (actor->IsA("SMESH_Actor"))
5400 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5401 if (aSmeshActor && aSmeshActor->hasIO())
5403 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5406 // entry is "encoded" = it does NOT contain component adress,
5407 // since it is a subject to change on next component loading
5408 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5410 std::string param, vtkParam = vType.toLatin1().data();
5411 vtkParam += gSeparator;
5412 vtkParam += QString::number(vtkViewers).toLatin1().data();
5413 vtkParam += gSeparator;
5416 param = vtkParam + "Visibility";
5417 ip->setParameter(entry, param, "On");
5420 param = vtkParam + "Representation";
5421 ip->setParameter(entry, param, QString::number
5422 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5425 param = vtkParam + "IsShrunk";
5426 ip->setParameter(entry, param, QString::number
5427 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5429 // Displayed entities
5430 unsigned int aMode = aSmeshActor->GetEntityMode();
5431 bool isE = aMode & SMESH_Actor::eEdges;
5432 bool isF = aMode & SMESH_Actor::eFaces;
5433 bool isV = aMode & SMESH_Actor::eVolumes;
5434 bool is0d = aMode & SMESH_Actor::e0DElements;
5435 bool isB = aMode & SMESH_Actor::eBallElem;
5437 QString modeStr ("e");
5438 modeStr += gDigitsSep; modeStr += QString::number(isE);
5439 modeStr += gDigitsSep; modeStr += "f";
5440 modeStr += gDigitsSep; modeStr += QString::number(isF);
5441 modeStr += gDigitsSep; modeStr += "v";
5442 modeStr += gDigitsSep; modeStr += QString::number(isV);
5443 modeStr += gDigitsSep; modeStr += "0d";
5444 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5445 modeStr += gDigitsSep; modeStr += "b";
5446 modeStr += gDigitsSep; modeStr += QString::number(isB);
5448 param = vtkParam + "Entities";
5449 ip->setParameter(entry, param, modeStr.toLatin1().data());
5452 vtkFloatingPointType r, g, b;
5455 aSmeshActor->GetSufaceColor(r, g, b, delta);
5456 QStringList colorStr;
5457 colorStr << "surface";
5458 colorStr << QString::number(r);
5459 colorStr << QString::number(g);
5460 colorStr << QString::number(b);
5462 colorStr << "backsurface";
5463 colorStr << QString::number(delta);
5465 aSmeshActor->GetVolumeColor(r, g, b, delta);
5466 colorStr << "volume";
5467 colorStr << QString::number(r);
5468 colorStr << QString::number(g);
5469 colorStr << QString::number(b);
5470 colorStr << QString::number(delta);
5472 aSmeshActor->GetEdgeColor(r, g, b);
5474 colorStr << QString::number(r);
5475 colorStr << QString::number(g);
5476 colorStr << QString::number(b);
5478 aSmeshActor->GetNodeColor(r, g, b);
5480 colorStr << QString::number(r);
5481 colorStr << QString::number(g);
5482 colorStr << QString::number(b);
5484 aSmeshActor->GetOutlineColor(r, g, b);
5485 colorStr << "outline";
5486 colorStr << QString::number(r);
5487 colorStr << QString::number(g);
5488 colorStr << QString::number(b);
5490 aSmeshActor->Get0DColor(r, g, b);
5491 colorStr << "elem0d";
5492 colorStr << QString::number(r);
5493 colorStr << QString::number(g);
5494 colorStr << QString::number(b);
5496 aSmeshActor->GetBallColor(r, g, b);
5498 colorStr << QString::number(r);
5499 colorStr << QString::number(g);
5500 colorStr << QString::number(b);
5502 aSmeshActor->GetFacesOrientationColor(r, g, b);
5503 colorStr << "orientation";
5504 colorStr << QString::number(r);
5505 colorStr << QString::number(g);
5506 colorStr << QString::number(b);
5508 param = vtkParam + "Colors";
5509 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5512 QStringList sizeStr;
5514 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5515 sizeStr << "outline";
5516 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5517 sizeStr << "elem0d";
5518 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5520 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5521 sizeStr << "shrink";
5522 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5523 sizeStr << "orientation";
5524 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5525 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5527 param = vtkParam + "Sizes";
5528 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5533 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5534 if( aMarkerType == VTK::MT_USER ) {
5535 markerStr += "custom";
5536 markerStr += gDigitsSep;
5537 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5541 markerStr += gDigitsSep;
5542 markerStr += QString::number( (int)aMarkerType );
5543 markerStr += gDigitsSep;
5544 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5547 param = vtkParam + "PointMarker";
5548 ip->setParameter(entry, param, markerStr.toLatin1().data());
5551 param = vtkParam + "Opacity";
5552 ip->setParameter(entry, param,
5553 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5556 param = vtkParam + "ClippingPlane";
5558 if( !aClippingPlaneInfoList.empty() ) {
5559 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5560 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5562 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5563 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5564 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5565 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5566 if( aSmeshActor == *anIter2 ) {
5567 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5568 QString::number( anId ).toLatin1().constData() );
5575 ip->setParameter( entry, param, "Off" );
5576 } // if (io->hasEntry())
5577 } // SMESH_Actor && hasIO
5579 } // while.. actors traversal
5583 } // if (SVTK view model)
5584 } // for (viewManagers)
5587 // data structures for clipping planes processing
5590 vtkIdType Orientation;
5591 vtkFloatingPointType Distance;
5592 vtkFloatingPointType Angle[2];
5594 typedef std::list<TPlaneData> TPlaneDataList;
5595 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5597 typedef std::list<vtkActor*> TActorList;
5600 TActorList ActorList;
5601 SUIT_ViewManager* ViewManager;
5603 typedef std::list<TPlaneInfo> TPlaneInfoList;
5604 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5607 * \brief Restore visual parameters
5609 * This method is called after the study document is opened.
5610 * Restore visual parameters from AttributeParameter attribue(s)
5612 void SMESHGUI::restoreVisualParameters (int savePoint)
5615 Kernel_Utils::Localizer loc;
5617 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5618 if (!appStudy || !appStudy->studyDS())
5620 _PTR(Study) studyDS = appStudy->studyDS();
5622 // componentName is used for encoding of entries when storing them in IParameters
5623 std::string componentName = myComponentSMESH->ComponentDataType();
5624 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5625 //if (!aSComponent) return;
5628 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5629 componentName.c_str(),
5631 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5633 // restore map of custom markers and map of clipping planes
5634 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5635 TPlaneDataMap aPlaneDataMap;
5637 std::vector<std::string> properties = ip->getProperties();
5638 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5640 std::string property = *propIt;
5641 QString aPropertyName( property.c_str() );
5642 QString aPropertyValue( ip->getProperty( property ).c_str() );
5644 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5645 if( aPropertyNameList.isEmpty() )
5648 QString aPropertyType = aPropertyNameList[0];
5649 if( aPropertyType == "texture" )
5651 if( aPropertyNameList.size() != 2 )
5655 int anId = aPropertyNameList[1].toInt( &ok );
5656 if( !ok || anId < 1 )
5659 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5660 if( aPropertyValueList.size() != 2 )
5663 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5664 QString aMarkerTextureString = aPropertyValueList[1];
5665 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5666 if( aMarkerTextureStringList.size() != 3 )
5670 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5675 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5679 VTK::MarkerTexture aMarkerTexture;
5680 aMarkerTexture.push_back( aWidth );
5681 aMarkerTexture.push_back( aHeight );
5683 QString aMarkerTextureData = aMarkerTextureStringList[2];
5684 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5686 QChar aChar = aMarkerTextureData.at( i );
5687 if( aChar.isDigit() )
5688 aMarkerTexture.push_back( aChar.digitValue() );
5691 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5693 else if( aPropertyType == "ClippingPlane" )
5695 if( aPropertyNameList.size() != 3 )
5699 int aViewId = aPropertyNameList[1].toInt( &ok );
5700 if( !ok || aViewId < 0 )
5704 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5705 if( !ok || aClippingPlaneId < 0 )
5708 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5709 if( aPropertyValueList.size() != 4 )
5712 TPlaneData aPlaneData;
5713 aPlaneData.Id = aClippingPlaneId;
5716 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5721 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5726 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5731 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5735 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5736 aPlaneDataList.push_back( aPlaneData );
5740 TPlaneInfoMap aPlaneInfoMap;
5742 std::vector<std::string> entries = ip->getEntries();
5744 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5746 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5747 QString entry (ip->decodeEntry(*entIt).c_str());
5749 // Check that the entry corresponds to a real object in the Study
5750 // as the object may be deleted or modified after the visual state is saved.
5751 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5752 if (!so) continue; //Skip the not existent entry
5754 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5755 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5757 std::vector<std::string>::iterator namesIt = paramNames.begin();
5758 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5760 // actors are stored in a map after displaying of them for
5761 // quicker access in the future: map < viewID to actor >
5762 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5764 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5766 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5767 // '_' is used as separator and should not be used in viewer type or parameter names.
5768 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5769 if (lst.size() != 3)
5772 QString viewerTypStr = lst[0];
5773 QString viewIndexStr = lst[1];
5774 QString paramNameStr = lst[2];
5777 int viewIndex = viewIndexStr.toUInt(&ok);
5778 if (!ok) // bad conversion of view index to integer
5782 if (viewerTypStr == SVTK_Viewer::Type())
5784 SMESH_Actor* aSmeshActor = 0;
5785 if (vtkActors.IsBound(viewIndex))
5786 aSmeshActor = vtkActors.Find(viewIndex);
5788 QList<SUIT_ViewManager*> lst;
5789 getApp()->viewManagers(viewerTypStr, lst);
5791 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5792 SUIT_ViewManager* vman = NULL;
5793 if (viewIndex >= 0 && viewIndex < lst.count())
5794 vman = lst.at(viewIndex);
5796 if (paramNameStr == "Visibility")
5798 if (!aSmeshActor && displayer() && vman)
5800 SUIT_ViewModel* vmodel = vman->getViewModel();
5801 // SVTK view model can be casted to SALOME_View
5802 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5804 // store displayed actor in a temporary map for quicker
5805 // access later when restoring other parameters
5806 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5807 vtkRenderer* Renderer = vtkView->getRenderer();
5808 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5809 vtkActorCollection* theActors = aCopy.GetActors();
5810 theActors->InitTraversal();
5811 bool isFound = false;
5812 vtkActor *ac = theActors->GetNextActor();
5813 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5814 if (ac->IsA("SMESH_Actor")) {
5815 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5816 if (aGeomAc->hasIO()) {
5817 Handle(SALOME_InteractiveObject) io =
5818 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5819 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5821 vtkActors.Bind(viewIndex, aGeomAc);
5827 } // if (paramNameStr == "Visibility")
5830 // the rest properties "work" with SMESH_Actor
5833 QString val ((*valuesIt).c_str());
5836 if (paramNameStr == "Representation") {
5837 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5840 else if (paramNameStr == "IsShrunk") {
5842 if (!aSmeshActor->IsShrunk())
5843 aSmeshActor->SetShrink();
5846 if (aSmeshActor->IsShrunk())
5847 aSmeshActor->UnShrink();
5850 // Displayed entities
5851 else if (paramNameStr == "Entities") {
5852 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5853 int aEntityMode = SMESH_Actor::eAllEntity;
5854 for ( int i = 0; i < mode.count(); i+=2 ) {
5855 if ( i < mode.count()-1 ) {
5856 QString type = mode[i];
5857 bool val = mode[i+1].toInt();
5858 if ( type == "e" && !val )
5859 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
5860 else if ( type == "f" && !val )
5861 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
5862 else if ( type == "v" && !val )
5863 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
5864 else if ( type == "0d" && !val )
5865 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
5866 else if ( type == "b" && !val )
5867 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
5870 aSmeshActor->SetEntityMode( aEntityMode );
5873 else if (paramNameStr == "Colors") {
5874 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5881 QColor outlineColor;
5882 QColor orientationColor;
5888 // below lines are required to get default values for delta coefficients
5889 // of backface color for faces and color of reversed volumes
5890 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
5891 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
5892 for ( int i = 0; i < colors.count(); i++ ) {
5893 QString type = colors[i];
5894 if ( type == "surface" ) {
5895 // face color is set by 3 values r:g:b, where
5896 // - r,g,b - is rgb color components
5897 if ( i+1 >= colors.count() ) break; // format error
5898 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5899 if ( i+2 >= colors.count() ) break; // format error
5900 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5901 if ( i+3 >= colors.count() ) break; // format error
5902 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5903 faceColor.setRgbF( r, g, b );
5906 else if ( type == "backsurface" ) {
5907 // backface color can be defined in several ways
5908 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
5909 // - in latest versions, it is set as delta coefficient
5910 bool rgbOk = false, deltaOk;
5911 if ( i+1 >= colors.count() ) break; // format error
5912 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5913 int delta = colors[i+1].toInt( &deltaOk );
5915 if ( i+1 < colors.count() ) // index is shifted to 1
5916 g = colors[i+1].toDouble( &rgbOk );
5917 if ( rgbOk ) i++; // shift index
5918 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
5919 b = colors[i+1].toDouble( &rgbOk );
5921 // - as currently there's no way to set directly backsurface color as it was before,
5922 // we ignore old dump where r,g,b triple was set
5923 // - also we check that delta parameter is set properly
5924 if ( !rgbOk && deltaOk )
5927 else if ( type == "volume" ) {
5928 // volume color is set by 4 values r:g:b:delta, where
5929 // - r,g,b - is a normal volume rgb color components
5930 // - delta - is a reversed volume color delta coefficient
5931 if ( i+1 >= colors.count() ) break; // format error
5932 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5933 if ( i+2 >= colors.count() ) break; // format error
5934 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5935 if ( i+3 >= colors.count() ) break; // format error
5936 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5937 if ( i+4 >= colors.count() ) break; // format error
5938 int delta = colors[i+4].toInt( &bOk );
5939 if ( !bOk ) break; // format error
5940 volumeColor.setRgbF( r, g, b );
5944 else if ( type == "edge" ) {
5945 // edge color is set by 3 values r:g:b, where
5946 // - r,g,b - is rgb color components
5947 if ( i+1 >= colors.count() ) break; // format error
5948 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5949 if ( i+2 >= colors.count() ) break; // format error
5950 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5951 if ( i+3 >= colors.count() ) break; // format error
5952 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5953 edgeColor.setRgbF( r, g, b );
5956 else if ( type == "node" ) {
5957 // node color is set by 3 values r:g:b, where
5958 // - r,g,b - is rgb color components
5959 if ( i+1 >= colors.count() ) break; // format error
5960 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5961 if ( i+2 >= colors.count() ) break; // format error
5962 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5963 if ( i+3 >= colors.count() ) break; // format error
5964 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5965 nodeColor.setRgbF( r, g, b );
5968 else if ( type == "elem0d" ) {
5969 // 0d element color is set by 3 values r:g:b, where
5970 // - r,g,b - is rgb color components
5971 if ( i+1 >= colors.count() ) break; // format error
5972 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5973 if ( i+2 >= colors.count() ) break; // format error
5974 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5975 if ( i+3 >= colors.count() ) break; // format error
5976 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5977 elem0dColor.setRgbF( r, g, b );
5980 else if ( type == "ball" ) {
5981 // ball color is set by 3 values r:g:b, where
5982 // - r,g,b - is rgb color components
5983 if ( i+1 >= colors.count() ) break; // format error
5984 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5985 if ( i+2 >= colors.count() ) break; // format error
5986 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5987 if ( i+3 >= colors.count() ) break; // format error
5988 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5989 ballColor.setRgbF( r, g, b );
5992 else if ( type == "outline" ) {
5993 // outline color is set by 3 values r:g:b, where
5994 // - r,g,b - is rgb color components
5995 if ( i+1 >= colors.count() ) break; // format error
5996 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5997 if ( i+2 >= colors.count() ) break; // format error
5998 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5999 if ( i+3 >= colors.count() ) break; // format error
6000 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6001 outlineColor.setRgbF( r, g, b );
6004 else if ( type == "orientation" ) {
6005 // orientation color is set by 3 values r:g:b, where
6006 // - r,g,b - is rgb color components
6007 if ( i+1 >= colors.count() ) break; // format error
6008 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6009 if ( i+2 >= colors.count() ) break; // format error
6010 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6011 if ( i+3 >= colors.count() ) break; // format error
6012 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6013 orientationColor.setRgbF( r, g, b );
6018 if ( nodeColor.isValid() )
6019 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6021 if ( edgeColor.isValid() )
6022 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6024 if ( faceColor.isValid() )
6025 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6027 if ( volumeColor.isValid() )
6028 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6029 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6030 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6032 if ( elem0dColor.isValid() )
6033 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6035 if ( ballColor.isValid() )
6036 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6038 if ( outlineColor.isValid() )
6039 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6040 // orientation color
6041 if ( orientationColor.isValid() )
6042 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6045 else if (paramNameStr == "Sizes") {
6046 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6049 int outlineWidth = -1;
6050 int elem0dSize = -1;
6052 double shrinkSize = -1;
6053 double orientationSize = -1;
6054 bool orientation3d = false;
6055 for ( int i = 0; i < sizes.count(); i++ ) {
6056 QString type = sizes[i];
6057 if ( type == "line" ) {
6058 // line (wireframe) width is given as single integer value
6059 if ( i+1 >= sizes.count() ) break; // format error
6060 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6064 if ( type == "outline" ) {
6065 // outline width is given as single integer value
6066 if ( i+1 >= sizes.count() ) break; // format error
6067 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6071 else if ( type == "elem0d" ) {
6072 // 0d element size is given as single integer value
6073 if ( i+1 >= sizes.count() ) break; // format error
6074 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6078 else if ( type == "ball" ) {
6079 // ball size is given as single integer value
6080 if ( i+1 >= sizes.count() ) break; // format error
6081 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6085 else if ( type == "shrink" ) {
6086 // shrink factor is given as single floating point value
6087 if ( i+1 >= sizes.count() ) break; // format error
6088 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6092 else if ( type == "orientation" ) {
6093 // orientation vectors are specified by two values size:3d, where
6094 // - size - is a floating point value specifying scale factor
6095 // - 3d - is a boolean
6096 if ( i+1 >= sizes.count() ) break; // format error
6097 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6098 if ( i+2 >= sizes.count() ) break; // format error
6099 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6100 orientationSize = v1;
6101 orientation3d = (bool)v2;
6105 // line (wireframe) width
6106 if ( lineWidth > 0 )
6107 aSmeshActor->SetLineWidth( lineWidth );
6109 if ( outlineWidth > 0 )
6110 aSmeshActor->SetOutlineWidth( outlineWidth );
6111 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6112 aSmeshActor->SetOutlineWidth( lineWidth );
6114 if ( elem0dSize > 0 )
6115 aSmeshActor->Set0DSize( elem0dSize );
6118 aSmeshActor->SetBallSize( ballSize );
6120 if ( shrinkSize > 0 )
6121 aSmeshActor->SetShrinkFactor( shrinkSize );
6122 // orientation vectors
6123 if ( orientationSize > 0 ) {
6124 aSmeshActor->SetFacesOrientationScale( orientationSize );
6125 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6129 else if (paramNameStr == "PointMarker") {
6130 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6131 if( data.count() >= 2 ) {
6133 int aParam1 = data[1].toInt( &ok );
6135 if( data[0] == "std" && data.count() == 3 ) {
6136 int aParam2 = data[2].toInt( &ok );
6137 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6139 else if( data[0] == "custom" ) {
6140 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6141 if( markerIt != aMarkerMap.end() ) {
6142 VTK::MarkerData aMarkerData = markerIt->second;
6143 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6150 else if (paramNameStr == "Opacity") {
6151 aSmeshActor->SetOpacity(val.toFloat());
6154 else if (paramNameStr.startsWith("ClippingPlane")) {
6155 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6156 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
6157 // new format - val looks like "Off" or "0" (plane id)
6158 // (note: in new format "Off" value is used only for consistency,
6159 // so it is processed together with values in old format)
6160 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
6161 if( anIsOldFormat ) {
6162 if (paramNameStr == "ClippingPlane1" || val == "Off")
6163 aSmeshActor->RemoveAllClippingPlanes();
6165 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
6166 double aDistance = vals[1].toFloat();
6167 vtkFloatingPointType anAngle[2];
6168 anAngle[0] = vals[2].toFloat();
6169 anAngle[1] = vals[3].toFloat();
6171 QList<SUIT_ViewManager*> lst;
6172 getApp()->viewManagers(viewerTypStr, lst);
6173 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6174 if (viewIndex >= 0 && viewIndex < lst.count()) {
6175 SUIT_ViewManager* vman = lst.at(viewIndex);
6176 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6178 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6180 SMESH::TActorList anActorList;
6181 anActorList.push_back( aSmeshActor );
6182 SMESH::OrientedPlane* aPlane =
6183 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
6185 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6186 aClippingPlaneInfo.Plane = aPlane;
6187 aClippingPlaneInfo.ActorList = anActorList;
6188 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6195 int aPlaneId = val.toInt( &ok );
6196 if( ok && aPlaneId >= 0 ) {
6197 bool anIsDefinedPlane = false;
6198 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6199 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6200 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6201 TPlaneInfo& aPlaneInfo = *anIter;
6202 if( aPlaneInfo.PlaneId == aPlaneId ) {
6203 aPlaneInfo.ActorList.push_back( aSmeshActor );
6204 anIsDefinedPlane = true;
6208 if( !anIsDefinedPlane ) {
6209 TPlaneInfo aPlaneInfo;
6210 aPlaneInfo.PlaneId = aPlaneId;
6211 aPlaneInfo.ActorList.push_back( aSmeshActor );
6212 aPlaneInfo.ViewManager = vman;
6214 // to make the list sorted by plane id
6215 anIter = aPlaneInfoList.begin();
6216 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6217 const TPlaneInfo& aPlaneInfoRef = *anIter;
6218 if( aPlaneInfoRef.PlaneId > aPlaneId )
6221 aPlaneInfoList.insert( anIter, aPlaneInfo );
6226 } // if (aSmeshActor)
6227 } // other parameters than Visibility
6229 } // for names/parameters iterator
6230 } // for entries iterator
6232 // take into account planes with empty list of actors referred to them
6233 QList<SUIT_ViewManager*> aVMList;
6234 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6236 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6237 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6238 int aViewId = aPlaneDataIter->first;
6239 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6240 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6242 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6244 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6245 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6246 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6247 const TPlaneData& aPlaneData = *anIter2;
6248 int aPlaneId = aPlaneData.Id;
6250 bool anIsFound = false;
6251 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6252 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6253 const TPlaneInfo& aPlaneInfo = *anIter3;
6254 if( aPlaneInfo.PlaneId == aPlaneId ) {
6261 TPlaneInfo aPlaneInfo; // ActorList field is empty
6262 aPlaneInfo.PlaneId = aPlaneId;
6263 aPlaneInfo.ViewManager = aViewManager;
6265 // to make the list sorted by plane id
6266 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6267 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6268 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6269 if( aPlaneInfoRef.PlaneId > aPlaneId )
6272 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6278 // add clipping planes to actors according to the restored parameters
6279 // and update the clipping plane map
6280 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6281 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6282 int aViewId = anIter1->first;
6283 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6285 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6286 if( anIter2 == aPlaneDataMap.end() )
6288 const TPlaneDataList& aPlaneDataList = anIter2->second;
6290 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6291 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6292 const TPlaneInfo& aPlaneInfo = *anIter3;
6293 int aPlaneId = aPlaneInfo.PlaneId;
6294 const TActorList& anActorList = aPlaneInfo.ActorList;
6295 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6299 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6303 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6305 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6306 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6307 const TPlaneData& aPlaneData = *anIter4;
6308 if( aPlaneData.Id == aPlaneId ) {
6309 SMESH::OrientedPlane* aPlane =
6310 SMESHGUI_ClippingDlg::AddPlane( anActorList,
6312 (SMESH::Orientation)aPlaneData.Orientation,
6313 aPlaneData.Distance,
6316 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6317 aClippingPlaneInfo.Plane = aPlane;
6318 aClippingPlaneInfo.ActorList = anActorList;
6319 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6327 // update all VTK views
6328 QList<SUIT_ViewManager*> lst;
6329 getApp()->viewManagers(lst);
6330 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6331 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6332 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6333 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6334 vtkView->getRenderer()->ResetCameraClippingRange();
6341 \brief Adds preferences for dfont of VTK viewer
6343 \param pIf group identifier
6344 \param param parameter
6345 \return identifier of preferences
6347 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
6349 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6351 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6354 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6355 fam.append( tr( "SMESH_FONT_COURIER" ) );
6356 fam.append( tr( "SMESH_FONT_TIMES" ) );
6358 setPreferenceProperty( tfont, "fonts", fam );
6360 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6361 setPreferenceProperty( tfont, "features", f );
6367 \brief Actions after hypothesis edition
6368 Updates object browser after hypothesis edition
6370 void SMESHGUI::onHypothesisEdit( int result )
6373 SMESHGUI::Modified();
6374 updateObjBrowser( true );
6379 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6380 \param pview view being closed
6382 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6383 #ifndef DISABLE_PLOT2DVIEWER
6384 //Crear all Plot2d Viewers if need.
6385 SMESH::ClearPlot2Viewers(pview);
6389 void SMESHGUI::message( const QString& msg )
6392 QStringList data = msg.split("/");
6393 if ( data.count() > 0 ) {
6394 if ( data.first() == "mesh_loading" ) {
6396 QString entry = data.count() > 1 ? data[1] : QString();
6397 if ( entry.isEmpty() )
6400 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6402 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6405 name = obj->GetName().c_str();
6406 if ( name.isEmpty() )
6409 if ( data.last() == "stop" )
6410 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6412 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6413 QApplication::processEvents();
6419 \brief Connects or disconnects signals about activating and cloning view on the module slots
6420 \param pview view which is connected/disconnected
6422 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6426 SUIT_ViewManager* viewMgr = pview->getViewManager();
6428 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6429 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6431 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6432 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6437 \brief Return \c true if object can be renamed
6439 bool SMESHGUI::renameAllowed( const QString& entry) const {
6440 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6444 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6448 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6453 if(appStudy->isComponent(entry) || obj->isReference())
6456 // check type to prevent renaming of inappropriate objects
6457 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6458 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6459 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6460 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6461 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6462 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6469 Rename object by entry.
6470 \param entry entry of the object
6471 \param name new name of the object
6472 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6474 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6476 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6480 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6485 _PTR(Study) aStudy = appStudy->studyDS();
6490 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6492 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6497 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6498 _PTR(GenericAttribute) anAttr;
6499 _PTR(AttributeName) aName;
6501 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6503 // check type to prevent renaming of inappropriate objects
6504 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6505 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6506 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6507 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6508 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6509 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6510 if ( !name.isEmpty() ) {
6511 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6513 // update name of group object and its actor
6514 Handle(SALOME_InteractiveObject) IObject =
6515 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6517 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6518 if( !aGroupObject->_is_nil() ) {
6519 aGroupObject->SetName( qPrintable(name) );
6520 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6521 anActor->setName( qPrintable(name) );