1 // Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FileInfoDlg.h"
48 #include "SMESHGUI_FileValidator.h"
49 #include "SMESHGUI_FilterDlg.h"
50 #include "SMESHGUI_FilterLibraryDlg.h"
51 #include "SMESHGUI_FindElemByPointDlg.h"
52 #include "SMESHGUI_GroupDlg.h"
53 #include "SMESHGUI_GroupOnShapeDlg.h"
54 #include "SMESHGUI_GroupOpDlg.h"
55 #include "SMESHGUI_Hypotheses.h"
56 #include "SMESHGUI_Make2DFrom3DOp.h"
57 #include "SMESHGUI_MakeNodeAtPointDlg.h"
58 #include "SMESHGUI_Measurements.h"
59 #include "SMESHGUI_MergeDlg.h"
60 #include "SMESHGUI_MeshInfo.h"
61 #include "SMESHGUI_MeshOp.h"
62 #include "SMESHGUI_MeshOrderOp.h"
63 #include "SMESHGUI_MeshPatternDlg.h"
64 #include "SMESHGUI_MultiEditDlg.h"
65 #include "SMESHGUI_NodesDlg.h"
66 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
67 #include "SMESHGUI_PropertiesDlg.h"
68 #include "SMESHGUI_RemoveElementsDlg.h"
69 #include "SMESHGUI_RemoveNodesDlg.h"
70 #include "SMESHGUI_RenumberingDlg.h"
71 #include "SMESHGUI_ReorientFacesDlg.h"
72 #include "SMESHGUI_RevolutionDlg.h"
73 #include "SMESHGUI_RotationDlg.h"
74 #include "SMESHGUI_ScaleDlg.h"
75 #include "SMESHGUI_Selection.h"
76 #include "SMESHGUI_SewingDlg.h"
77 #include "SMESHGUI_SingleEditDlg.h"
78 #include "SMESHGUI_SmoothingDlg.h"
79 #include "SMESHGUI_SymmetryDlg.h"
80 #include "SMESHGUI_TranslationDlg.h"
81 #include "SMESHGUI_TransparencyDlg.h"
83 #include "SMESHGUI_FilterUtils.h"
84 #include "SMESHGUI_GroupUtils.h"
85 #include "SMESHGUI_HypothesesUtils.h"
86 #include "SMESHGUI_MeshUtils.h"
87 #include "SMESHGUI_PatternUtils.h"
88 #include "SMESHGUI_Utils.h"
89 #include "SMESHGUI_VTKUtils.h"
91 #include <SMESH_version.h>
93 #include "SMESH_ControlsDef.hxx"
94 #include <SMESH_Actor.h>
95 #include <SMESH_ActorUtils.h>
96 #include <SMESH_Client.hxx>
97 #include <SMESH_ScalarBarActor.h>
98 #include <SMESH_TypeFilter.hxx>
100 // SALOME GUI includes
101 #include <SalomeApp_Application.h>
102 #include <SalomeApp_CheckFileDlg.h>
103 #include <SalomeApp_DataObject.h>
104 #include <SalomeApp_Study.h>
105 #include <SalomeApp_Tools.h>
107 #include <LightApp_DataOwner.h>
108 #include <LightApp_NameDlg.h>
109 #include <LightApp_Preferences.h>
110 #include <LightApp_SelectionMgr.h>
111 #include <LightApp_UpdateFlags.h>
113 #include <SVTK_ViewManager.h>
114 #include <SVTK_ViewModel.h>
115 #include <SVTK_ViewWindow.h>
117 #include <VTKViewer_Algorithm.h>
119 #include <SUIT_Desktop.h>
120 #include <SUIT_FileDlg.h>
121 #include <SUIT_MessageBox.h>
122 #include <SUIT_OverrideCursor.h>
123 #include <SUIT_ResourceMgr.h>
124 #include <SUIT_Session.h>
126 #include <QtxPopupMgr.h>
127 #include <QtxFontEdit.h>
129 #include <SALOME_ListIO.hxx>
130 #include <SALOME_ListIteratorOfListIO.hxx>
132 #ifndef DISABLE_PLOT2DVIEWER
133 #include <SPlot2d_ViewModel.h>
134 #include <SPlot2d_Histogram.h>
138 #include <SALOMEconfig.h>
139 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
140 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
141 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
144 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
145 #include <QApplication>
147 #include <QTextStream>
150 #include <boost/shared_ptr.hpp>
153 #include <vtkCallbackCommand.h>
154 #include <vtkCamera.h>
155 #include <vtkLookupTable.h>
156 #include <vtkPlane.h>
157 #include <vtkRenderer.h>
159 // SALOME KERNEL includes
160 #include <SALOMEDSClient_ClientFactory.hxx>
161 #include <SALOMEDSClient_IParameters.hxx>
162 #include <SALOMEDSClient_SComponent.hxx>
163 #include <SALOMEDSClient_StudyBuilder.hxx>
164 #include <SALOMEDS_Study.hxx>
167 #include <Standard_ErrorHandler.hxx>
168 #include <NCollection_DataMap.hxx>
170 #include <Basics_Utils.hxx>
172 //To disable automatic genericobj management, the following line should be commented.
173 //Otherwise, it should be uncommented.
174 //Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
175 #define WITHGENERICOBJ
179 //=============================================================
180 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
183 void ExportMeshToFile(int theCommandID);
185 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
187 void SetDisplayEntity(int theCommandID);
189 void Control( int theCommandID );
193 //=============================================================
194 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
198 std::string myExtension;
200 if ( theCommandID == 113 ) {
201 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
202 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
204 else if ( theCommandID == 112 ) {
205 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
207 else if ( theCommandID == 111 ) {
208 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
210 else if ( theCommandID == 115 ) {
211 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
213 else if ( theCommandID == 116 ) {
214 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
216 else if ( theCommandID == 117 ) {
217 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
218 filter.append( QObject::tr( "All files (*)" ) );
220 else if ( theCommandID == 118 ) {
221 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
222 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
225 QString anInitialPath = "";
226 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
227 anInitialPath = QDir::currentPath();
229 QStringList filenames;
230 bool toCreateGroups = true;
232 // if ( theCommandID == 118 ) { // GMF
233 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
234 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
235 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
236 // fd->setNameFilters( filter );
237 // fd->SetChecked( true );
239 // filenames << fd->selectedFile();
240 // toCreateGroups = fd->IsChecked();
246 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
249 QObject::tr( "SMESH_IMPORT_MESH" ) );
251 if ( filenames.count() > 0 ) {
252 SUIT_OverrideCursor wc;
253 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
256 QStringList anEntryList;
257 bool isEmpty = false;
258 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
259 QString filename = *it;
260 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
262 switch ( theCommandID ) {
265 // DAT format (currently unsupported)
266 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
267 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
273 aMeshes->length( 1 );
274 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toLatin1().constData() );
275 if ( aMeshes[0]->_is_nil() )
276 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
277 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
283 SMESH::DriverMED_ReadStatus res;
284 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toLatin1().constData(), res );
285 if ( res != SMESH::DRS_OK ) {
286 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
287 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
294 aMeshes->length( 1 );
295 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toLatin1().constData() );
296 if ( aMeshes[0]->_is_nil() ) {
297 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
298 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
305 SMESH::DriverMED_ReadStatus res;
306 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toLatin1().constData(), res );
307 if ( res != SMESH::DRS_OK ) {
308 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
309 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
316 SMESH::DriverMED_ReadStatus res;
317 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toLatin1().constData(), res );
318 if ( res != SMESH::DRS_OK ) {
319 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
320 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
327 SMESH::ComputeError_var res;
328 aMeshes->length( 1 );
329 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toLatin1().constData(),
332 if ( res->code != SMESH::DRS_OK ) {
333 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
334 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
335 if ( strlen( res->comment.in() ) > 0 ) {
336 errors.back() += ": ";
337 errors.back() += res->comment.in();
344 catch ( const SALOME::SALOME_Exception& S_ex ) {
345 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
346 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
349 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
350 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
352 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
353 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
354 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
355 if ( theCommandID == 112 ) // mesh names aren't taken from the file for UNV import
356 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
358 anEntryList.append( aMeshSO->GetID().c_str() );
360 // obj has been published in study. Its refcount has been incremented.
361 // It is safe to decrement its refcount
362 // so that it will be destroyed when the entry in study will be removed
363 aMeshes[i]->UnRegister();
371 // update Object browser
372 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
374 // browse to the published meshes
375 if( LightApp_Application* anApp =
376 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
377 anApp->browseObjects( anEntryList );
379 // show Error message box if there were errors
380 if ( errors.count() > 0 ) {
381 SUIT_MessageBox::critical( SMESHGUI::desktop(),
382 QObject::tr( "SMESH_ERROR" ),
383 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
386 // show warning message box, if some imported mesh is empty
388 SUIT_MessageBox::warning( SMESHGUI::desktop(),
389 QObject::tr( "SMESH_WRN_WARNING" ),
390 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
395 //================================================================================
397 * \brief Export selected meshes or groups into a file
399 //================================================================================
401 void ExportMeshToFile( int theCommandID )
403 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
404 SALOME_ListIO selected;
406 aSel->selectedObjects( selected );
408 const bool isMED = ( theCommandID == 122 || theCommandID == 125 );
409 const bool isDAT = ( theCommandID == 121 || theCommandID == 124 );
410 const bool isUNV = ( theCommandID == 123 || theCommandID == 126 );
411 const bool isSTL = ( theCommandID == 140 || theCommandID == 141 );
412 const bool isCGNS= ( theCommandID == 142 || theCommandID == 143 );
413 const bool isSAUV= ( theCommandID == 144 || theCommandID == 145 );
414 const bool isGMF = ( theCommandID == 146 || theCommandID == 147 );
416 // actually, the following condition can't be met (added for insurance)
417 if( selected.Extent() == 0 ||
418 ( selected.Extent() > 1 && !isMED && !isSTL ))
421 // get mesh object from selection and check duplication of their names
422 bool hasDuplicatedMeshNames = false;
423 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
424 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
425 SALOME_ListIteratorOfListIO It( selected );
426 for( ; It.More(); It.Next() )
428 Handle(SALOME_InteractiveObject) anIObject = It.Value();
429 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
430 if ( aMeshItem->_is_nil() ) {
431 SUIT_MessageBox::warning( SMESHGUI::desktop(),
432 QObject::tr( "SMESH_WRN_WARNING" ),
433 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
437 QString aMeshName = anIObject->getName();
439 // check for name duplications
440 if ( !hasDuplicatedMeshNames )
441 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
442 if( aMeshName == (*aMeshIter).second ) {
443 hasDuplicatedMeshNames = true;
448 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
451 if( hasDuplicatedMeshNames && isMED ) {
452 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
453 QObject::tr("SMESH_WRN_WARNING"),
454 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
455 QObject::tr("SMESH_BUT_YES"),
456 QObject::tr("SMESH_BUT_NO"), 0, 1);
461 aMeshIter = aMeshList.begin();
462 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
463 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
464 QString aMeshName = (*aMeshIter).second;
466 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
468 // check for equal group names within each mesh
469 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
470 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
471 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
472 int aRet = SUIT_MessageBox::warning
473 (SMESHGUI::desktop(),
474 QObject::tr("SMESH_WRN_WARNING"),
475 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
476 QObject::tr("SMESH_BUT_YES"),
477 QObject::tr("SMESH_BUT_NO"), 0, 1);
484 // Warn the user about presence of not supported elements
486 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
490 notSupportedElemTypes.push_back( SMESH::Entity_0D );
491 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
496 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
497 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
498 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
499 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
500 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
501 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
502 notSupportedElemTypes.push_back( SMESH::Entity_0D );
503 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
508 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
509 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
510 notSupportedElemTypes.push_back( SMESH::Entity_0D );
511 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
516 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
517 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
522 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
523 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
524 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
525 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
526 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
527 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
528 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
533 notSupportedElemTypes.push_back( SMESH::Entity_0D );
534 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
535 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
536 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
537 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
538 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
539 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
540 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
541 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
543 if ( ! notSupportedElemTypes.empty() )
545 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
546 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
547 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
548 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
550 if ( !presentNotSupported.empty() )
553 const char* typeMsg[SMESH::Entity_Last] = {
554 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
555 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
556 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
557 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
558 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
559 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
560 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
561 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
563 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
564 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
565 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
566 if ( iType != presentNotSupported.size() - 1 )
567 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
569 int aRet = SUIT_MessageBox::warning
570 (SMESHGUI::desktop(),
571 QObject::tr("SMESH_WRN_WARNING"),
572 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
573 QObject::tr("SMESH_BUT_YES"),
574 QObject::tr("SMESH_BUT_NO"), 0, 1);
579 // Get parameters of export operation
582 SMESH::MED_VERSION aFormat;
583 // Init the parameters with the default values
584 bool aIsASCII_STL = true;
585 bool toCreateGroups = false;
586 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
588 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
589 bool toOverwrite = true;
591 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
592 QString anInitialPath = "";
593 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
594 anInitialPath = QDir::currentPath();
596 // Get a file name to write in and additional otions
597 if ( isUNV || isDAT || isGMF ) // Export w/o options
600 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
602 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
604 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
605 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
606 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
607 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
608 anInitialPath + QString("/") + aMeshName,
609 aFilter, aTitle, false);
611 // else if ( isGMF )// Export to GMF
613 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
614 // ( SMESHGUI::desktop(), false, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
615 // QStringList filters;
616 // filters << QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)"
617 // << QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
618 // fd->setWindowTitle( aTitle );
619 // fd->setNameFilters( filters );
621 // if ( !aMeshOrGroup->_is_equivalent( aMesh ))
622 // toCreateGroups = false;
624 // toCreateGroups = ( aMesh->NbGroups() > 0 );
626 // fd->SetChecked( true );
627 // if ( !anInitialPath.isEmpty() )
628 // fd->setDirectory( anInitialPath );
629 // fd->selectFile(aMeshName);
632 // aFilename = fd->selectedFile();
633 // toCreateGroups = fd->IsChecked();
637 else if ( isCGNS )// Export to CGNS
639 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
640 fd->setWindowTitle( aTitle );
641 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
642 if ( !anInitialPath.isEmpty() )
643 fd->setDirectory( anInitialPath );
644 fd->selectFile(aMeshName);
645 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
646 fd->setValidator( fv );
649 aFilename = fd->selectedFile();
650 toOverwrite = fv->isOverwrite();
654 else if ( isSTL ) // Export to STL
656 QMap<QString, int> aFilterMap;
657 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
658 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
661 QMap<QString, int>::const_iterator it = aFilterMap.begin();
662 for ( ; it != aFilterMap.end(); ++it )
663 filters.push_back( it.key() );
665 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
666 fd->setWindowTitle( aTitle );
667 fd->setNameFilters( filters );
668 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
669 if ( !anInitialPath.isEmpty() )
670 fd->setDirectory( anInitialPath );
671 fd->selectFile(aMeshName);
675 aFilename = fd->selectedFile();
676 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
681 else if ( isMED || isSAUV ) // Export to MED or SAUV
683 QMap<QString, SMESH::MED_VERSION> aFilterMap;
684 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
686 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
687 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
688 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
691 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
692 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
693 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
697 QString aDefaultFilter;
698 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
699 for ( ; it != aFilterMap.end(); ++it ) {
700 filters.push_back( it.key() );
701 if (it.value() == SMESH::MED_V2_2)
702 aDefaultFilter = it.key();
705 SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
706 ( SMESHGUI::desktop(), false, QObject::tr("SMESH_AUTO_GROUPS"), true, true );
707 fd->setWindowTitle( aTitle );
708 fd->setNameFilters( filters );
709 fd->selectNameFilter(aDefaultFilter);
710 fd->SetChecked(toCreateGroups);
711 if ( !anInitialPath.isEmpty() )
712 fd->setDirectory( anInitialPath );
713 fd->selectFile(aMeshName);
715 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
716 fd->setValidator( fv );
721 aFilename = fd->selectedFile();
723 aFilename = QString::null;
726 aFormat = aFilterMap[fd->selectedNameFilter()];
727 toOverwrite = fv->isOverwrite();
729 if ( !aFilename.isEmpty() ) {
730 // med-2.1 does not support poly elements
731 if ( aFormat==SMESH::MED_V2_1 )
732 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
733 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
734 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
735 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
736 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
738 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
739 QObject::tr("SMESH_WRN_WARNING"),
740 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
741 QObject::tr("SMESH_BUT_YES"),
742 QObject::tr("SMESH_BUT_NO"), 0, 1);
750 // can't append to an existing using other format
751 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
752 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toLatin1().constData(), aVersion );
753 if( !isVersionOk || aVersion != aFormat ) {
754 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
755 QObject::tr("SMESH_WRN_WARNING"),
756 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
757 QObject::tr("SMESH_BUT_YES"),
758 QObject::tr("SMESH_BUT_NO"), 0, 1);
765 QStringList aMeshNamesCollisionList;
766 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toLatin1().constData() );
767 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
768 QString anExistingMeshName( aMeshNames[ i ] );
769 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
770 QString anExportMeshName = (*aMeshIter).second;
771 if( anExportMeshName == anExistingMeshName ) {
772 aMeshNamesCollisionList.append( anExportMeshName );
777 if( !aMeshNamesCollisionList.isEmpty() ) {
778 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
779 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
780 QObject::tr("SMESH_WRN_WARNING"),
781 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
782 QObject::tr("SMESH_BUT_YES"),
783 QObject::tr("SMESH_BUT_NO"),
784 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
793 toCreateGroups = fd->IsChecked();
803 if ( !aFilename.isEmpty() ) {
804 // Check whether the file already exists and delete it if yes
805 QFile aFile( aFilename );
806 if ( aFile.exists() && toOverwrite )
808 SUIT_OverrideCursor wc;
811 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
812 // bool Renumber = false;
813 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
815 // Renumber= resMgr->booleanValue("renumbering");
817 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
818 // aMeshEditor->RenumberNodes();
819 // aMeshEditor->RenumberElements();
820 // if ( SMESHGUI::automaticUpdate() )
821 // SMESH::UpdateView();
825 aMeshIter = aMeshList.begin();
826 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
828 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
829 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
830 if ( aMeshOrGroup->_is_equivalent( aMeshItem ))
831 aMeshItem->ExportToMEDX( aFilename.toLatin1().data(), toCreateGroups,
832 aFormat, toOverwrite && aMeshIndex == 0 );
834 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups,
835 aFormat, toOverwrite && aMeshIndex == 0 );
840 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
842 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
843 if( !aMeshItem->_is_nil() )
844 aMeshItem->ExportSAUV( aFilename.toLatin1().data(), toCreateGroups );
849 if ( aMeshOrGroup->_is_equivalent( aMesh ))
850 aMesh->ExportDAT( aFilename.toLatin1().data() );
852 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toLatin1().data() );
856 if ( aMeshOrGroup->_is_equivalent( aMesh ))
857 aMesh->ExportUNV( aFilename.toLatin1().data() );
859 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toLatin1().data() );
863 if ( aMeshOrGroup->_is_equivalent( aMesh ))
864 aMesh->ExportSTL( aFilename.toLatin1().data(), aIsASCII_STL );
866 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toLatin1().data(), aIsASCII_STL );
870 aMeshIter = aMeshList.begin();
871 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
873 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
874 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
875 aMeshItem->ExportCGNS( aMeshOrGroup,
876 aFilename.toLatin1().data(),
877 toOverwrite && aMeshIndex == 0 );
882 toCreateGroups = true;
883 aMesh->ExportGMF( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups );
886 catch (const SALOME::SALOME_Exception& S_ex){
888 SUIT_MessageBox::warning(SMESHGUI::desktop(),
889 QObject::tr("SMESH_WRN_WARNING"),
890 QObject::tr("SMESH_EXPORT_FAILED"));
896 inline void InverseEntityMode(unsigned int& theOutputMode,
897 unsigned int theMode)
899 bool anIsNotPresent = ~theOutputMode & theMode;
901 theOutputMode |= theMode;
903 theOutputMode &= ~theMode;
906 void SetDisplayEntity(int theCommandID){
907 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
908 SALOME_ListIO selected;
910 aSel->selectedObjects( selected );
912 if(selected.Extent() >= 1){
913 SALOME_ListIteratorOfListIO It( selected );
914 for( ; It.More(); It.Next()){
915 Handle(SALOME_InteractiveObject) IObject = It.Value();
916 if(IObject->hasEntry()){
917 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
918 unsigned int aMode = anActor->GetEntityMode();
919 switch(theCommandID){
921 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
924 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
927 InverseEntityMode(aMode,SMESH_Actor::eEdges);
930 InverseEntityMode(aMode,SMESH_Actor::eFaces);
933 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
936 aMode = SMESH_Actor::eAllEntity;
940 anActor->SetEntityMode(aMode);
948 SALOME_ListIO selected;
949 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
953 LightApp_SelectionMgr* aSel = app->selectionMgr();
954 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
955 if( !aSel || !appStudy )
958 aSel->selectedObjects( selected );
959 if( selected.IsEmpty() )
962 Handle(SALOME_InteractiveObject) anIObject = selected.First();
964 _PTR(Study) aStudy = appStudy->studyDS();
965 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
966 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
967 if( aMainObject->_is_nil() )
970 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
972 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
973 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
975 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
976 SALOMEDS::Color aColor = aGroupObject->GetColor();
977 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
981 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
982 switch ( aGroupObject->GetType ()) {
984 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
986 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
988 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
990 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
992 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
993 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
996 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
997 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1003 SMESH::RepaintCurrentView();
1006 QString functorToString( SMESH::Controls::FunctorPtr f )
1008 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1009 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1010 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1011 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1012 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1013 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1014 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1015 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1016 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1017 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1018 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1019 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1020 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1021 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1022 type = QObject::tr( "WARP_ELEMENTS" );
1023 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1024 type = QObject::tr( "TAPER_ELEMENTS" );
1025 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1026 type = QObject::tr( "SKEW_ELEMENTS" );
1027 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1028 type = QObject::tr( "AREA_ELEMENTS" );
1029 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1030 type = QObject::tr( "LENGTH_EDGES" );
1031 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1032 type = QObject::tr( "LENGTH2D_EDGES" );
1033 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1034 type = QObject::tr( "MULTI_BORDERS" );
1035 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1036 type = QObject::tr( "MULTI2D_BORDERS" );
1037 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1038 type = QObject::tr( "FREE_NODES" );
1039 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1040 type = QObject::tr( "FREE_EDGES" );
1041 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1042 type = QObject::tr( "FREE_BORDERS" );
1043 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1044 type = QObject::tr( "FREE_FACES" );
1045 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1046 type = QObject::tr( "BARE_BORDER_VOLUME" );
1047 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1048 type = QObject::tr( "BARE_BORDER_FACE" );
1049 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1050 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1051 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1052 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1053 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1054 type = QObject::tr( "EQUAL_NODE" );
1055 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1056 type = QObject::tr( "EQUAL_EDGE" );
1057 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1058 type = QObject::tr( "EQUAL_FACE" );
1059 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1060 type = QObject::tr( "EQUAL_VOLUME" );
1064 void SaveDistribution()
1066 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1067 SALOME_ListIO selected;
1069 aSel->selectedObjects( selected );
1071 if ( selected.Extent() == 1 ) {
1072 Handle(SALOME_InteractiveObject) anIO = selected.First();
1073 if ( anIO->hasEntry() ) {
1074 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1075 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1076 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1077 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1078 if ( aScalarBarActor && aFunctor ) {
1079 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1081 std::vector<int> elements;
1082 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1083 if ( mesh->_is_nil() ) {
1084 SMESH::SMESH_IDSource_var idSource =
1085 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1086 if ( !idSource->_is_nil() )
1088 SMESH::long_array_var ids = idSource->GetIDs();
1089 elements.resize( ids->length() );
1090 for ( unsigned i = 0; i < elements.size(); ++i )
1091 elements[i] = ids[i];
1094 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1095 vtkLookupTable* lookupTable =
1096 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1097 double * minmax = lookupTable->GetRange();
1098 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1099 std::vector<int> nbEvents;
1100 std::vector<double> funValues;
1101 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
1102 QString anInitialPath = "";
1103 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1104 anInitialPath = QDir::currentPath();
1105 QString aMeshName = anIO->getName();
1107 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1108 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1109 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1110 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1111 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1114 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1116 if ( !aFilename.isEmpty() ) {
1117 QFile f( aFilename );
1118 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1119 QTextStream out( &f );
1120 out << "# Mesh: " << aMeshName << endl;
1121 out << "# Control: " << functorToString( aFunctor ) << endl;
1123 out.setFieldWidth( 10 );
1124 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1125 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1136 void ShowDistribution() {
1137 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1138 SALOME_ListIO selected;
1140 aSel->selectedObjects( selected );
1142 if ( selected.Extent() == 1 ) {
1143 Handle(SALOME_InteractiveObject) anIO = selected.First();
1144 if ( anIO->hasEntry() ) {
1145 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1146 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1147 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1148 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1154 #ifndef DISABLE_PLOT2DVIEWER
1155 void PlotDistribution() {
1156 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1160 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1161 SALOME_ListIO selected;
1163 aSel->selectedObjects( selected );
1165 if ( selected.Extent() == 1 ) {
1166 Handle(SALOME_InteractiveObject) anIO = selected.First();
1167 if ( anIO->hasEntry() ) {
1168 //Find Actor by entry before getting Plot2d viewer,
1169 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1170 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1172 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1177 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1181 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1185 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1186 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1187 QString functorName = functorToString( anActor->GetFunctor());
1188 QString aHistogramName("%1 : %2");
1189 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1190 aHistogram->setName(aHistogramName);
1191 aHistogram->setHorTitle(functorName);
1192 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1193 aPlot->displayObject(aHistogram, true);
1198 #endif //DISABLE_PLOT2DVIEWER
1200 void DisableAutoColor(){
1201 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1202 SALOME_ListIO selected;
1204 aSel->selectedObjects( selected );
1206 if(selected.Extent()){
1207 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1208 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1209 if ( !aMesh->_is_nil() ) {
1210 aMesh->SetAutoColor( false );
1215 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1217 SALOME_ListIO selected;
1218 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1222 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1223 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1224 if( !aSel || !appStudy )
1227 if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection
1228 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1229 aModule->EmitSignalDeactivateDialog();
1230 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1231 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1236 _PTR(Study) aStudy = appStudy->studyDS();
1238 aSel->selectedObjects( selected );
1240 if(selected.Extent() >= 1){
1241 switch(theCommandID){
1243 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1244 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1249 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1250 QColor orientationColor, outlineColor, volumeColor;
1251 int deltaF = 0, deltaV = 0;
1255 int outlineWidth = 1;
1256 double shrinkCoef = 0.0;
1257 double orientationScale = 0.0;
1258 bool orientation3d = false;
1259 VTK::MarkerType markerType = VTK::MT_NONE;
1260 VTK::MarkerScale markerScale = VTK::MS_NONE;
1262 bool hasNodes = false;
1263 int presentEntities = 0;
1264 bool firstTime = true;
1266 SALOME_ListIteratorOfListIO It( selected );
1267 for ( ; It.More(); It.Next() ) {
1268 Handle(SALOME_InteractiveObject) IObject = It.Value();
1269 if ( !IObject->hasEntry() ) continue;
1270 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1271 if ( !anActor || !anActor->GetObject() ) continue;
1274 // nodes: color, marker
1275 anActor->GetNodeColor( color[0], color[1], color[2] );
1276 nodeColor.setRgbF( color[0], color[1], color[2] );
1277 markerType = anActor->GetMarkerType();
1278 markerScale = anActor->GetMarkerScale();
1279 markerId = anActor->GetMarkerTexture();
1280 // edges: color, width
1281 anActor->GetEdgeColor( color[0], color[1], color[2] );
1282 edgeColor.setRgbF( color[0], color[1], color[2] );
1283 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1284 // faces: front color, back color (delta)
1285 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1286 faceColor.setRgbF( color[0], color[1], color[2] );
1287 // faces: front color, back color (delta)
1288 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1289 volumeColor.setRgbF( color[0], color[1], color[2] );
1290 // 0d elements: color, size
1291 anActor->Get0DColor( color[0], color[1], color[2] );
1292 elem0dColor.setRgbF( color[0], color[1], color[2] );
1293 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1294 // balls: color, size
1295 anActor->GetBallColor( color[0], color[1], color[2] );
1296 ballColor.setRgbF( color[0], color[1], color[2] );
1297 ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1299 anActor->GetOutlineColor( color[0], color[1], color[2] );
1300 outlineColor.setRgbF( color[0], color[1], color[2] );
1301 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1302 // orientation vectors: color, scale, 3d flag
1303 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1304 orientationColor.setRgbF( color[0], color[1], color[2] );
1305 orientationScale = anActor->GetFacesOrientationScale();
1306 orientation3d = anActor->GetFacesOrientation3DVectors();
1308 shrinkCoef = anActor->GetShrinkFactor();
1311 firstTime = false; // we only take properties from first object (for performance reasons)
1314 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1315 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1316 presentEntities = presentEntities | SMESH_Actor::eEdges;
1317 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1318 presentEntities = presentEntities | SMESH_Actor::eFaces;
1319 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1320 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1321 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1322 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1323 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1324 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1326 // as we know that all types of elements are present, we can exit the loop
1327 if ( presentEntities == SMESH_Actor::eAllEntity )
1331 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1332 // nodes: color, marker
1333 dlg.setNodeColor( nodeColor );
1334 if( markerType != VTK::MT_USER )
1335 dlg.setNodeMarker( markerType, markerScale );
1337 dlg.setNodeCustomMarker( markerId );
1338 // edges: color, line width
1339 dlg.setEdgeColor( edgeColor );
1340 dlg.setEdgeWidth( edgeWidth );
1341 // faces: front color, back color
1342 dlg.setFaceColor( faceColor, deltaF );
1343 // volumes: normal color, reversed color
1344 dlg.setVolumeColor( volumeColor, deltaV );
1345 // outlines: color, line width
1346 dlg.setOutlineColor( outlineColor );
1347 dlg.setOutlineWidth( outlineWidth );
1348 // 0d elements: color, size
1349 dlg.setElem0dColor( elem0dColor );
1350 dlg.setElem0dSize( elem0dSize );
1351 // balls: color, size
1352 dlg.setBallColor( ballColor );
1353 dlg.setBallSize( ballSize );
1354 // orientation: color, scale, 3d flag
1355 dlg.setOrientationColor( orientationColor );
1356 dlg.setOrientationSize( int( orientationScale * 100. ) );
1357 dlg.setOrientation3d( orientation3d );
1358 // shrink: scale factor
1359 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1360 // hide unused controls
1361 dlg.showControls( presentEntities, hasNodes );
1364 nodeColor = dlg.nodeColor();
1365 markerType = dlg.nodeMarkerType();
1366 markerScale = dlg.nodeMarkerScale();
1367 markerId = dlg.nodeMarkerId();
1368 edgeColor = dlg.edgeColor();
1369 edgeWidth = dlg.edgeWidth();
1370 faceColor = dlg.faceColor();
1371 deltaF = dlg.faceColorDelta();
1372 volumeColor = dlg.volumeColor();
1373 deltaV = dlg.volumeColorDelta();
1374 outlineColor = dlg.outlineColor();
1375 outlineWidth = dlg.outlineWidth();
1376 elem0dColor = dlg.elem0dColor();
1377 elem0dSize = dlg.elem0dSize();
1378 ballColor = dlg.ballColor();
1379 ballSize = dlg.ballSize();
1380 orientationColor = dlg.orientationColor();
1381 orientationScale = dlg.orientationSize() / 100.;
1382 orientation3d = dlg.orientation3d();
1383 shrinkCoef = dlg.shrinkCoef() / 100.;
1385 // store point markers map that might be changed by the user
1386 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1388 // set properties from dialog box to the presentations
1389 SALOME_ListIteratorOfListIO It( selected );
1390 for ( ; It.More(); It.Next() ) {
1391 Handle(SALOME_InteractiveObject) IObject = It.Value();
1392 if ( !IObject->hasEntry() ) continue;
1393 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1394 if ( !anActor ) continue;
1396 // nodes: color, marker
1397 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1398 if ( markerType != VTK::MT_USER ) {
1399 anActor->SetMarkerStd( markerType, markerScale );
1402 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1403 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1404 if ( iter != markerMap.end() )
1405 anActor->SetMarkerTexture( markerId, iter->second.second );
1407 // volumes: normal color, reversed color (delta)
1408 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1409 // faces: front color, back color (delta)
1410 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1411 // edges: color, width
1412 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1413 anActor->SetLineWidth( edgeWidth );
1415 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1416 anActor->SetOutlineWidth( outlineWidth );
1417 // 0D elements: color, size
1418 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1419 anActor->Set0DSize( elem0dSize );
1420 // balls: color, size
1421 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1422 anActor->SetBallSize( ballSize );
1423 // orientation: color, scale, 3d flag
1424 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1425 anActor->SetFacesOrientationScale( orientationScale );
1426 anActor->SetFacesOrientation3DVectors( orientation3d );
1428 anActor->SetShrinkFactor( shrinkCoef );
1430 // for groups, set also proper color
1431 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1432 if ( !aGroupObject->_is_nil() ) {
1433 SMESH::ElementType anElementType = aGroupObject->GetType();
1435 switch( anElementType ) {
1437 aColor = nodeColor; break;
1439 aColor = edgeColor; break;
1441 aColor = faceColor; break;
1443 aColor = volumeColor; break;
1445 aColor = elem0dColor; break;
1447 aColor = ballColor; break;
1451 if ( aColor.isValid() ) {
1452 SALOMEDS::Color aGroupColor;
1453 aGroupColor.R = aColor.redF();
1454 aGroupColor.G = aColor.greenF();
1455 aGroupColor.B = aColor.blueF();
1456 aGroupObject->SetColor( aGroupColor );
1458 } // if ( !aGroupObject->_is_nil() )
1459 } // for ( ; It.More(); It.Next() )
1460 SMESH::RepaintCurrentView();
1461 } // if ( dlg.exec() )
1464 } // switch(theCommandID)
1465 SALOME_ListIteratorOfListIO It( selected );
1466 for( ; It.More(); It.Next()){
1467 Handle(SALOME_InteractiveObject) IObject = It.Value();
1468 if(IObject->hasEntry()){
1469 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1470 switch(theCommandID){
1472 anActor->SetRepresentation(SMESH_Actor::eEdge);
1475 anActor->SetRepresentation(SMESH_Actor::eSurface);
1478 if(anActor->IsShrunk())
1479 anActor->UnShrink();
1481 anActor->SetShrink();
1484 anActor->SetRepresentation(SMESH_Actor::ePoint);
1487 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1488 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1491 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1492 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1498 SMESH::RepaintCurrentView();
1502 void Control( int theCommandID )
1504 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1505 SALOME_ListIO selected;
1507 aSel->selectedObjects( selected );
1509 if( !selected.IsEmpty() ){
1510 Handle(SALOME_InteractiveObject) anIO = selected.First();
1512 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1513 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1514 switch ( theCommandID ){
1516 aControl = SMESH_Actor::eLength;
1519 aControl = SMESH_Actor::eLength2D;
1522 aControl = SMESH_Actor::eFreeEdges;
1525 aControl = SMESH_Actor::eFreeBorders;
1528 aControl = SMESH_Actor::eMultiConnection;
1531 aControl = SMESH_Actor::eFreeNodes;
1534 aControl = SMESH_Actor::eMultiConnection2D;
1537 aControl = SMESH_Actor::eArea;
1540 aControl = SMESH_Actor::eTaper;
1543 aControl = SMESH_Actor::eAspectRatio;
1546 aControl = SMESH_Actor::eAspectRatio3D;
1549 aControl = SMESH_Actor::eMinimumAngle;
1552 aControl = SMESH_Actor::eWarping;
1555 aControl = SMESH_Actor::eSkew;
1558 aControl = SMESH_Actor::eVolume3D;
1561 aControl = SMESH_Actor::eFreeFaces;
1564 aControl = SMESH_Actor::eMaxElementLength2D;
1567 aControl = SMESH_Actor::eMaxElementLength3D;
1570 aControl = SMESH_Actor::eBareBorderVolume;
1573 aControl = SMESH_Actor::eBareBorderFace;
1576 aControl = SMESH_Actor::eOverConstrainedVolume;
1579 aControl = SMESH_Actor::eOverConstrainedFace;
1582 aControl = SMESH_Actor::eCoincidentNodes;
1585 aControl = SMESH_Actor::eCoincidentElems1D;
1588 aControl = SMESH_Actor:: eCoincidentElems2D;
1591 aControl = SMESH_Actor::eCoincidentElems3D;
1595 anActor->SetControlMode(aControl);
1596 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1597 SMESH::RepaintCurrentView();
1598 #ifndef DISABLE_PLOT2DVIEWER
1599 if(anActor->GetPlot2Histogram()) {
1600 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1601 QString functorName = functorToString( anActor->GetFunctor());
1602 QString aHistogramName("%1 : %2");
1603 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1604 aHistogram->setName(aHistogramName);
1605 aHistogram->setHorTitle(functorName);
1606 SMESH::ProcessIn2DViewers(anActor);
1615 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1616 SMESH::MeshObjectType theType,
1617 const QString theInTypeName,
1618 QString & theOutTypeName)
1620 SMESH_TypeFilter aTypeFilter( theType );
1622 if( !theIO.IsNull() )
1624 entry = theIO->getEntry();
1625 LightApp_DataOwner owner( entry );
1626 if ( aTypeFilter.isOk( &owner )) {
1627 theOutTypeName = theInTypeName;
1635 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1637 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1638 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1640 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1641 CORBA::String_var anID = aSComp->GetID().c_str();
1642 if (!strcmp(anID.in(),theIO->getEntry()))
1648 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1649 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1650 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1651 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1652 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1660 QString CheckHomogeneousSelection()
1662 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1663 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1664 SALOME_ListIO selected;
1666 aSel->selectedObjects( selected );
1668 QString RefType = CheckTypeObject(selected.First());
1669 SALOME_ListIteratorOfListIO It(selected);
1670 for ( ; It.More(); It.Next())
1672 Handle(SALOME_InteractiveObject) IObject = It.Value();
1673 QString Type = CheckTypeObject(IObject);
1674 if (Type.compare(RefType) != 0)
1675 return "Heterogeneous Selection";
1682 void SMESHGUI::OnEditDelete()
1684 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1685 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1686 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1688 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1689 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1690 _PTR(GenericAttribute) anAttr;
1691 _PTR(AttributeIOR) anIOR;
1693 int objectCount = 0;
1695 QString aParentComponent = QString::null;
1696 Handle(SALOME_InteractiveObject) anIO;
1697 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1699 anIO = anIt.Value();
1700 QString cur = anIO->getComponentDataType();
1701 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1703 // check if object is reference
1704 _PTR(SObject) aRefSObj;
1705 aNameList.append("\n - ");
1706 if ( aSO->ReferencedObject( aRefSObj ) ) {
1707 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1708 aNameList.append( aRefName );
1709 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1712 aNameList.append(anIO->getName());
1716 if( aParentComponent.isNull() )
1717 aParentComponent = cur;
1718 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1719 aParentComponent = "";
1722 if ( objectCount == 0 )
1723 return; // No Valid Objects Selected
1725 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1726 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1727 QObject::tr("ERR_ERROR"),
1728 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1731 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1732 if (SUIT_MessageBox::warning
1733 (SMESHGUI::desktop(),
1734 QObject::tr("SMESH_WRN_WARNING"),
1735 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1736 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1737 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1740 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1742 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1743 // then treat them all starting from the deepest objects (at list back)
1744 std::list< _PTR(SObject) > listSO;
1745 SALOME_ListIteratorOfListIO It(selected);
1746 for( ; It.More(); It.Next()) // loop on selected IO's
1748 Handle(SALOME_InteractiveObject) IObject = It.Value();
1749 if(IObject->hasEntry()) {
1750 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1752 // disable removal of "SMESH" component object
1753 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1755 if ( engineIOR() == anIOR->Value().c_str() )
1758 //Check the referenced object
1759 _PTR(SObject) aRefSObject;
1760 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1761 aSO = aRefSObject; // Delete main Object instead of reference
1763 listSO.push_back( aSO );
1764 std::list< _PTR(SObject) >::iterator itSO = listSO.begin();
1765 for ( ; itSO != listSO.end(); ++itSO ) {
1766 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1767 for (it->InitEx(false); it->More(); it->Next())
1768 listSO.push_back( it->Value() );
1772 // Check if none of objects to delete is referred from outside
1773 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1774 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1776 _PTR(SObject) SO = *ritSO;
1777 if ( !SO ) continue;
1778 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1779 for (size_t i = 0; i < aReferences.size(); i++) {
1780 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1781 std::string type = aComponent->ComponentDataType();
1782 if ( type != "SMESH" )
1784 SUIT_MessageBox::warning( anApp->desktop(),
1785 QObject::tr("WRN_WARNING"),
1786 QObject::tr("DEP_OBJECT") );
1787 return; // outside SMESH, there is an object depending on a SMESH object
1792 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1793 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1795 Handle(SALOME_InteractiveObject) IObject = It.Value();
1796 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1797 if ( !mesh->_is_nil() )
1801 // Treat SO's in the list starting from the back
1802 aStudyBuilder->NewCommand(); // There is a transaction
1803 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1805 _PTR(SObject) SO = *ritSO;
1806 if ( !SO ) continue;
1807 std::string anEntry = SO->GetID();
1809 /** Erase graphical object **/
1810 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1811 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1812 // ViewManagerList aViewMenegers = anApp->viewManagers();
1813 // ViewManagerList::const_iterator it = aViewMenegers.begin();
1814 // for( ; it != aViewMenegers.end(); it++) {
1815 // SUIT_ViewManager* vm = *it;
1816 // int nbSf = vm ? vm->getViewsCount() : 0;
1818 // QVector<SUIT_ViewWindow*> aViews = vm->getViews();
1819 // for(int i = 0; i < nbSf; i++){
1820 // SUIT_ViewWindow *sf = aViews[i];
1821 // if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
1822 // SMESH::RemoveActor(sf,anActor);
1828 /** Remove an object from data structures **/
1829 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1830 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1831 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1832 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1833 aMesh->RemoveGroup( aGroup );
1835 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1836 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1837 aMesh->RemoveSubMesh( aSubMesh );
1839 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1841 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1844 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1845 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1846 QString objType = CheckTypeObject(IObject);
1847 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1848 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1849 aStudyBuilder->RemoveObjectWithChildren( SO );
1851 else {// default action: remove SObject from the study
1852 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1853 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1855 aStudyBuilder->RemoveObjectWithChildren( SO );
1859 } /* listSO back loop */
1861 aStudyBuilder->CommitCommand();
1863 /* Clear any previous selection */
1865 aSel->setSelectedObjects( l1 );
1867 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1872 SMESHGUI_EXPORT CAM_Module* createModule()
1874 return new SMESHGUI();
1877 SMESHGUI_EXPORT char* getModuleVersion() {
1878 return (char*)SMESH_VERSION_STR;
1882 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1884 //=============================================================================
1888 //=============================================================================
1889 SMESHGUI::SMESHGUI() :
1890 SalomeApp_Module( "SMESH" )
1892 if ( CORBA::is_nil( myComponentSMESH ) )
1894 CORBA::Boolean anIsEmbeddedMode;
1895 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1896 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1898 // 0019923: EDF 765 SMESH : default values of hypothesis
1899 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1900 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1901 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1902 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1903 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1905 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1906 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1907 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1909 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1910 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1914 myActiveDialogBox = 0;
1915 myFilterLibraryDlg = 0;
1919 myEventCallbackCommand = vtkCallbackCommand::New();
1920 myEventCallbackCommand->Delete();
1921 myEventCallbackCommand->SetClientData( this );
1922 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1925 /* load resources for all available meshers */
1926 SMESH::InitAvailableHypotheses();
1929 //=============================================================================
1933 //=============================================================================
1934 SMESHGUI::~SMESHGUI()
1938 //=============================================================================
1942 //=============================================================================
1943 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1945 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1947 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1952 //=============================================================================
1956 //=============================================================================
1957 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1959 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1963 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
1964 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1965 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
1966 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
1967 return autoUpdate && !exceeded;
1970 //=============================================================================
1974 //=============================================================================
1975 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
1977 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
1980 //=============================================================================
1984 //=============================================================================
1985 SMESHGUI* SMESHGUI::GetSMESHGUI()
1987 SMESHGUI* smeshMod = 0;
1988 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
1991 CAM_Module* module = app->module( "Mesh" );
1992 smeshMod = dynamic_cast<SMESHGUI*>( module );
1995 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
1997 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2000 _PTR(Study) aStudy = study->studyDS();
2002 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2011 Standard_EXPORT SMESHGUI* GetComponentGUI()
2013 return SMESHGUI::GetSMESHGUI();
2017 //=============================================================================
2021 //=============================================================================
2022 void SMESHGUI::SetState(int aState)
2027 //=============================================================================
2031 //=============================================================================
2032 void SMESHGUI::ResetState()
2037 //=============================================================================
2041 //=============================================================================
2042 void SMESHGUI::EmitSignalDeactivateDialog()
2044 emit SignalDeactivateActiveDialog();
2047 //=============================================================================
2051 //=============================================================================
2052 void SMESHGUI::EmitSignalStudyFrameChanged()
2054 emit SignalStudyFrameChanged();
2057 //=============================================================================
2061 //=============================================================================
2062 void SMESHGUI::EmitSignalCloseAllDialogs()
2064 emit SignalCloseAllDialogs();
2067 //=============================================================================
2071 //=============================================================================
2072 void SMESHGUI::EmitSignalVisibilityChanged()
2074 emit SignalVisibilityChanged();
2077 //=============================================================================
2081 //=============================================================================
2082 QDialog *SMESHGUI::GetActiveDialogBox()
2084 return myActiveDialogBox;
2087 //=============================================================================
2091 //=============================================================================
2092 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2094 myActiveDialogBox = (QDialog *) aDlg;
2098 //=============================================================================
2102 //=============================================================================
2103 SUIT_Desktop* SMESHGUI::desktop()
2105 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2107 return app->desktop();
2112 //=============================================================================
2116 //=============================================================================
2117 SalomeApp_Study* SMESHGUI::activeStudy()
2119 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2121 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2126 //=============================================================================
2130 //=============================================================================
2131 void SMESHGUI::Modified( bool theIsUpdateActions )
2133 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2134 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2135 appStudy->Modified();
2136 if( theIsUpdateActions )
2137 app->updateActions();
2142 //=============================================================================
2146 //=============================================================================
2147 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2149 /* Here the position is on the bottom right corner - 10 */
2150 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2152 SUIT_Desktop *PP = desktop();
2153 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2154 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2158 //=============================================================================
2162 //=============================================================================
2163 static int isStudyLocked(_PTR(Study) theStudy){
2164 return theStudy->GetProperties()->IsLocked();
2167 static bool checkLock(_PTR(Study) theStudy) {
2168 if (isStudyLocked(theStudy)) {
2169 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2170 QObject::tr("WRN_WARNING"),
2171 QObject::tr("WRN_STUDY_LOCKED") );
2177 //=======================================================================
2178 //function : CheckActiveStudyLocked
2180 //=======================================================================
2182 bool SMESHGUI::isActiveStudyLocked()
2184 _PTR(Study) aStudy = activeStudy()->studyDS();
2185 return checkLock( aStudy );
2188 //=============================================================================
2192 //=============================================================================
2193 bool SMESHGUI::OnGUIEvent( int theCommandID )
2195 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2199 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2200 SUIT_ResourceMgr* mgr = resourceMgr();
2204 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2205 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2208 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2209 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2211 //QAction* act = action( theCommandID );
2213 switch (theCommandID) {
2215 if(checkLock(aStudy)) break;
2227 if(checkLock(aStudy)) break;
2228 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2232 case 150: //MED FILE INFORMATION
2234 SALOME_ListIO selected;
2235 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2237 aSel->selectedObjects( selected );
2238 if( selected.Extent() )
2240 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2241 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2242 if ( !aMesh->_is_nil() )
2244 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2251 case 122: // EXPORT MED
2266 ::ExportMeshToFile(theCommandID);
2270 case 200: // SCALAR BAR
2272 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2273 SALOME_ListIO selected;
2275 aSel->selectedObjects( selected );
2277 if( selected.Extent() ) {
2278 Handle(SALOME_InteractiveObject) anIO = selected.First();
2279 if( anIO->hasEntry() ) {
2280 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2281 anActor->SetControlMode( SMESH_Actor::eNone );
2282 #ifndef DISABLE_PLOT2DVIEWER
2283 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2292 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2297 // dump control distribution data to the text file
2298 ::SaveDistribution();
2304 // show/ distribution
2305 ::ShowDistribution();
2309 #ifndef DISABLE_PLOT2DVIEWER
2312 // plot distribution
2313 ::PlotDistribution();
2324 ::DisableAutoColor();
2327 case 1134: // Clipping
2328 case 1133: // Tranparency
2329 case 1132: // Display preferences (colors, shrink size, line width, ...)
2336 ::SetDisplayMode(theCommandID, myMarkerMap);
2339 //2D quadratic representation
2342 ::SetDisplayMode(theCommandID, myMarkerMap);
2346 case 216: // 0D elements
2349 case 219: // Volumes
2350 case 220: // All Entity
2352 ::SetDisplayEntity(theCommandID);
2355 case 221: // Orientation of faces
2357 LightApp_SelectionMgr* mgr = selectionMgr();
2358 SALOME_ListIO selected; mgr->selectedObjects( selected );
2360 SALOME_ListIteratorOfListIO it(selected);
2361 for( ; it.More(); it.Next()) {
2362 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2363 if(anIObject->hasEntry()) {
2364 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2365 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2374 if(checkLock(aStudy)) break;
2376 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2379 SMESH::UpdateView();
2381 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2382 SMESH::OnVisuException();
2384 catch (...) { // PAL16774 (Crash after display of many groups)
2385 SMESH::OnVisuException();
2389 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2390 aSel->selectedObjects( l );
2391 aSel->setSelectedObjects( l );
2396 case 301: // DISPLAY
2397 case 302: // DISPLAY ONLY
2399 SMESH::EDisplaing anAction;
2400 switch (theCommandID) {
2401 case 300: anAction = SMESH::eErase; break;
2402 case 301: anAction = SMESH::eDisplay; break;
2403 case 302: anAction = SMESH::eDisplayOnly; break;
2406 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2407 SALOME_ListIO sel_objects, to_process;
2409 aSel->selectedObjects( sel_objects );
2411 if( theCommandID==302 )
2413 MESSAGE("anAction = SMESH::eDisplayOnly");
2414 startOperation( myEraseAll );
2417 extractContainers( sel_objects, to_process );
2420 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2424 SALOME_ListIteratorOfListIO It( to_process );
2425 for ( ; It.More(); It.Next()) {
2427 Handle(SALOME_InteractiveObject) IOS = It.Value();
2428 if (IOS->hasEntry()) {
2430 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2431 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2432 break; // PAL16774 (Crash after display of many groups)
2434 if (anAction == SMESH::eDisplayOnly)
2436 MESSAGE("anAction = SMESH::eDisplayOnly");
2437 anAction = SMESH::eDisplay;
2443 // PAL13338 + PAL15161 -->
2444 if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2445 MESSAGE("anAction = SMESH::eDisplayOnly");
2446 SMESH::UpdateView();
2447 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2449 // PAL13338 + PAL15161 <--
2451 catch (...) { // PAL16774 (Crash after display of many groups)
2452 SMESH::OnVisuException();
2455 if (anAction == SMESH::eErase) {
2456 MESSAGE("anAction == SMESH::eErase");
2458 aSel->setSelectedObjects( l1 );
2461 aSel->setSelectedObjects( to_process );
2468 if(checkLock(aStudy)) break;
2471 EmitSignalDeactivateDialog();
2473 ( new SMESHGUI_NodesDlg( this ) )->show();
2476 SUIT_MessageBox::warning(desktop(),
2477 tr("SMESH_WRN_WARNING"),
2478 tr("SMESH_WRN_VIEWER_VTK"));
2483 case 2151: // FILTER
2487 EmitSignalDeactivateDialog();
2488 ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2493 case 701: // COMPUTE MESH
2494 case 711: // PRECOMPUTE MESH
2495 case 712: // EVALUATE MESH
2496 case 713: // MESH ORDER
2497 case 702: // Create mesh
2498 case 703: // Create sub-mesh
2499 case 704: // Edit mesh/sub-mesh
2500 startOperation( theCommandID );
2502 case 705: // copy mesh
2504 if (checkLock(aStudy)) break;
2505 EmitSignalDeactivateDialog();
2506 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2509 case 710: // Build compound mesh
2511 if (checkLock(aStudy)) break;
2512 EmitSignalDeactivateDialog();
2513 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2517 case 407: // DIAGONAL INVERSION
2518 case 408: // Delete diagonal
2522 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2523 tr( "NOT_A_VTK_VIEWER" ) );
2527 if ( checkLock( aStudy ) )
2530 /*Standard_Boolean aRes;
2531 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2532 if ( aMesh->_is_nil() )
2534 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2535 tr( "SMESH_BAD_SELECTION" ) );
2539 EmitSignalDeactivateDialog();
2540 if ( theCommandID == 407 )
2541 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2543 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2546 case 409: // Change orientation
2547 case 410: // Union of triangles
2548 case 411: // Cutting of quadrangles
2549 case 419: // Splitting volumes into tetrahedra
2553 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2554 tr( "NOT_A_VTK_VIEWER" ) );
2558 if ( checkLock( aStudy ) )
2561 EmitSignalDeactivateDialog();
2562 SMESHGUI_MultiEditDlg* aDlg = NULL;
2563 if ( theCommandID == 409 )
2564 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2565 else if ( theCommandID == 410 )
2566 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2567 else if ( theCommandID == 419 )
2568 aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2570 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2575 case 412: // Smoothing
2577 if(checkLock(aStudy)) break;
2579 EmitSignalDeactivateDialog();
2580 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2583 SUIT_MessageBox::warning(desktop(),
2584 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2588 case 413: // Extrusion
2590 if (checkLock(aStudy)) break;
2592 EmitSignalDeactivateDialog();
2593 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2595 SUIT_MessageBox::warning(desktop(),
2596 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2600 case 414: // Revolution
2602 if(checkLock(aStudy)) break;
2604 EmitSignalDeactivateDialog();
2605 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2608 SUIT_MessageBox::warning(desktop(),
2609 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2613 case 415: // Pattern mapping
2615 if ( checkLock( aStudy ) )
2619 EmitSignalDeactivateDialog();
2620 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2623 SUIT_MessageBox::warning(desktop(),
2624 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2628 case 416: // Extrusion along a path
2630 if (checkLock(aStudy)) break;
2632 EmitSignalDeactivateDialog();
2633 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2635 SUIT_MessageBox::warning(desktop(),
2636 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2640 case 417: // Convert mesh to quadratic
2641 case 418: // create 2D mesh from 3D
2642 case 420: // Reorient faces
2643 case 806: // CREATE GEO GROUP
2645 startOperation( theCommandID );
2648 case 801: // CREATE GROUP
2652 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2653 tr( "NOT_A_VTK_VIEWER" ) );
2657 if(checkLock(aStudy)) break;
2658 EmitSignalDeactivateDialog();
2659 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2661 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2662 SALOME_ListIO selected;
2664 aSel->selectedObjects( selected );
2666 int nbSel = selected.Extent();
2668 // check if mesh is selected
2669 aMesh = SMESH::GetMeshByIO( selected.First() );
2671 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2676 case 802: // CONSTRUCT GROUP
2680 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2681 tr( "NOT_A_VTK_VIEWER" ) );
2685 if(checkLock(aStudy)) break;
2686 EmitSignalDeactivateDialog();
2688 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2689 SALOME_ListIO selected;
2691 aSel->selectedObjects( selected );
2693 int nbSel = selected.Extent();
2695 // check if submesh is selected
2696 Handle(SALOME_InteractiveObject) IObject = selected.First();
2697 if (IObject->hasEntry()) {
2698 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2700 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2701 if (!aSubMesh->_is_nil()) {
2703 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2704 // get submesh elements list by types
2705 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2706 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2707 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2708 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2709 // create group for each type o elements
2710 QString aName = IObject->getName();
2711 QStringList anEntryList;
2712 if (aNodes->length() > 0) {
2713 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2714 aGroup->Add(aNodes.inout());
2715 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2716 anEntryList.append( aSObject->GetID().c_str() );
2718 if (aEdges->length() > 0) {
2719 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2720 aGroup->Add(aEdges.inout());
2721 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2722 anEntryList.append( aSObject->GetID().c_str() );
2724 if (aFaces->length() > 0) {
2725 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2726 aGroup->Add(aFaces.inout());
2727 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2728 anEntryList.append( aSObject->GetID().c_str() );
2730 if (aVolumes->length() > 0) {
2731 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2732 aGroup->Add(aVolumes.inout());
2733 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2734 anEntryList.append( aSObject->GetID().c_str() );
2737 anApp->browseObjects( anEntryList );
2739 catch(const SALOME::SALOME_Exception & S_ex){
2740 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2747 SUIT_MessageBox::warning(desktop(),
2748 tr("SMESH_WRN_WARNING"),
2749 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2754 case 803: // EDIT GROUP
2758 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2759 tr( "NOT_A_VTK_VIEWER" ) );
2763 if(checkLock(aStudy)) break;
2764 EmitSignalDeactivateDialog();
2766 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2767 SALOME_ListIO selected;
2769 aSel->selectedObjects( selected );
2771 SALOME_ListIteratorOfListIO It (selected);
2772 int nbSelectedGroups = 0;
2773 for ( ; It.More(); It.Next() )
2775 SMESH::SMESH_GroupBase_var aGroup =
2776 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2777 if (!aGroup->_is_nil()) {
2779 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2783 if (nbSelectedGroups == 0)
2785 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2791 case 804: // Add elements to group
2793 if(checkLock(aStudy)) break;
2794 if (myState == 800) {
2795 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2796 if (aDlg) aDlg->onAdd();
2801 case 805: // Remove elements from group
2803 if(checkLock(aStudy)) break;
2804 if (myState == 800) {
2805 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2806 if (aDlg) aDlg->onRemove();
2811 case 815: // Edit GEOM GROUP as standalone
2815 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2816 tr( "NOT_A_VTK_VIEWER" ) );
2820 if(checkLock(aStudy)) break;
2821 EmitSignalDeactivateDialog();
2823 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2824 SALOME_ListIO selected;
2826 aSel->selectedObjects( selected );
2828 SALOME_ListIteratorOfListIO It (selected);
2829 for ( ; It.More(); It.Next() )
2831 SMESH::SMESH_GroupOnGeom_var aGroup =
2832 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2833 if (!aGroup->_is_nil()) {
2834 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2839 SMESH::SMESH_GroupOnFilter_var aGroup =
2840 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2841 if (!aGroup->_is_nil()) {
2842 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2850 case 810: // Union Groups
2851 case 811: // Intersect groups
2852 case 812: // Cut groups
2856 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2857 tr( "NOT_A_VTK_VIEWER" ) );
2861 if ( checkLock( aStudy ) )
2864 EmitSignalDeactivateDialog();
2866 SMESHGUI_GroupOpDlg* aDlg = 0;
2867 if ( theCommandID == 810 )
2868 aDlg = new SMESHGUI_UnionGroupsDlg( this );
2869 else if ( theCommandID == 811 )
2870 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2872 aDlg = new SMESHGUI_CutGroupsDlg( this );
2879 case 814: // Create groups of entities from existing groups of superior dimensions
2881 if ( checkLock( aStudy ) )
2884 EmitSignalDeactivateDialog();
2885 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2891 case 813: // Delete groups with their contents
2895 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2896 tr( "NOT_A_VTK_VIEWER" ) );
2900 if ( checkLock( aStudy ) )
2903 EmitSignalDeactivateDialog();
2905 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2909 case 900: // MESH INFOS
2910 case 903: // WHAT IS
2912 int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2913 EmitSignalDeactivateDialog();
2914 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2915 SALOME_ListIO selected;
2917 aSel->selectedObjects( selected );
2919 if ( selected.Extent() > 1 ) { // a dlg for each IO
2920 SALOME_ListIteratorOfListIO It( selected );
2921 for ( ; It.More(); It.Next() ) {
2922 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2923 dlg->showInfo( It.Value() );
2928 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2934 case 904: // FIND ELEM
2936 startOperation( theCommandID );
2940 case 1100: // EDIT HYPOTHESIS
2942 if(checkLock(aStudy)) break;
2944 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2945 SALOME_ListIO selected;
2947 aSel->selectedObjects( selected );
2949 int nbSel = selected.Extent();
2952 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2953 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
2955 /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
2956 /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects */
2957 /* Warning : however by internal mechanism all subMeshes icons are changed ! */
2958 if ( !aHypothesis->_is_nil() )
2961 //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2962 SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2964 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
2974 case 1102: // REMOVE HYPOTHESIS / ALGORITHMS
2976 if(checkLock(aStudy)) break;
2977 SUIT_OverrideCursor wc;
2979 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2980 SALOME_ListIO selected;
2982 aSel->selectedObjects( selected, QString::null, false );
2984 SALOME_ListIteratorOfListIO It(selected);
2985 for (int i = 0; It.More(); It.Next(), i++) {
2986 Handle(SALOME_InteractiveObject) IObject = It.Value();
2987 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2990 aSel->setSelectedObjects( l1 );
2996 case 4009: // ELEM0D
2998 case 4021: // TRIANGLE
3000 case 4023: // POLYGON
3004 case 4134: // PYRAMID
3005 case 4135: // OCTA12
3007 if(checkLock(aStudy)) break;
3009 EmitSignalDeactivateDialog();
3010 SMDSAbs_EntityType type = SMDSEntity_Edge;
3011 switch (theCommandID) {
3012 case 4008: type = SMDSEntity_Ball; break;
3013 case 4009: type = SMDSEntity_0D; break;
3014 case 4021: type = SMDSEntity_Triangle; break;
3015 case 4022: type = SMDSEntity_Quadrangle; break;
3016 case 4031: type = SMDSEntity_Tetra; break;
3017 case 4023: type = SMDSEntity_Polygon; break;
3018 case 4032: type = SMDSEntity_Hexa; break;
3019 case 4133: type = SMDSEntity_Penta; break;
3020 case 4134: type = SMDSEntity_Pyramid; break;
3021 case 4135: type = SMDSEntity_Hexagonal_Prism; break;
3024 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3027 SUIT_MessageBox::warning(desktop(),
3028 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3032 case 4033: // POLYHEDRON
3034 if(checkLock(aStudy)) break;
3036 EmitSignalDeactivateDialog();
3037 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3040 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3041 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3045 case 4034: // QUADRATIC EDGE
3046 case 4035: // QUADRATIC TRIANGLE
3047 case 4036: // QUADRATIC QUADRANGLE
3048 case 4136: // BIQUADRATIC QUADRANGLE
3049 case 4137: // BIQUADRATIC TRIANGLE
3050 case 4037: // QUADRATIC TETRAHEDRON
3051 case 4038: // QUADRATIC PYRAMID
3052 case 4039: // QUADRATIC PENTAHEDRON
3053 case 4040: // QUADRATIC HEXAHEDRON
3054 case 4140: // TRIQUADRATIC HEXAHEDRON
3056 if(checkLock(aStudy)) break;
3058 EmitSignalDeactivateDialog();
3059 SMDSAbs_EntityType type = SMDSEntity_Last;
3061 switch (theCommandID) {
3063 type = SMDSEntity_Quad_Edge; break;
3065 type = SMDSEntity_Quad_Triangle; break;
3067 type = SMDSEntity_Quad_Quadrangle; break;
3069 type = SMDSEntity_BiQuad_Quadrangle; break;
3071 type = SMDSEntity_BiQuad_Triangle; break;
3073 type = SMDSEntity_Quad_Tetra; break;
3075 type = SMDSEntity_Quad_Pyramid; break;
3077 type = SMDSEntity_Quad_Penta; break;
3079 type = SMDSEntity_Quad_Hexa; break;
3081 type = SMDSEntity_TriQuad_Hexa; break;
3084 if ( type != SMDSEntity_Last )
3085 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3088 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3089 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3093 case 4041: // REMOVES NODES
3095 if(checkLock(aStudy)) break;
3097 EmitSignalDeactivateDialog();
3098 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3101 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3102 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3106 case 4042: // REMOVES ELEMENTS
3108 if(checkLock(aStudy)) break;
3110 EmitSignalDeactivateDialog();
3111 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3115 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3116 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3120 case 4043: { // CLEAR_MESH
3122 if(checkLock(aStudy)) break;
3124 SALOME_ListIO selected;
3125 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3126 aSel->selectedObjects( selected );
3128 SUIT_OverrideCursor wc;
3129 SALOME_ListIteratorOfListIO It (selected);
3130 for ( ; It.More(); It.Next() )
3132 Handle(SALOME_InteractiveObject) IOS = It.Value();
3133 SMESH::SMESH_Mesh_var aMesh =
3134 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3135 if ( aMesh->_is_nil()) continue;
3137 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3139 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3140 SMESH::ModifiedMesh( aMeshSObj, false, true);
3141 // hide groups and submeshes
3142 _PTR(ChildIterator) anIter =
3143 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3144 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3146 _PTR(SObject) so = anIter->Value();
3147 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3150 catch (const SALOME::SALOME_Exception& S_ex){
3152 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3156 SMESH::UpdateView();
3160 case 4044: // REMOVE ORPHAN NODES
3162 if(checkLock(aStudy)) break;
3163 SALOME_ListIO selected;
3164 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3165 aSel->selectedObjects( selected );
3166 if ( selected.Extent() == 1 ) {
3167 Handle(SALOME_InteractiveObject) anIO = selected.First();
3168 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3169 if ( !aMesh->_is_nil() ) {
3170 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3171 tr( "SMESH_WARNING" ),
3172 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3173 SUIT_MessageBox::Yes |
3174 SUIT_MessageBox::No,
3175 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3178 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3179 int removed = aMeshEditor->RemoveOrphanNodes();
3180 SUIT_MessageBox::information(SMESHGUI::desktop(),
3181 tr("SMESH_INFORMATION"),
3182 tr("NB_NODES_REMOVED").arg(removed));
3183 if ( removed > 0 ) {
3184 SMESH::UpdateView();
3185 SMESHGUI::Modified();
3188 catch (const SALOME::SALOME_Exception& S_ex) {
3189 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3198 case 4051: // RENUMBERING NODES
3200 if(checkLock(aStudy)) break;
3202 EmitSignalDeactivateDialog();
3203 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3207 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3208 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3212 case 4052: // RENUMBERING ELEMENTS
3214 if(checkLock(aStudy)) break;
3216 EmitSignalDeactivateDialog();
3217 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3221 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3222 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3226 case 4061: // TRANSLATION
3228 if(checkLock(aStudy)) break;
3230 EmitSignalDeactivateDialog();
3231 ( new SMESHGUI_TranslationDlg( this ) )->show();
3234 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3235 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3239 case 4062: // ROTATION
3241 if(checkLock(aStudy)) break;
3243 EmitSignalDeactivateDialog();
3244 ( new SMESHGUI_RotationDlg( this ) )->show();
3247 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3248 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3252 case 4063: // SYMMETRY
3254 if(checkLock(aStudy)) break;
3256 EmitSignalDeactivateDialog();
3257 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3260 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3261 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3265 case 4064: // SEWING
3267 if(checkLock(aStudy)) break;
3269 EmitSignalDeactivateDialog();
3270 ( new SMESHGUI_SewingDlg( this ) )->show();
3273 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3274 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3278 case 4065: // MERGE NODES
3280 if(checkLock(aStudy)) break;
3282 EmitSignalDeactivateDialog();
3283 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3286 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3287 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3291 case 4066: // MERGE EQUAL ELEMENTS
3293 if (checkLock(aStudy)) break;
3295 EmitSignalDeactivateDialog();
3296 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3298 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3299 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3304 case 4067: // MAKE MESH PASS THROUGH POINT
3305 startOperation( 4067 );
3310 if(checkLock(aStudy)) break;
3312 EmitSignalDeactivateDialog();
3313 ( new SMESHGUI_ScaleDlg( this ) )->show();
3316 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3317 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3322 case 4069: // DUPLICATE NODES
3324 if(checkLock(aStudy)) break;
3326 EmitSignalDeactivateDialog();
3327 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3330 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3331 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3336 case 4070: // 0D_ON_ALL_NODES
3337 startOperation( 4070 );
3340 case 5105: // Library of selection filters
3342 static QList<int> aTypes;
3343 if ( aTypes.isEmpty() )
3345 aTypes.append( SMESH::NODE );
3346 aTypes.append( SMESH::EDGE );
3347 aTypes.append( SMESH::FACE );
3348 aTypes.append( SMESH::VOLUME );
3350 if (!myFilterLibraryDlg)
3351 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3352 else if (myFilterLibraryDlg->isHidden())
3353 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3354 myFilterLibraryDlg->raise();
3358 case 6017: // CONTROLS
3386 LightApp_SelectionMgr* mgr = selectionMgr();
3387 SALOME_ListIO selected; mgr->selectedObjects( selected );
3389 if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3390 _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3392 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3393 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
3394 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3395 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
3396 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3397 ::Control( theCommandID );
3402 SUIT_MessageBox::warning(desktop(),
3403 tr( "SMESH_WRN_WARNING" ),
3404 tr( "SMESH_BAD_SELECTION" ) );
3408 SUIT_MessageBox::warning(desktop(),
3409 tr( "SMESH_WRN_WARNING" ),
3410 tr( "NOT_A_VTK_VIEWER" ) );
3415 LightApp_SelectionMgr* mgr = selectionMgr();
3416 SALOME_ListIO selected; mgr->selectedObjects( selected );
3418 SALOME_ListIteratorOfListIO it(selected);
3419 for( ; it.More(); it.Next()) {
3420 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3421 if(anIObject->hasEntry()) {
3422 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3423 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3431 LightApp_SelectionMgr* mgr = selectionMgr();
3432 SALOME_ListIO selected; mgr->selectedObjects( selected );
3434 SALOME_ListIteratorOfListIO it(selected);
3435 for( ; it.More(); it.Next()) {
3436 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3437 if(anIObject->hasEntry())
3438 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3439 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3447 int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3448 EmitSignalDeactivateDialog();
3449 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3455 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3456 //updateObjBrowser();
3460 //=============================================================================
3464 //=============================================================================
3465 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3470 //=============================================================================
3474 //=============================================================================
3475 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3480 //=============================================================================
3484 //=============================================================================
3485 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3490 //=============================================================================
3491 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3492 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3494 //=============================================================================
3495 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3496 SUIT_ViewWindow* wnd )
3498 if(theIO->hasEntry()){
3499 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3500 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3504 //=======================================================================
3505 // function : createSMESHAction
3507 //=======================================================================
3508 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3509 const int key, const bool toggle, const QString& shortcutAction )
3512 QWidget* parent = application()->desktop();
3513 SUIT_ResourceMgr* resMgr = resourceMgr();
3515 if ( !icon_id.isEmpty() )
3516 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3518 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3519 if ( !pix.isNull() )
3520 icon = QIcon( pix );
3522 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3523 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3524 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3526 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3527 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3530 //=======================================================================
3531 // function : createPopupItem
3533 //=======================================================================
3534 void SMESHGUI::createPopupItem( const int id,
3535 const QString& clients,
3536 const QString& types,
3537 const QString& theRule,
3540 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3541 popupMgr()->insert( action( id ), pId, 0 );
3543 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3544 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3545 QString rule = "(%1) and (%2) and (%3)";
3546 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3547 if( clients.isEmpty() )
3548 rule = rule.arg( QString( "true" ) );
3550 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3551 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3554 bool cont = myRules.contains( id );
3556 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3558 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3559 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3562 //=======================================================================
3563 // function : initialize
3565 //=======================================================================
3566 void SMESHGUI::initialize( CAM_Application* app )
3568 SalomeApp_Module::initialize( app );
3570 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3572 /* Automatic Update flag */
3573 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3575 // ----- create actions --------------
3577 //createSMESHAction( 111, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3578 createSMESHAction( 112, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3579 createSMESHAction( 113, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3580 createSMESHAction( 114, "NUM" );
3581 createSMESHAction( 115, "IMPORT_STL" );
3582 createSMESHAction( 116, "IMPORT_CGNS" );
3583 createSMESHAction( 117, "IMPORT_SAUV" );
3584 createSMESHAction( 118, "IMPORT_GMF" );
3585 createSMESHAction( 121, "DAT" );
3586 createSMESHAction( 122, "MED" );
3587 createSMESHAction( 123, "UNV" );
3588 createSMESHAction( 140, "STL" );
3589 createSMESHAction( 142, "CGNS");
3590 createSMESHAction( 144, "SAUV");
3591 createSMESHAction( 146, "GMF" );
3592 createSMESHAction( 124, "DAT" );
3593 createSMESHAction( 125, "MED" );
3594 createSMESHAction( 126, "UNV" );
3595 createSMESHAction( 141, "STL" );
3596 createSMESHAction( 143, "CGNS");
3597 createSMESHAction( 145, "SAUV");
3598 createSMESHAction( 147, "GMF" );
3599 createSMESHAction( 150, "FILE_INFO" );
3600 createSMESHAction( 33, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3601 createSMESHAction( 5105, "SEL_FILTER_LIB" );
3602 createSMESHAction( 701, "COMPUTE", "ICON_COMPUTE" );
3603 createSMESHAction( 702, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3604 createSMESHAction( 703, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3605 createSMESHAction( 704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3606 createSMESHAction( 705, "COPY_MESH", "ICON_COPY_MESH" );
3607 createSMESHAction( 710, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3608 createSMESHAction( 711, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3609 createSMESHAction( 712, "EVALUATE", "ICON_COMPUTE" );
3610 createSMESHAction( 713, "MESH_ORDER", "ICON_COMPUTE" );
3611 createSMESHAction( 806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3612 createSMESHAction( 801, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3613 createSMESHAction( 802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3614 createSMESHAction( 803, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3615 createSMESHAction( 815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3616 createSMESHAction( 804, "ADD" );
3617 createSMESHAction( 805, "REMOVE" );
3618 createSMESHAction( 810, "UN_GROUP", "ICON_UNION" );
3619 createSMESHAction( 811, "INT_GROUP", "ICON_INTERSECT" );
3620 createSMESHAction( 812, "CUT_GROUP", "ICON_CUT" );
3621 createSMESHAction( 814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3622 createSMESHAction( 813, "DEL_GROUP", "ICON_DEL_GROUP" );
3623 createSMESHAction( 900, "ADV_INFO", "ICON_ADV_INFO" );
3624 //createSMESHAction( 902, "STD_INFO", "ICON_STD_INFO" );
3625 //createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3626 createSMESHAction( 904, "FIND_ELEM", "ICON_FIND_ELEM" );
3627 createSMESHAction( 6001, "LENGTH", "ICON_LENGTH", 0, true );
3628 createSMESHAction( 6002, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3629 createSMESHAction( 6021, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3630 createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3631 createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3632 createSMESHAction( 6024, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3633 createSMESHAction( 6025, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3634 createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3635 createSMESHAction( 6027, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3636 createSMESHAction( 6028, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3637 createSMESHAction( 6029, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3638 createSMESHAction( 6030, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3639 createSMESHAction( 6031, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3640 createSMESHAction( 6003, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3641 createSMESHAction( 6004, "CONNECTION", "ICON_CONNECTION", 0, true );
3642 createSMESHAction( 6005, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3643 createSMESHAction( 6011, "AREA", "ICON_AREA", 0, true );
3644 createSMESHAction( 6012, "TAPER", "ICON_TAPER", 0, true );
3645 createSMESHAction( 6013, "ASPECT", "ICON_ASPECT", 0, true );
3646 createSMESHAction( 6014, "MIN_ANG", "ICON_ANGLE", 0, true );
3647 createSMESHAction( 6015, "WARP", "ICON_WARP", 0, true );
3648 createSMESHAction( 6016, "SKEW", "ICON_SKEW", 0, true );
3649 createSMESHAction( 6017, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3650 createSMESHAction( 6018, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3651 createSMESHAction( 6019, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3652 createSMESHAction( 6009, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3653 createSMESHAction( 4000, "NODE", "ICON_DLG_NODE" );
3654 createSMESHAction( 4009, "ELEM0D", "ICON_DLG_ELEM0D" );
3655 createSMESHAction( 4008, "BALL", "ICON_DLG_BALL" );
3656 createSMESHAction( 4010, "EDGE", "ICON_DLG_EDGE" );
3657 createSMESHAction( 4021, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3658 createSMESHAction( 4022, "QUAD", "ICON_DLG_QUADRANGLE" );
3659 createSMESHAction( 4023, "POLYGON", "ICON_DLG_POLYGON" );
3660 createSMESHAction( 4031, "TETRA", "ICON_DLG_TETRAS" );
3661 createSMESHAction( 4032, "HEXA", "ICON_DLG_HEXAS" );
3662 createSMESHAction( 4133, "PENTA", "ICON_DLG_PENTA" );
3663 createSMESHAction( 4134, "PYRAMID", "ICON_DLG_PYRAMID" );
3664 createSMESHAction( 4135, "OCTA", "ICON_DLG_OCTA" );
3665 createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3666 createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3667 createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3668 createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3669 createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3670 createSMESHAction( 4137, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3671 createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3672 createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3673 createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3674 createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3675 createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3676 createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3677 createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3678 createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3679 createSMESHAction( 4043, "CLEAR_MESH" , "ICON_CLEAR_MESH" );
3680 createSMESHAction( 4051, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3681 createSMESHAction( 4052, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3682 createSMESHAction( 4061, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3683 createSMESHAction( 4062, "ROT", "ICON_DLG_MESH_ROTATION" );
3684 createSMESHAction( 4063, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3685 createSMESHAction( 4064, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3686 createSMESHAction( 4065, "MERGE", "ICON_SMESH_MERGE_NODES" );
3687 createSMESHAction( 4066, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3688 createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3689 createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" );
3690 createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3691 createSMESHAction( 4070, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3692 createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" );
3693 createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" );
3694 createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3695 createSMESHAction( 410, "UNION", "ICON_UNIONTRI" );
3696 createSMESHAction( 411, "CUT", "ICON_CUTQUAD" );
3697 createSMESHAction( 412, "SMOOTH", "ICON_DLG_SMOOTHING" );
3698 createSMESHAction( 413, "EXTRUSION", "ICON_EXTRUSION" );
3699 createSMESHAction( 414, "REVOLUTION", "ICON_REVOLUTION" );
3700 createSMESHAction( 415, "MAP", "ICON_MAP" );
3701 createSMESHAction( 416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3702 createSMESHAction( 417, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3703 createSMESHAction( 418, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3704 createSMESHAction( 419, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3705 createSMESHAction( 420, "REORIENT_2D", "ICON_REORIENT_2D" );
3706 createSMESHAction( 200, "RESET" );
3707 createSMESHAction( 201, "SCALAR_BAR_PROP" );
3708 createSMESHAction( 2021, "SAVE_DISTRIBUTION" );
3709 createSMESHAction( 2022, "SHOW_DISTRIBUTION","",0, true );
3710 #ifndef DISABLE_PLOT2DVIEWER
3711 createSMESHAction( 2023, "PLOT_DISTRIBUTION" );
3713 createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true );
3714 createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true );
3715 createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true );
3716 createSMESHAction( 214, "UPDATE", "ICON_UPDATE" );
3717 createSMESHAction( 215, "NODES", "ICON_POINTS", 0, true );
3718 createSMESHAction( 222, "BALLS", "ICON_DLG_BALL", 0, true );
3719 createSMESHAction( 216, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3720 createSMESHAction( 217, "EDGES", "ICON_DLG_EDGE", 0, true );
3721 createSMESHAction( 218, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3722 createSMESHAction( 219, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3723 createSMESHAction( 220, "ALL" );
3724 createSMESHAction( 221, "FACE_ORIENTATION", "", 0, true );
3726 createSMESHAction( 231, "LINE_REPRESENTATION", "", 0, true );
3727 createSMESHAction( 232, "ARC_REPRESENTATION", "", 0, true );
3729 createSMESHAction( 1100, "EDIT_HYPO" );
3730 createSMESHAction( 1102, "UNASSIGN" );
3731 createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3732 createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3733 createSMESHAction( 1131, "DISPMODE" );
3734 createSMESHAction( 1132, "COLORS" );
3735 createSMESHAction( 1133, "TRANSP" );
3736 createSMESHAction( 1134, "CLIP" );
3737 createSMESHAction( 1135, "DISP_ENT" );
3738 createSMESHAction( 1136, "AUTO_COLOR" );
3739 createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3740 createSMESHAction( 2000, "CTRL" );
3742 createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3743 createSMESHAction( 502, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3745 createSMESHAction( 300, "HIDE" );
3746 createSMESHAction( 301, "SHOW" );
3747 createSMESHAction( 302, "DISPLAY_ONLY" );
3749 // ----- create menu --------------
3750 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3751 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3752 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3753 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3754 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3755 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3756 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3757 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3759 createMenu( separator(), fileId );
3761 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3762 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3763 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3764 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3765 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3766 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3767 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3768 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3769 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3770 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3772 //createMenu( 111, importId, -1 );
3773 createMenu( 112, importId, -1 );
3774 createMenu( 113, importId, -1 );
3775 createMenu( 115, importId, -1 );
3777 createMenu( 116, importId, -1 );
3779 createMenu( 117, importId, -1 );
3780 createMenu( 118, importId, -1 );
3781 createMenu( 121, exportId, -1 );
3782 createMenu( 122, exportId, -1 );
3783 createMenu( 123, exportId, -1 );
3784 createMenu( 140, exportId, -1 ); // export to STL
3786 createMenu( 142, exportId, -1 ); // export to CGNS
3788 createMenu( 144, exportId, -1 ); // export to SAUV
3789 createMenu( 146, exportId, -1 ); // export to GMF
3790 createMenu( separator(), fileId, 10 );
3792 createMenu( 33, editId, -1 );
3794 createMenu( 5105, toolsId, -1 );
3796 createMenu( 702, meshId, -1 ); // "Mesh" menu
3797 createMenu( 703, meshId, -1 );
3798 createMenu( 704, meshId, -1 );
3799 createMenu( 710, meshId, -1 );
3800 createMenu( 705, meshId, -1 );
3801 createMenu( separator(), meshId, -1 );
3802 createMenu( 701, meshId, -1 );
3803 createMenu( 711, meshId, -1 );
3804 createMenu( 712, meshId, -1 );
3805 createMenu( 713, meshId, -1 );
3806 createMenu( separator(), meshId, -1 );
3807 createMenu( 801, meshId, -1 );
3808 createMenu( 806, meshId, -1 );
3809 createMenu( 802, meshId, -1 );
3810 createMenu( 803, meshId, -1 );
3811 createMenu( 815, meshId, -1 );
3812 createMenu( separator(), meshId, -1 );
3813 createMenu( 810, meshId, -1 );
3814 createMenu( 811, meshId, -1 );
3815 createMenu( 812, meshId, -1 );
3816 createMenu( separator(), meshId, -1 );
3817 createMenu( 814, meshId, -1 );
3818 createMenu( separator(), meshId, -1 );
3819 createMenu( 900, meshId, -1 );
3820 //createMenu( 902, meshId, -1 );
3821 //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3822 createMenu( 904, meshId, -1 );
3823 createMenu( separator(), meshId, -1 );
3825 createMenu( 6005, nodeId, -1 );
3826 createMenu( 6028, nodeId, -1 );
3827 createMenu( 6002, edgeId, -1 );
3828 createMenu( 6003, edgeId, -1 );
3829 createMenu( 6001, edgeId, -1 );
3830 createMenu( 6004, edgeId, -1 );
3831 createMenu( 6029, edgeId, -1 );
3832 createMenu( 6021, faceId, -1 );
3833 createMenu( 6025, faceId, -1 );
3834 createMenu( 6027, faceId, -1 );
3835 createMenu( 6018, faceId, -1 );
3836 createMenu( 6019, faceId, -1 );
3837 createMenu( 6011, faceId, -1 );
3838 createMenu( 6012, faceId, -1 );
3839 createMenu( 6013, faceId, -1 );
3840 createMenu( 6014, faceId, -1 );
3841 createMenu( 6015, faceId, -1 );
3842 createMenu( 6016, faceId, -1 );
3843 createMenu( 6022, faceId, -1 );
3844 createMenu( 6030, faceId, -1 );
3845 createMenu( 6017, volumeId, -1 );
3846 createMenu( 6009, volumeId, -1 );
3847 createMenu( 6023, volumeId, -1 );
3848 createMenu( 6024, volumeId, -1 );
3849 createMenu( 6026, volumeId, -1 );
3850 createMenu( 6031, volumeId, -1 );
3852 createMenu( 4000, addId, -1 );
3853 createMenu( 4009, addId, -1 );
3854 createMenu( 4070, addId, -1 );
3855 createMenu( 4008, addId, -1 );
3856 createMenu( 4010, addId, -1 );
3857 createMenu( 4021, addId, -1 );
3858 createMenu( 4022, addId, -1 );
3859 createMenu( 4023, addId, -1 );
3860 createMenu( 4031, addId, -1 );
3861 createMenu( 4032, addId, -1 );
3862 createMenu( 4133, addId, -1 );
3863 createMenu( 4134, addId, -1 );
3864 createMenu( 4135, addId, -1 );
3865 createMenu( 4033, addId, -1 );
3866 createMenu( separator(), addId, -1 );
3867 createMenu( 4034, addId, -1 );
3868 createMenu( 4035, addId, -1 );
3869 createMenu( 4137, addId, -1 );
3870 createMenu( 4036, addId, -1 );
3871 createMenu( 4136, addId, -1 );
3872 createMenu( 4037, addId, -1 );
3873 createMenu( 4038, addId, -1 );
3874 createMenu( 4039, addId, -1 );
3875 createMenu( 4040, addId, -1 );
3876 createMenu( 4140, addId, -1 );
3878 createMenu( 4041, removeId, -1 );
3879 createMenu( 4042, removeId, -1 );
3880 createMenu( 4044, removeId, -1 );
3881 createMenu( separator(), removeId, -1 );
3882 createMenu( 813, removeId, -1 );
3883 createMenu( separator(), removeId, -1 );
3884 createMenu( 4043, removeId, -1 );
3886 createMenu( 4051, renumId, -1 );
3887 createMenu( 4052, renumId, -1 );
3889 createMenu( 4061, transfId, -1 );
3890 createMenu( 4062, transfId, -1 );
3891 createMenu( 4063, transfId, -1 );
3892 createMenu( 4068, transfId, -1 );
3893 createMenu( 4064, transfId, -1 );
3894 createMenu( 4065, transfId, -1 );
3895 createMenu( 4066, transfId, -1 );
3896 createMenu( 4069, transfId, -1 );
3898 createMenu( 4067,modifyId, -1 );
3899 createMenu( 407, modifyId, -1 );
3900 createMenu( 408, modifyId, -1 );
3901 createMenu( 409, modifyId, -1 );
3902 createMenu( 420, modifyId, -1 );
3903 createMenu( 410, modifyId, -1 );
3904 createMenu( 411, modifyId, -1 );
3905 createMenu( 419, modifyId, -1 );
3906 createMenu( 412, modifyId, -1 );
3907 createMenu( 413, modifyId, -1 );
3908 createMenu( 416, modifyId, -1 );
3909 createMenu( 414, modifyId, -1 );
3910 createMenu( 415, modifyId, -1 );
3911 createMenu( 417, modifyId, -1 );
3912 createMenu( 418, modifyId, -1 );
3914 createMenu( 501, measureId, -1 );
3915 createMenu( 502, measureId, -1 );
3916 createMenu( 214, viewId, -1 );
3918 // ----- create toolbars --------------
3919 int meshTb = createTool( tr( "TB_MESH" ) ),
3920 ctrlTb = createTool( tr( "TB_CTRL" ) ),
3921 addRemTb = createTool( tr( "TB_ADD_REMOVE" ) ),
3922 modifyTb = createTool( tr( "TB_MODIFY" ) ),
3923 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
3925 createTool( 702, meshTb );
3926 createTool( 703, meshTb );
3927 createTool( 704, meshTb );
3928 createTool( 710, meshTb );
3929 createTool( 705, meshTb );
3930 createTool( separator(), meshTb );
3931 createTool( 701, meshTb );
3932 createTool( 711, meshTb );
3933 createTool( 712, meshTb );
3934 createTool( 713, meshTb );
3935 createTool( separator(), meshTb );
3936 createTool( 801, meshTb );
3937 createTool( 806, meshTb );
3938 createTool( 802, meshTb );
3939 createTool( 803, meshTb );
3940 //createTool( 815, meshTb );
3941 createTool( separator(), meshTb );
3942 createTool( 900, meshTb );
3943 //createTool( 902, meshTb );
3944 //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3945 createTool( 904, meshTb );
3946 createTool( separator(), meshTb );
3948 createTool( 6005, ctrlTb );
3949 createTool( 6028, ctrlTb );
3950 createTool( separator(), ctrlTb );
3951 createTool( 6002, ctrlTb );
3952 createTool( 6003, ctrlTb );
3953 createTool( 6001, ctrlTb );
3954 createTool( 6004, ctrlTb );
3955 createTool( 6029, ctrlTb );
3956 createTool( separator(), ctrlTb );
3957 createTool( 6021, ctrlTb );
3958 createTool( 6025, ctrlTb );
3959 createTool( 6027, ctrlTb );
3960 createTool( 6018, ctrlTb );
3961 createTool( 6019, ctrlTb );
3962 createTool( 6011, ctrlTb );
3963 createTool( 6012, ctrlTb );
3964 createTool( 6013, ctrlTb );
3965 createTool( 6014, ctrlTb );
3966 createTool( 6015, ctrlTb );
3967 createTool( 6016, ctrlTb );
3968 createTool( 6022, ctrlTb );
3969 createTool( 6030, ctrlTb );
3970 createTool( separator(), ctrlTb );
3971 createTool( 6017, ctrlTb );
3972 createTool( 6009, ctrlTb );
3973 createTool( 6023, ctrlTb );
3974 createTool( 6024, ctrlTb );
3975 createTool( 6026, ctrlTb );
3976 createTool( 6031, ctrlTb );
3977 createTool( separator(), ctrlTb );
3979 createTool( 4000, addRemTb );
3980 createTool( 4009, addRemTb );
3981 createTool( 4070, addRemTb );
3982 createTool( 4008, addRemTb );
3983 createTool( 4010, addRemTb );
3984 createTool( 4021, addRemTb );
3985 createTool( 4022, addRemTb );
3986 createTool( 4023, addRemTb );
3987 createTool( 4031, addRemTb );
3988 createTool( 4032, addRemTb );
3989 createTool( 4133, addRemTb );
3990 createTool( 4134, addRemTb );
3991 createTool( 4135, addRemTb );
3992 createTool( 4033, addRemTb );
3993 createTool( separator(), addRemTb );
3994 createTool( 4034, addRemTb );
3995 createTool( 4035, addRemTb );
3996 createTool( 4137, addRemTb );
3997 createTool( 4036, addRemTb );
3998 createTool( 4136, addRemTb );
3999 createTool( 4037, addRemTb );
4000 createTool( 4038, addRemTb );
4001 createTool( 4039, addRemTb );
4002 createTool( 4040, addRemTb );
4003 createTool( 4140, addRemTb );
4004 createTool( separator(), addRemTb );
4005 createTool( 4041, addRemTb );
4006 createTool( 4042, addRemTb );
4007 createTool( 4044, addRemTb );
4008 createTool( 4043, addRemTb );
4009 createTool( separator(), addRemTb );
4010 createTool( 4051, addRemTb );
4011 createTool( 4052, addRemTb );
4012 createTool( separator(), addRemTb );
4013 createTool( 4061, addRemTb );
4014 createTool( 4062, addRemTb );
4015 createTool( 4063, addRemTb );
4016 createTool( 4068, addRemTb );
4017 createTool( 4064, addRemTb );
4018 createTool( 4065, addRemTb );
4019 createTool( 4066, addRemTb );
4020 createTool( 4069, addRemTb );
4021 createTool( separator(), addRemTb );
4023 createTool( 4067,modifyTb );
4024 createTool( 407, modifyTb );
4025 createTool( 408, modifyTb );
4026 createTool( 409, modifyTb );
4027 createTool( 420, modifyTb );
4028 createTool( 410, modifyTb );
4029 createTool( 411, modifyTb );
4030 createTool( 419, modifyTb );
4031 createTool( 412, modifyTb );
4032 createTool( 413, modifyTb );
4033 createTool( 416, modifyTb );
4034 createTool( 414, modifyTb );
4035 createTool( 415, modifyTb );
4036 createTool( 417, modifyTb );
4037 createTool( 418, modifyTb );
4039 createTool( 214, dispModeTb );
4041 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4042 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4045 QString OB = "'ObjectBrowser'",
4046 View = "'" + SVTK_Viewer::Type() + "'",
4048 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4049 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4050 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4051 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4052 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4053 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4054 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4055 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4056 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4057 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4058 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4060 mesh_part = mesh + " " + subMesh + " " + group,
4061 mesh_group = mesh + " " + group,
4062 hyp_alg = hypo + " " + algo;
4064 // popup for object browser
4066 isInvisible("not( isVisible )"),
4067 isEmpty("numberOfNodes = 0"),
4068 isNotEmpty("numberOfNodes <> 0"),
4070 // has nodes, edges, etc in VISIBLE! actor
4071 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4072 hasElems("(count( elemTypes ) > 0)"),
4073 hasDifferentElems("(count( elemTypes ) > 1)"),
4074 hasBalls("({'BallElem'} in elemTypes)"),
4075 hasElems0d("({'Elem0d'} in elemTypes)"),
4076 hasEdges("({'Edge'} in elemTypes)"),
4077 hasFaces("({'Face'} in elemTypes)"),
4078 hasVolumes("({'Volume'} in elemTypes)");
4080 createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
4081 createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
4082 createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
4083 createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
4084 createPopupItem( 803, OB, group ); // EDIT_GROUP
4085 createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
4087 popupMgr()->insert( separator(), -1, 0 );
4088 createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
4089 createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
4090 createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
4091 createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
4092 createPopupItem( 214, OB, mesh_part ); // UPDATE
4093 createPopupItem( 900, OB, mesh_part ); // ADV_INFO
4094 createPopupItem( 904, OB, mesh_group ); // FIND_ELEM
4095 popupMgr()->insert( separator(), -1, 0 );
4096 createPopupItem( 801, OB, mesh ); // CREATE_GROUP
4097 createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
4098 createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
4099 popupMgr()->insert( separator(), -1, 0 );
4100 createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
4101 createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4102 popupMgr()->insert( separator(), -1, 0 );
4103 createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
4104 popupMgr()->insert( separator(), -1, 0 );
4105 createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
4106 createPopupItem( 418, OB, mesh + " " + group, // create 2D mesh from 3D
4108 popupMgr()->insert( separator(), -1, 0 );
4110 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4111 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4112 QString only_one_2D = only_one_non_empty + " && dim>1";
4114 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4115 createPopupItem( 125, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_MED
4116 createPopupItem( 126, OB, mesh_group, only_one_non_empty, anId ); // EXPORT_UNV
4117 createPopupItem( 141, OB, mesh_group, only_one_2D, anId ); // EXPORT_STL
4119 createPopupItem( 143, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_CGNS
4121 createPopupItem( 145, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_SAUV
4122 createPopupItem( 147, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_GMF
4123 createPopupItem( 124, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_DAT
4124 createPopupItem( 33, OB, mesh_part + " " + hyp_alg ); // DELETE
4125 createPopupItem( 813, OB, group ); // DEL_GROUP with contents
4126 popupMgr()->insert( separator(), -1, 0 );
4129 createPopupItem( 803, View, group ); // EDIT_GROUP
4130 createPopupItem( 804, View, elems ); // ADD
4131 createPopupItem( 805, View, elems ); // REMOVE
4133 popupMgr()->insert( separator(), -1, 0 );
4134 createPopupItem( 214, View, mesh_part ); // UPDATE
4135 createPopupItem( 900, View, mesh_part ); // ADV_INFO
4136 createPopupItem( 904, View, mesh ); // FIND_ELEM
4137 popupMgr()->insert( separator(), -1, 0 );
4139 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
4140 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
4141 popupMgr()->insert( separator(), -1, 0 );
4143 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4144 QString aType = QString( "%1type in {%2}" ).arg( lc );
4145 aType = aType.arg( mesh_part );
4146 QString aMeshInVTK = aClient + "&&" + aType;
4148 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4149 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4150 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4152 //-------------------------------------------------
4154 //-------------------------------------------------
4155 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4157 popupMgr()->insert( action( 9010 ), anId, -1 );
4158 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4159 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4161 popupMgr()->insert( action( 9011 ), anId, -1 );
4162 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4163 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4165 popupMgr()->insert( separator(), -1, -1 );
4167 //-------------------------------------------------
4169 //-------------------------------------------------
4170 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4172 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4173 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4174 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4176 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4177 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4178 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4180 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4181 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4182 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4184 popupMgr()->insert( separator(), anId, -1 );
4186 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4187 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4188 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4190 //-------------------------------------------------
4192 //-------------------------------------------------
4193 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4195 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4197 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4198 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4199 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4201 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4202 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4203 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4205 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4206 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4207 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4209 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4210 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4211 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4213 popupMgr()->insert( action( 222 ), anId, -1 ); // BALLS
4214 popupMgr()->setRule( action( 222 ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4215 popupMgr()->setRule( action( 222 ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4217 popupMgr()->insert( separator(), anId, -1 );
4219 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4220 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4223 //-------------------------------------------------
4224 // Representation of the 2D Quadratic elements
4225 //-------------------------------------------------
4226 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4227 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4228 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4229 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4231 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4232 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4233 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4235 //-------------------------------------------------
4236 // Orientation of faces
4237 //-------------------------------------------------
4238 popupMgr()->insert( action( 221 ), -1, -1 );
4239 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4240 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4242 //-------------------------------------------------
4244 //-------------------------------------------------
4245 popupMgr()->insert( action( 1132 ), -1, -1 );
4246 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4248 //-------------------------------------------------
4250 //-------------------------------------------------
4251 popupMgr()->insert( action( 1133 ), -1, -1 );
4252 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4254 //-------------------------------------------------
4256 //-------------------------------------------------
4258 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4259 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4260 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4261 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4263 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4265 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4266 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4268 popupMgr()->insert( separator(), anId, -1 );
4270 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4272 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4273 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4274 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4276 popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4277 popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4278 popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4280 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4282 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4283 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4284 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4286 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4287 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4288 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4290 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4291 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4292 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4294 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4295 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4296 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4297 popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4298 popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4299 popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4301 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4303 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4304 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4305 QtxPopupMgr::VisibleRule );
4306 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4308 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4309 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4310 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4312 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4313 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4314 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4316 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4317 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4318 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4320 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4321 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4322 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4324 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4325 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4326 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4328 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4329 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4330 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4332 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4333 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4334 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4336 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4337 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4338 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4340 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4341 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4342 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4344 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4345 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4346 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4348 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4349 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4350 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4351 popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4352 popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4353 popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4355 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4357 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4358 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4359 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4361 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4362 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4363 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4365 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4366 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4367 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4369 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4370 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4371 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4373 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4374 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4375 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4377 popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4378 popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4379 popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4381 popupMgr()->insert( separator(), anId, -1 );
4383 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4384 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4386 popupMgr()->insert( separator(), anId, -1 );
4388 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4390 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4391 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4393 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4394 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4395 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4397 #ifndef DISABLE_PLOT2DVIEWER
4398 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4399 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4402 //-------------------------------------------------
4404 //-------------------------------------------------
4405 popupMgr()->insert( separator(), -1, -1 );
4406 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4407 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4408 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4409 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4411 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4412 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4414 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4415 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4417 popupMgr()->insert( separator(), -1, -1 );
4419 //-------------------------------------------------
4421 //-------------------------------------------------
4422 popupMgr()->insert( action( 1134 ), -1, -1 );
4423 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4425 popupMgr()->insert( separator(), -1, -1 );
4427 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4428 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4430 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4431 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4434 //================================================================================
4436 * \brief Return true if SMESH or GEOM objects are selected.
4437 * Is called form LightApp_Module::activateModule() which clear selection if
4438 * not isSelectionCompatible()
4440 //================================================================================
4442 bool SMESHGUI::isSelectionCompatible()
4444 bool isCompatible = true;
4445 SALOME_ListIO selected;
4446 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4447 Sel->selectedObjects( selected );
4449 SALOME_ListIteratorOfListIO It( selected );
4450 for ( ; isCompatible && It.More(); It.Next())
4452 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4453 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4455 return isCompatible;
4459 bool SMESHGUI::reusableOperation( const int id )
4461 // compute, evaluate and precompute are not reusable operations
4462 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4465 bool SMESHGUI::activateModule( SUIT_Study* study )
4467 bool res = SalomeApp_Module::activateModule( study );
4469 setMenuShown( true );
4470 setToolShown( true );
4472 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4473 PyGILState_STATE gstate = PyGILState_Ensure();
4474 PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4475 if(pluginsmanager==NULL)
4479 PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4484 PyGILState_Release(gstate);
4485 // end of GEOM plugins loading
4487 // Reset actions accelerator keys
4488 //action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4489 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4490 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4492 action( 33)->setEnabled(true); // Delete: Key_Delete
4494 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4495 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4496 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4497 if ( _PTR(Study) aStudy = s->studyDS()) {
4498 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4499 updateObjBrowser(); // objects can be removed
4502 // get all view currently opened in the study and connect their signals to
4503 // the corresponding slots of the class.
4504 SUIT_Desktop* aDesk = study->application()->desktop();
4506 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4507 SUIT_ViewWindow* wnd;
4508 foreach ( wnd, wndList )
4515 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4517 setMenuShown( false );
4518 setToolShown( false );
4520 EmitSignalCloseAllDialogs();
4522 // Unset actions accelerator keys
4523 //action(111)->setShortcut(QKeySequence()); // Import DAT
4524 action(112)->setShortcut(QKeySequence()); // Import UNV
4525 action(113)->setShortcut(QKeySequence()); // Import MED
4527 action( 33)->setEnabled(false); // Delete: Key_Delete
4529 return SalomeApp_Module::deactivateModule( study );
4532 void SMESHGUI::studyClosed( SUIT_Study* s )
4534 SMESH::RemoveVisuData( s->id() );
4535 SalomeApp_Module::studyClosed( s );
4538 void SMESHGUI::OnGUIEvent()
4540 const QObject* obj = sender();
4541 if ( !obj || !obj->inherits( "QAction" ) )
4543 int id = actionId((QAction*)obj);
4548 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4550 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4551 if ( CORBA::is_nil( myComponentSMESH ) )
4553 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4555 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4556 return aGUI.myComponentSMESH;
4559 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4560 return myComponentSMESH;
4563 QString SMESHGUI::engineIOR() const
4565 CORBA::ORB_var anORB = getApp()->orb();
4566 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4567 return QString( anIOR.in() );
4570 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4572 SalomeApp_Module::contextMenuPopup( client, menu, title );
4574 selectionMgr()->selectedObjects( lst );
4575 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4576 Handle(SALOME_InteractiveObject) io = lst.First();
4577 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4578 _PTR(Study) study = appStudy->studyDS();
4579 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4581 QString aName = QString( obj->GetName().c_str() );
4582 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4583 aName.remove( (aName.length() - 1), 1 );
4589 LightApp_Selection* SMESHGUI::createSelection() const
4591 return new SMESHGUI_Selection();
4594 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4596 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4597 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4600 void SMESHGUI::viewManagers( QStringList& list ) const
4602 list.append( SVTK_Viewer::Type() );
4605 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4607 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4608 SMESH::UpdateSelectionProp( this );
4610 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4611 for(int i = 0; i < aViews.count() ; i++){
4612 SUIT_ViewWindow *sf = aViews[i];
4618 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4620 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4621 myClippingPlaneInfoMap.erase( theViewManager );
4624 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4626 theActor->AddObserver( SMESH::DeleteActorEvent,
4627 myEventCallbackCommand.GetPointer(),
4631 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4632 unsigned long theEvent,
4633 void* theClientData,
4636 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4637 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4638 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4639 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4640 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4641 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4642 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4643 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4644 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4645 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4646 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4647 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4648 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4649 if( anActor == *anIter3 ) {
4650 anActorList.erase( anIter3 );
4661 void SMESHGUI::createPreferences()
4663 // General tab ------------------------------------------------------------------------
4664 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4666 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4667 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4668 setPreferenceProperty( lim, "min", 0 );
4669 setPreferenceProperty( lim, "max", 100000000 );
4670 setPreferenceProperty( lim, "step", 1000 );
4671 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4673 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4674 setPreferenceProperty( qaGroup, "columns", 2 );
4675 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4676 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4677 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4678 setPreferenceProperty( prec, "min", 0 );
4679 setPreferenceProperty( prec, "max", 16 );
4680 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4681 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4682 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4683 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4684 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4686 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4687 setPreferenceProperty( dispgroup, "columns", 2 );
4688 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4690 modes.append( tr("MEN_WIRE") );
4691 modes.append( tr("MEN_SHADE") );
4692 modes.append( tr("MEN_NODES") );
4693 modes.append( tr("MEN_SHRINK") );
4694 QList<QVariant> indices;
4695 indices.append( 0 );
4696 indices.append( 1 );
4697 indices.append( 2 );
4698 indices.append( 3 );
4699 setPreferenceProperty( dispmode, "strings", modes );
4700 setPreferenceProperty( dispmode, "indexes", indices );
4702 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4703 setPreferenceProperty( arcgroup, "columns", 2 );
4704 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4705 QStringList quadraticModes;
4706 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4707 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4709 indices.append( 0 );
4710 indices.append( 1 );
4711 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4712 setPreferenceProperty( quadraticmode, "indexes", indices );
4714 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4715 "SMESH", "max_angle" );
4716 setPreferenceProperty( maxAngle, "min", 1 );
4717 setPreferenceProperty( maxAngle, "max", 90 );
4721 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4722 setPreferenceProperty( exportgroup, "columns", 2 );
4723 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4724 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4726 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4727 setPreferenceProperty( computeGroup, "columns", 2 );
4728 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4730 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4731 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4732 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4734 indices.append( 0 );
4735 indices.append( 1 );
4736 indices.append( 2 );
4737 setPreferenceProperty( notifyMode, "strings", modes );
4738 setPreferenceProperty( notifyMode, "indexes", indices );
4740 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4741 setPreferenceProperty( infoGroup, "columns", 2 );
4742 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4744 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4745 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4747 indices.append( 0 );
4748 indices.append( 1 );
4749 setPreferenceProperty( elemInfo, "strings", modes );
4750 setPreferenceProperty( elemInfo, "indexes", indices );
4751 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4752 setPreferenceProperty( nodesLim, "min", 0 );
4753 setPreferenceProperty( nodesLim, "max", 10000000 );
4754 setPreferenceProperty( nodesLim, "step", 10000 );
4755 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4756 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
4757 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
4758 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
4759 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
4761 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4762 setPreferenceProperty( segGroup, "columns", 2 );
4763 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4764 "SMESH", "segmentation" );
4765 setPreferenceProperty( segLen, "min", 1 );
4766 setPreferenceProperty( segLen, "max", 10000000 );
4767 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4768 "SMESH", "nb_segments_per_edge" );
4769 setPreferenceProperty( nbSeg, "min", 1 );
4770 setPreferenceProperty( nbSeg, "max", 10000000 );
4772 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4773 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4774 "SMESH", "forget_mesh_on_hyp_modif" );
4777 // Quantities with individual precision settings
4778 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4779 setPreferenceProperty( precGroup, "columns", 2 );
4781 const int nbQuantities = 6;
4782 int precs[nbQuantities], ii = 0;
4783 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4784 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4785 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4786 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4787 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4788 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4789 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4790 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4791 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4792 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4793 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4794 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4796 // Set property for precision value for spinboxes
4797 for ( ii = 0; ii < nbQuantities; ii++ ){
4798 setPreferenceProperty( precs[ii], "min", -14 );
4799 setPreferenceProperty( precs[ii], "max", 14 );
4800 setPreferenceProperty( precs[ii], "precision", 2 );
4803 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4804 setPreferenceProperty( previewGroup, "columns", 2 );
4805 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4806 setPreferenceProperty( chunkSize, "min", 1 );
4807 setPreferenceProperty( chunkSize, "max", 1000 );
4808 setPreferenceProperty( chunkSize, "step", 50 );
4810 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4811 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4813 // Mesh tab ------------------------------------------------------------------------
4814 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4815 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4816 setPreferenceProperty( nodeGroup, "columns", 3 );
4818 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4820 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4822 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4823 QList<QVariant> aMarkerTypeIndicesList;
4824 QList<QVariant> aMarkerTypeIconsList;
4825 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4826 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4827 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4828 aMarkerTypeIndicesList << i;
4829 aMarkerTypeIconsList << pixmap;
4831 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4832 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4834 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4836 QList<QVariant> aMarkerScaleIndicesList;
4837 QStringList aMarkerScaleValuesList;
4838 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4839 aMarkerScaleIndicesList << i;
4840 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4842 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4843 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4845 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4846 //setPreferenceProperty( elemGroup, "columns", 2 );
4848 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4849 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4850 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
4851 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
4852 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4853 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
4854 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4855 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4858 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4859 setPreferenceProperty( grpGroup, "columns", 2 );
4861 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4862 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
4864 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4865 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4866 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
4867 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
4868 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4869 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4870 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
4871 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
4872 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4873 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4875 setPreferenceProperty( size0d, "min", 1 );
4876 setPreferenceProperty( size0d, "max", 10 );
4878 setPreferenceProperty( ballSize, "min", 1 );
4879 setPreferenceProperty( ballSize, "max", 10 );
4881 setPreferenceProperty( elemW, "min", 1 );
4882 setPreferenceProperty( elemW, "max", 5 );
4884 setPreferenceProperty( outW, "min", 1 );
4885 setPreferenceProperty( outW, "max", 5 );
4887 setPreferenceProperty( shrink, "min", 0 );
4888 setPreferenceProperty( shrink, "max", 100 );
4890 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
4891 setPreferenceProperty( numGroup, "columns", 2 );
4893 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
4894 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
4896 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
4897 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
4899 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4900 setPreferenceProperty( orientGroup, "columns", 1 );
4902 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4903 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4905 setPreferenceProperty( orientScale, "min", 0.05 );
4906 setPreferenceProperty( orientScale, "max", 0.5 );
4907 setPreferenceProperty( orientScale, "step", 0.05 );
4909 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4911 // Selection tab ------------------------------------------------------------------------
4912 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4914 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4915 setPreferenceProperty( selGroup, "columns", 2 );
4917 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4918 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4920 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4921 setPreferenceProperty( preGroup, "columns", 2 );
4923 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4925 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4926 setPreferenceProperty( precSelGroup, "columns", 2 );
4928 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4929 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4930 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4932 // Scalar Bar tab ------------------------------------------------------------------------
4933 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4934 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4935 setPreferenceProperty( fontGr, "columns", 2 );
4937 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4938 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4940 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4941 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4943 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4944 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4946 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4947 setPreferenceProperty( numcol, "min", 2 );
4948 setPreferenceProperty( numcol, "max", 256 );
4950 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4951 setPreferenceProperty( numlab, "min", 2 );
4952 setPreferenceProperty( numlab, "max", 65 );
4954 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4955 setPreferenceProperty( orientGr, "columns", 2 );
4956 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4957 QStringList orients;
4958 orients.append( tr( "SMESH_VERTICAL" ) );
4959 orients.append( tr( "SMESH_HORIZONTAL" ) );
4960 indices.clear(); indices.append( 0 ); indices.append( 1 );
4961 setPreferenceProperty( orient, "strings", orients );
4962 setPreferenceProperty( orient, "indexes", indices );
4964 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4965 setPreferenceProperty( posVSizeGr, "columns", 2 );
4966 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4967 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4968 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4969 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4970 setPreferenceProperty( xv, "step", 0.1 );
4971 setPreferenceProperty( xv, "min", 0.0 );
4972 setPreferenceProperty( xv, "max", 1.0 );
4973 setPreferenceProperty( yv, "step", 0.1 );
4974 setPreferenceProperty( yv, "min", 0.0 );
4975 setPreferenceProperty( yv, "max", 1.0 );
4976 setPreferenceProperty( wv, "step", 0.1 );
4977 setPreferenceProperty( wv, "min", 0.0 );
4978 setPreferenceProperty( wv, "max", 1.0 );
4979 setPreferenceProperty( hv, "min", 0.0 );
4980 setPreferenceProperty( hv, "max", 1.0 );
4981 setPreferenceProperty( hv, "step", 0.1 );
4983 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
4984 setPreferenceProperty( posHSizeGr, "columns", 2 );
4985 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
4986 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
4987 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
4988 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
4989 setPreferenceProperty( xv, "min", 0.0 );
4990 setPreferenceProperty( xv, "max", 1.0 );
4991 setPreferenceProperty( xv, "step", 0.1 );
4992 setPreferenceProperty( xh, "min", 0.0 );
4993 setPreferenceProperty( xh, "max", 1.0 );
4994 setPreferenceProperty( xh, "step", 0.1 );
4995 setPreferenceProperty( yh, "min", 0.0 );
4996 setPreferenceProperty( yh, "max", 1.0 );
4997 setPreferenceProperty( yh, "step", 0.1 );
4998 setPreferenceProperty( wh, "min", 0.0 );
4999 setPreferenceProperty( wh, "max", 1.0 );
5000 setPreferenceProperty( wh, "step", 0.1 );
5001 setPreferenceProperty( hh, "min", 0.0 );
5002 setPreferenceProperty( hh, "max", 1.0 );
5003 setPreferenceProperty( hh, "step", 0.1 );
5005 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5006 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5007 setPreferenceProperty( distributionGr, "columns", 3 );
5009 types.append( tr( "SMESH_MONOCOLOR" ) );
5010 types.append( tr( "SMESH_MULTICOLOR" ) );
5011 indices.clear(); indices.append( 0 ); indices.append( 1 );
5012 setPreferenceProperty( coloringType, "strings", types );
5013 setPreferenceProperty( coloringType, "indexes", indices );
5014 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5018 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5020 if( sect=="SMESH" ) {
5021 float sbX1,sbY1,sbW,sbH;
5022 float aTol = 1.00000009999999;
5023 std::string aWarning;
5024 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5025 if( name=="selection_object_color" || name=="selection_element_color" ||
5026 name=="highlight_color" ||
5027 name=="selection_precision_node" || name=="selection_precision_element" ||
5028 name=="selection_precision_object")
5029 SMESH::UpdateSelectionProp( this );
5030 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5031 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5032 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5033 if(sbX1+sbW > aTol){
5034 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5037 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5038 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5041 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5042 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5043 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5044 if(sbY1+sbH > aTol){
5045 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5046 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5047 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5050 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5051 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5052 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5053 if(sbX1+sbW > aTol){
5054 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5057 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5058 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5061 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5062 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5063 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5064 if(sbY1+sbH > aTol){
5065 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5068 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5069 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5072 else if ( name == "segmentation" ) {
5073 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5074 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5076 else if ( name == "nb_segments_per_edge" ) {
5077 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5078 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5080 else if ( name == "historical_python_dump" ||
5081 name == "forget_mesh_on_hyp_modif") {
5082 QString val = aResourceMgr->stringValue( "SMESH", name );
5083 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5085 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5086 SMESH::UpdateFontProp( this );
5088 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5089 SMESH::UpdateFontProp( this );
5092 if(aWarning.size() != 0){
5093 aWarning += "The default values are applied instead.";
5094 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5095 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5096 QObject::tr(aWarning.c_str()));
5101 //================================================================================
5103 * \brief Update something in accordance with update flags
5104 * \param theFlags - update flags
5106 * Update viewer or/and object browser etc. in accordance with update flags ( see
5107 * LightApp_UpdateFlags enumeration ).
5109 //================================================================================
5110 void SMESHGUI::update( const int flags )
5112 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5113 SMESH::UpdateView();
5115 SalomeApp_Module::update( flags );
5118 //================================================================================
5120 * \brief Set default selection mode
5122 * SLOT called when operation commited. Sets default selection mode
5124 //================================================================================
5125 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5127 SVTK_ViewWindow* vtkWnd =
5128 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5130 vtkWnd->SetSelectionMode( ActorSelection );
5133 //================================================================================
5135 * \brief Set default selection mode
5137 * SLOT called when operation aborted. Sets default selection mode
5139 //================================================================================
5140 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5142 SVTK_ViewWindow* vtkWnd =
5143 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5145 vtkWnd->SetSelectionMode( ActorSelection );
5148 //================================================================================
5150 * \brief Creates operation with given identifier
5151 * \param id - identifier of operation to be started
5152 * \return Pointer on created operation or NULL if operation is not created
5154 * Virtual method redefined from the base class creates operation with given id.
5155 * It is called called automatically from startOperation method of base class.
5157 //================================================================================
5158 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5160 LightApp_Operation* op = 0;
5161 // to do : create operation here
5164 case 417: //convert to quadratic
5165 op = new SMESHGUI_ConvToQuadOp();
5167 case 418: // create 2D mesh as boundary on 3D
5168 op = new SMESHGUI_Make2DFrom3DOp();
5170 case 420: // Reorient faces
5171 op = new SMESHGUI_ReorientFacesOp();
5173 case 701: // Compute mesh
5174 op = new SMESHGUI_ComputeOp();
5176 case 702: // Create mesh
5177 op = new SMESHGUI_MeshOp( true, true );
5179 case 703: // Create sub-mesh
5180 op = new SMESHGUI_MeshOp( true, false );
5182 case 704: // Edit mesh/sub-mesh
5183 op = new SMESHGUI_MeshOp( false );
5185 case 711: // Precompute mesh
5186 op = new SMESHGUI_PrecomputeOp();
5188 case 712: // Evaluate mesh
5189 op = new SMESHGUI_EvaluateOp();
5191 case 713: // Evaluate mesh
5192 op = new SMESHGUI_MeshOrderOp();
5194 case 806: // Create group on geom
5195 op = new SMESHGUI_GroupOnShapeOp();
5197 case 904: // Find element
5198 op = new SMESHGUI_FindElemByPointOp();
5200 case 4067: // Make mesh pass through point
5201 op = new SMESHGUI_MakeNodeAtPointOp();
5203 case 4070: // Create 0D elements on all nodes
5204 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5211 op = SalomeApp_Module::createOperation( id );
5215 //================================================================================
5217 * \brief Stops current operations and starts a given one
5218 * \param id - The id of the operation to start
5220 //================================================================================
5222 void SMESHGUI::switchToOperation(int id)
5224 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5225 activeStudy()->abortAllOperations();
5226 startOperation( id );
5229 LightApp_Displayer* SMESHGUI::displayer()
5232 myDisplayer = new SMESHGUI_Displayer( getApp() );
5236 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5239 int aTolerance = 64;
5240 int anIterations = 0;
5246 if( anIterations % aPeriod == 0 )
5249 if( aTolerance < 1 )
5253 aHue = (int)( 360.0 * rand() / RAND_MAX );
5256 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5257 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5258 for( ; it != itEnd; ++it )
5260 SALOMEDS::Color anAutoColor = *it;
5261 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5264 aQColor.getHsv( &h, &s, &v );
5265 if( abs( h - aHue ) < aTolerance )
5277 aColor.setHsv( aHue, 255, 255 );
5279 SALOMEDS::Color aSColor;
5280 aSColor.R = aColor.redF();
5281 aSColor.G = aColor.greenF();
5282 aSColor.B = aColor.blueF();
5287 const char* gSeparator = "_"; // character used to separate parameter names
5288 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5289 const char* gPathSep = "|"; // character used to separate paths
5292 * \brief Store visual parameters
5294 * This method is called just before the study document is saved.
5295 * Store visual parameters in AttributeParameter attribue(s)
5297 void SMESHGUI::storeVisualParameters (int savePoint)
5300 Kernel_Utils::Localizer loc;
5302 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5303 if (!appStudy || !appStudy->studyDS())
5305 _PTR(Study) studyDS = appStudy->studyDS();
5307 // componentName is used for encoding of entries when storing them in IParameters
5308 std::string componentName = myComponentSMESH->ComponentDataType();
5309 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5310 //if (!aSComponent) return;
5313 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5314 componentName.c_str(),
5316 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5318 // store map of custom markers
5319 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5320 if( !aMarkerMap.empty() )
5322 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5323 for( ; anIter != aMarkerMap.end(); anIter++ )
5325 int anId = anIter->first;
5326 VTK::MarkerData aMarkerData = anIter->second;
5327 std::string aMarkerFileName = aMarkerData.first;
5328 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5329 if( aMarkerTexture.size() < 3 )
5330 continue; // should contain at least width, height and the first value
5332 QString aPropertyName( "texture" );
5333 aPropertyName += gSeparator;
5334 aPropertyName += QString::number( anId );
5336 QString aPropertyValue = aMarkerFileName.c_str();
5337 aPropertyValue += gPathSep;
5339 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5340 ushort aWidth = *aTextureIter++;
5341 ushort aHeight = *aTextureIter++;
5342 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5343 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5344 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5345 aPropertyValue += QString::number( *aTextureIter );
5347 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5351 // viewers counters are used for storing view_numbers in IParameters
5354 // main cycle to store parameters of displayed objects
5355 QList<SUIT_ViewManager*> lst;
5356 QList<SUIT_ViewManager*>::Iterator it;
5357 getApp()->viewManagers(lst);
5358 for (it = lst.begin(); it != lst.end(); it++)
5360 SUIT_ViewManager* vman = *it;
5361 QString vType = vman->getType();
5363 // saving VTK actors properties
5364 if (vType == SVTK_Viewer::Type())
5366 // store the clipping planes attached to the view manager
5367 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5368 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5369 if( anIter != myClippingPlaneInfoMap.end() )
5370 aClippingPlaneInfoList = anIter->second;
5372 if( !aClippingPlaneInfoList.empty() ) {
5373 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5374 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5376 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5377 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5379 QString aPropertyName( "ClippingPlane" );
5380 aPropertyName += gSeparator;
5381 aPropertyName += QString::number( vtkViewers );
5382 aPropertyName += gSeparator;
5383 aPropertyName += QString::number( anId );
5385 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5386 aPropertyValue += gDigitsSep;
5387 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5388 aPropertyValue += gDigitsSep;
5389 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5390 aPropertyValue += gDigitsSep;
5391 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5393 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5397 QVector<SUIT_ViewWindow*> views = vman->getViews();
5398 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5400 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5402 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5403 vtkActorCollection* allActors = aCopy.GetActors();
5404 allActors->InitTraversal();
5405 while (vtkActor* actor = allActors->GetNextActor())
5407 if (actor->GetVisibility()) // store only visible actors
5409 SMESH_Actor* aSmeshActor = 0;
5410 if (actor->IsA("SMESH_Actor"))
5411 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5412 if (aSmeshActor && aSmeshActor->hasIO())
5414 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5417 // entry is "encoded" = it does NOT contain component adress,
5418 // since it is a subject to change on next component loading
5419 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5421 std::string param, vtkParam = vType.toLatin1().data();
5422 vtkParam += gSeparator;
5423 vtkParam += QString::number(vtkViewers).toLatin1().data();
5424 vtkParam += gSeparator;
5427 param = vtkParam + "Visibility";
5428 ip->setParameter(entry, param, "On");
5431 param = vtkParam + "Representation";
5432 ip->setParameter(entry, param, QString::number
5433 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5436 param = vtkParam + "IsShrunk";
5437 ip->setParameter(entry, param, QString::number
5438 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5440 // Displayed entities
5441 unsigned int aMode = aSmeshActor->GetEntityMode();
5442 bool isE = aMode & SMESH_Actor::eEdges;
5443 bool isF = aMode & SMESH_Actor::eFaces;
5444 bool isV = aMode & SMESH_Actor::eVolumes;
5445 bool is0d = aMode & SMESH_Actor::e0DElements;
5446 bool isB = aMode & SMESH_Actor::eBallElem;
5448 QString modeStr ("e");
5449 modeStr += gDigitsSep; modeStr += QString::number(isE);
5450 modeStr += gDigitsSep; modeStr += "f";
5451 modeStr += gDigitsSep; modeStr += QString::number(isF);
5452 modeStr += gDigitsSep; modeStr += "v";
5453 modeStr += gDigitsSep; modeStr += QString::number(isV);
5454 modeStr += gDigitsSep; modeStr += "0d";
5455 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5456 modeStr += gDigitsSep; modeStr += "b";
5457 modeStr += gDigitsSep; modeStr += QString::number(isB);
5459 param = vtkParam + "Entities";
5460 ip->setParameter(entry, param, modeStr.toLatin1().data());
5466 aSmeshActor->GetSufaceColor(r, g, b, delta);
5467 QStringList colorStr;
5468 colorStr << "surface";
5469 colorStr << QString::number(r);
5470 colorStr << QString::number(g);
5471 colorStr << QString::number(b);
5473 colorStr << "backsurface";
5474 colorStr << QString::number(delta);
5476 aSmeshActor->GetVolumeColor(r, g, b, delta);
5477 colorStr << "volume";
5478 colorStr << QString::number(r);
5479 colorStr << QString::number(g);
5480 colorStr << QString::number(b);
5481 colorStr << QString::number(delta);
5483 aSmeshActor->GetEdgeColor(r, g, b);
5485 colorStr << QString::number(r);
5486 colorStr << QString::number(g);
5487 colorStr << QString::number(b);
5489 aSmeshActor->GetNodeColor(r, g, b);
5491 colorStr << QString::number(r);
5492 colorStr << QString::number(g);
5493 colorStr << QString::number(b);
5495 aSmeshActor->GetOutlineColor(r, g, b);
5496 colorStr << "outline";
5497 colorStr << QString::number(r);
5498 colorStr << QString::number(g);
5499 colorStr << QString::number(b);
5501 aSmeshActor->Get0DColor(r, g, b);
5502 colorStr << "elem0d";
5503 colorStr << QString::number(r);
5504 colorStr << QString::number(g);
5505 colorStr << QString::number(b);
5507 aSmeshActor->GetBallColor(r, g, b);
5509 colorStr << QString::number(r);
5510 colorStr << QString::number(g);
5511 colorStr << QString::number(b);
5513 aSmeshActor->GetFacesOrientationColor(r, g, b);
5514 colorStr << "orientation";
5515 colorStr << QString::number(r);
5516 colorStr << QString::number(g);
5517 colorStr << QString::number(b);
5519 param = vtkParam + "Colors";
5520 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5523 QStringList sizeStr;
5525 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5526 sizeStr << "outline";
5527 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5528 sizeStr << "elem0d";
5529 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5531 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5532 sizeStr << "shrink";
5533 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5534 sizeStr << "orientation";
5535 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5536 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5538 param = vtkParam + "Sizes";
5539 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5544 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5545 if( aMarkerType == VTK::MT_USER ) {
5546 markerStr += "custom";
5547 markerStr += gDigitsSep;
5548 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5552 markerStr += gDigitsSep;
5553 markerStr += QString::number( (int)aMarkerType );
5554 markerStr += gDigitsSep;
5555 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5558 param = vtkParam + "PointMarker";
5559 ip->setParameter(entry, param, markerStr.toLatin1().data());
5562 param = vtkParam + "Opacity";
5563 ip->setParameter(entry, param,
5564 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5567 param = vtkParam + "ClippingPlane";
5569 if( !aClippingPlaneInfoList.empty() ) {
5570 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5571 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5573 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5574 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5575 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5576 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5577 if( aSmeshActor == *anIter2 ) {
5578 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5579 QString::number( anId ).toLatin1().constData() );
5586 ip->setParameter( entry, param, "Off" );
5587 } // if (io->hasEntry())
5588 } // SMESH_Actor && hasIO
5590 } // while.. actors traversal
5594 } // if (SVTK view model)
5595 } // for (viewManagers)
5598 // data structures for clipping planes processing
5601 vtkIdType Orientation;
5605 typedef std::list<TPlaneData> TPlaneDataList;
5606 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5608 typedef std::list<vtkActor*> TActorList;
5611 TActorList ActorList;
5612 SUIT_ViewManager* ViewManager;
5614 typedef std::list<TPlaneInfo> TPlaneInfoList;
5615 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5618 * \brief Restore visual parameters
5620 * This method is called after the study document is opened.
5621 * Restore visual parameters from AttributeParameter attribue(s)
5623 void SMESHGUI::restoreVisualParameters (int savePoint)
5626 Kernel_Utils::Localizer loc;
5628 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5629 if (!appStudy || !appStudy->studyDS())
5631 _PTR(Study) studyDS = appStudy->studyDS();
5633 // componentName is used for encoding of entries when storing them in IParameters
5634 std::string componentName = myComponentSMESH->ComponentDataType();
5635 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5636 //if (!aSComponent) return;
5639 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5640 componentName.c_str(),
5642 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5644 // restore map of custom markers and map of clipping planes
5645 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5646 TPlaneDataMap aPlaneDataMap;
5648 std::vector<std::string> properties = ip->getProperties();
5649 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5651 std::string property = *propIt;
5652 QString aPropertyName( property.c_str() );
5653 QString aPropertyValue( ip->getProperty( property ).c_str() );
5655 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5656 if( aPropertyNameList.isEmpty() )
5659 QString aPropertyType = aPropertyNameList[0];
5660 if( aPropertyType == "texture" )
5662 if( aPropertyNameList.size() != 2 )
5666 int anId = aPropertyNameList[1].toInt( &ok );
5667 if( !ok || anId < 1 )
5670 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5671 if( aPropertyValueList.size() != 2 )
5674 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5675 QString aMarkerTextureString = aPropertyValueList[1];
5676 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5677 if( aMarkerTextureStringList.size() != 3 )
5681 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5686 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5690 VTK::MarkerTexture aMarkerTexture;
5691 aMarkerTexture.push_back( aWidth );
5692 aMarkerTexture.push_back( aHeight );
5694 QString aMarkerTextureData = aMarkerTextureStringList[2];
5695 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5697 QChar aChar = aMarkerTextureData.at( i );
5698 if( aChar.isDigit() )
5699 aMarkerTexture.push_back( aChar.digitValue() );
5702 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5704 else if( aPropertyType == "ClippingPlane" )
5706 if( aPropertyNameList.size() != 3 )
5710 int aViewId = aPropertyNameList[1].toInt( &ok );
5711 if( !ok || aViewId < 0 )
5715 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5716 if( !ok || aClippingPlaneId < 0 )
5719 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5720 if( aPropertyValueList.size() != 4 )
5723 TPlaneData aPlaneData;
5724 aPlaneData.Id = aClippingPlaneId;
5727 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5732 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5737 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5742 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5746 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5747 aPlaneDataList.push_back( aPlaneData );
5751 TPlaneInfoMap aPlaneInfoMap;
5753 std::vector<std::string> entries = ip->getEntries();
5755 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5757 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5758 QString entry (ip->decodeEntry(*entIt).c_str());
5760 // Check that the entry corresponds to a real object in the Study
5761 // as the object may be deleted or modified after the visual state is saved.
5762 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5763 if (!so) continue; //Skip the not existent entry
5765 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5766 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5768 std::vector<std::string>::iterator namesIt = paramNames.begin();
5769 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5771 // actors are stored in a map after displaying of them for
5772 // quicker access in the future: map < viewID to actor >
5773 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5775 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5777 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5778 // '_' is used as separator and should not be used in viewer type or parameter names.
5779 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5780 if (lst.size() != 3)
5783 QString viewerTypStr = lst[0];
5784 QString viewIndexStr = lst[1];
5785 QString paramNameStr = lst[2];
5788 int viewIndex = viewIndexStr.toUInt(&ok);
5789 if (!ok) // bad conversion of view index to integer
5793 if (viewerTypStr == SVTK_Viewer::Type())
5795 SMESH_Actor* aSmeshActor = 0;
5796 if (vtkActors.IsBound(viewIndex))
5797 aSmeshActor = vtkActors.Find(viewIndex);
5799 QList<SUIT_ViewManager*> lst;
5800 getApp()->viewManagers(viewerTypStr, lst);
5802 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5803 SUIT_ViewManager* vman = NULL;
5804 if (viewIndex >= 0 && viewIndex < lst.count())
5805 vman = lst.at(viewIndex);
5807 if (paramNameStr == "Visibility")
5809 if (!aSmeshActor && displayer() && vman)
5811 SUIT_ViewModel* vmodel = vman->getViewModel();
5812 // SVTK view model can be casted to SALOME_View
5813 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5815 // store displayed actor in a temporary map for quicker
5816 // access later when restoring other parameters
5817 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5818 vtkRenderer* Renderer = vtkView->getRenderer();
5819 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5820 vtkActorCollection* theActors = aCopy.GetActors();
5821 theActors->InitTraversal();
5822 bool isFound = false;
5823 vtkActor *ac = theActors->GetNextActor();
5824 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5825 if (ac->IsA("SMESH_Actor")) {
5826 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5827 if (aGeomAc->hasIO()) {
5828 Handle(SALOME_InteractiveObject) io =
5829 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5830 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5832 vtkActors.Bind(viewIndex, aGeomAc);
5838 } // if (paramNameStr == "Visibility")
5841 // the rest properties "work" with SMESH_Actor
5844 QString val ((*valuesIt).c_str());
5847 if (paramNameStr == "Representation") {
5848 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5851 else if (paramNameStr == "IsShrunk") {
5853 if (!aSmeshActor->IsShrunk())
5854 aSmeshActor->SetShrink();
5857 if (aSmeshActor->IsShrunk())
5858 aSmeshActor->UnShrink();
5861 // Displayed entities
5862 else if (paramNameStr == "Entities") {
5863 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5864 int aEntityMode = SMESH_Actor::eAllEntity;
5865 for ( int i = 0; i < mode.count(); i+=2 ) {
5866 if ( i < mode.count()-1 ) {
5867 QString type = mode[i];
5868 bool val = mode[i+1].toInt();
5869 if ( type == "e" && !val )
5870 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
5871 else if ( type == "f" && !val )
5872 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
5873 else if ( type == "v" && !val )
5874 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
5875 else if ( type == "0d" && !val )
5876 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
5877 else if ( type == "b" && !val )
5878 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
5881 aSmeshActor->SetEntityMode( aEntityMode );
5884 else if (paramNameStr == "Colors") {
5885 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5892 QColor outlineColor;
5893 QColor orientationColor;
5899 // below lines are required to get default values for delta coefficients
5900 // of backface color for faces and color of reversed volumes
5901 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
5902 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
5903 for ( int i = 0; i < colors.count(); i++ ) {
5904 QString type = colors[i];
5905 if ( type == "surface" ) {
5906 // face color is set by 3 values r:g:b, where
5907 // - r,g,b - is rgb color components
5908 if ( i+1 >= colors.count() ) break; // format error
5909 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5910 if ( i+2 >= colors.count() ) break; // format error
5911 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5912 if ( i+3 >= colors.count() ) break; // format error
5913 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5914 faceColor.setRgbF( r, g, b );
5917 else if ( type == "backsurface" ) {
5918 // backface color can be defined in several ways
5919 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
5920 // - in latest versions, it is set as delta coefficient
5921 bool rgbOk = false, deltaOk;
5922 if ( i+1 >= colors.count() ) break; // format error
5923 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5924 int delta = colors[i+1].toInt( &deltaOk );
5926 if ( i+1 < colors.count() ) // index is shifted to 1
5927 g = colors[i+1].toDouble( &rgbOk );
5928 if ( rgbOk ) i++; // shift index
5929 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
5930 b = colors[i+1].toDouble( &rgbOk );
5932 // - as currently there's no way to set directly backsurface color as it was before,
5933 // we ignore old dump where r,g,b triple was set
5934 // - also we check that delta parameter is set properly
5935 if ( !rgbOk && deltaOk )
5938 else if ( type == "volume" ) {
5939 // volume color is set by 4 values r:g:b:delta, where
5940 // - r,g,b - is a normal volume rgb color components
5941 // - delta - is a reversed volume color delta coefficient
5942 if ( i+1 >= colors.count() ) break; // format error
5943 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5944 if ( i+2 >= colors.count() ) break; // format error
5945 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5946 if ( i+3 >= colors.count() ) break; // format error
5947 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5948 if ( i+4 >= colors.count() ) break; // format error
5949 int delta = colors[i+4].toInt( &bOk );
5950 if ( !bOk ) break; // format error
5951 volumeColor.setRgbF( r, g, b );
5955 else if ( type == "edge" ) {
5956 // edge color is set by 3 values r:g:b, where
5957 // - r,g,b - is rgb color components
5958 if ( i+1 >= colors.count() ) break; // format error
5959 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5960 if ( i+2 >= colors.count() ) break; // format error
5961 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5962 if ( i+3 >= colors.count() ) break; // format error
5963 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5964 edgeColor.setRgbF( r, g, b );
5967 else if ( type == "node" ) {
5968 // node color is set by 3 values r:g:b, where
5969 // - r,g,b - is rgb color components
5970 if ( i+1 >= colors.count() ) break; // format error
5971 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5972 if ( i+2 >= colors.count() ) break; // format error
5973 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5974 if ( i+3 >= colors.count() ) break; // format error
5975 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5976 nodeColor.setRgbF( r, g, b );
5979 else if ( type == "elem0d" ) {
5980 // 0d element color is set by 3 values r:g:b, where
5981 // - r,g,b - is rgb color components
5982 if ( i+1 >= colors.count() ) break; // format error
5983 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5984 if ( i+2 >= colors.count() ) break; // format error
5985 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5986 if ( i+3 >= colors.count() ) break; // format error
5987 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5988 elem0dColor.setRgbF( r, g, b );
5991 else if ( type == "ball" ) {
5992 // ball color is set by 3 values r:g:b, where
5993 // - r,g,b - is rgb color components
5994 if ( i+1 >= colors.count() ) break; // format error
5995 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5996 if ( i+2 >= colors.count() ) break; // format error
5997 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5998 if ( i+3 >= colors.count() ) break; // format error
5999 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6000 ballColor.setRgbF( r, g, b );
6003 else if ( type == "outline" ) {
6004 // outline color is set by 3 values r:g:b, where
6005 // - r,g,b - is rgb color components
6006 if ( i+1 >= colors.count() ) break; // format error
6007 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6008 if ( i+2 >= colors.count() ) break; // format error
6009 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6010 if ( i+3 >= colors.count() ) break; // format error
6011 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6012 outlineColor.setRgbF( r, g, b );
6015 else if ( type == "orientation" ) {
6016 // orientation color is set by 3 values r:g:b, where
6017 // - r,g,b - is rgb color components
6018 if ( i+1 >= colors.count() ) break; // format error
6019 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6020 if ( i+2 >= colors.count() ) break; // format error
6021 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6022 if ( i+3 >= colors.count() ) break; // format error
6023 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6024 orientationColor.setRgbF( r, g, b );
6029 if ( nodeColor.isValid() )
6030 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6032 if ( edgeColor.isValid() )
6033 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6035 if ( faceColor.isValid() )
6036 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6038 if ( volumeColor.isValid() )
6039 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6040 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6041 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6043 if ( elem0dColor.isValid() )
6044 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6046 if ( ballColor.isValid() )
6047 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6049 if ( outlineColor.isValid() )
6050 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6051 // orientation color
6052 if ( orientationColor.isValid() )
6053 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6056 else if (paramNameStr == "Sizes") {
6057 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6060 int outlineWidth = -1;
6061 int elem0dSize = -1;
6063 double shrinkSize = -1;
6064 double orientationSize = -1;
6065 bool orientation3d = false;
6066 for ( int i = 0; i < sizes.count(); i++ ) {
6067 QString type = sizes[i];
6068 if ( type == "line" ) {
6069 // line (wireframe) width is given as single integer value
6070 if ( i+1 >= sizes.count() ) break; // format error
6071 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6075 if ( type == "outline" ) {
6076 // outline width is given as single integer value
6077 if ( i+1 >= sizes.count() ) break; // format error
6078 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6082 else if ( type == "elem0d" ) {
6083 // 0d element size is given as single integer value
6084 if ( i+1 >= sizes.count() ) break; // format error
6085 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6089 else if ( type == "ball" ) {
6090 // ball size is given as single integer value
6091 if ( i+1 >= sizes.count() ) break; // format error
6092 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6096 else if ( type == "shrink" ) {
6097 // shrink factor is given as single floating point value
6098 if ( i+1 >= sizes.count() ) break; // format error
6099 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6103 else if ( type == "orientation" ) {
6104 // orientation vectors are specified by two values size:3d, where
6105 // - size - is a floating point value specifying scale factor
6106 // - 3d - is a boolean
6107 if ( i+1 >= sizes.count() ) break; // format error
6108 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6109 if ( i+2 >= sizes.count() ) break; // format error
6110 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6111 orientationSize = v1;
6112 orientation3d = (bool)v2;
6116 // line (wireframe) width
6117 if ( lineWidth > 0 )
6118 aSmeshActor->SetLineWidth( lineWidth );
6120 if ( outlineWidth > 0 )
6121 aSmeshActor->SetOutlineWidth( outlineWidth );
6122 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6123 aSmeshActor->SetOutlineWidth( lineWidth );
6125 if ( elem0dSize > 0 )
6126 aSmeshActor->Set0DSize( elem0dSize );
6129 aSmeshActor->SetBallSize( ballSize );
6131 if ( shrinkSize > 0 )
6132 aSmeshActor->SetShrinkFactor( shrinkSize );
6133 // orientation vectors
6134 if ( orientationSize > 0 ) {
6135 aSmeshActor->SetFacesOrientationScale( orientationSize );
6136 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6140 else if (paramNameStr == "PointMarker") {
6141 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6142 if( data.count() >= 2 ) {
6144 int aParam1 = data[1].toInt( &ok );
6146 if( data[0] == "std" && data.count() == 3 ) {
6147 int aParam2 = data[2].toInt( &ok );
6148 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6150 else if( data[0] == "custom" ) {
6151 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6152 if( markerIt != aMarkerMap.end() ) {
6153 VTK::MarkerData aMarkerData = markerIt->second;
6154 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6161 else if (paramNameStr == "Opacity") {
6162 aSmeshActor->SetOpacity(val.toFloat());
6165 else if (paramNameStr.startsWith("ClippingPlane")) {
6166 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6167 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
6168 // new format - val looks like "Off" or "0" (plane id)
6169 // (note: in new format "Off" value is used only for consistency,
6170 // so it is processed together with values in old format)
6171 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
6172 if( anIsOldFormat ) {
6173 if (paramNameStr == "ClippingPlane1" || val == "Off")
6174 aSmeshActor->RemoveAllClippingPlanes();
6176 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
6177 double aDistance = vals[1].toFloat();
6179 anAngle[0] = vals[2].toFloat();
6180 anAngle[1] = vals[3].toFloat();
6182 QList<SUIT_ViewManager*> lst;
6183 getApp()->viewManagers(viewerTypStr, lst);
6184 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6185 if (viewIndex >= 0 && viewIndex < lst.count()) {
6186 SUIT_ViewManager* vman = lst.at(viewIndex);
6187 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6189 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6191 SMESH::TActorList anActorList;
6192 anActorList.push_back( aSmeshActor );
6193 SMESH::OrientedPlane* aPlane =
6194 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
6196 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6197 aClippingPlaneInfo.Plane = aPlane;
6198 aClippingPlaneInfo.ActorList = anActorList;
6199 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6206 int aPlaneId = val.toInt( &ok );
6207 if( ok && aPlaneId >= 0 ) {
6208 bool anIsDefinedPlane = false;
6209 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6210 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6211 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6212 TPlaneInfo& aPlaneInfo = *anIter;
6213 if( aPlaneInfo.PlaneId == aPlaneId ) {
6214 aPlaneInfo.ActorList.push_back( aSmeshActor );
6215 anIsDefinedPlane = true;
6219 if( !anIsDefinedPlane ) {
6220 TPlaneInfo aPlaneInfo;
6221 aPlaneInfo.PlaneId = aPlaneId;
6222 aPlaneInfo.ActorList.push_back( aSmeshActor );
6223 aPlaneInfo.ViewManager = vman;
6225 // to make the list sorted by plane id
6226 anIter = aPlaneInfoList.begin();
6227 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6228 const TPlaneInfo& aPlaneInfoRef = *anIter;
6229 if( aPlaneInfoRef.PlaneId > aPlaneId )
6232 aPlaneInfoList.insert( anIter, aPlaneInfo );
6237 } // if (aSmeshActor)
6238 } // other parameters than Visibility
6240 } // for names/parameters iterator
6241 } // for entries iterator
6243 // take into account planes with empty list of actors referred to them
6244 QList<SUIT_ViewManager*> aVMList;
6245 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6247 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6248 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6249 int aViewId = aPlaneDataIter->first;
6250 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6251 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6253 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6255 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6256 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6257 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6258 const TPlaneData& aPlaneData = *anIter2;
6259 int aPlaneId = aPlaneData.Id;
6261 bool anIsFound = false;
6262 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6263 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6264 const TPlaneInfo& aPlaneInfo = *anIter3;
6265 if( aPlaneInfo.PlaneId == aPlaneId ) {
6272 TPlaneInfo aPlaneInfo; // ActorList field is empty
6273 aPlaneInfo.PlaneId = aPlaneId;
6274 aPlaneInfo.ViewManager = aViewManager;
6276 // to make the list sorted by plane id
6277 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6278 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6279 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6280 if( aPlaneInfoRef.PlaneId > aPlaneId )
6283 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6289 // add clipping planes to actors according to the restored parameters
6290 // and update the clipping plane map
6291 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6292 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6293 int aViewId = anIter1->first;
6294 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6296 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6297 if( anIter2 == aPlaneDataMap.end() )
6299 const TPlaneDataList& aPlaneDataList = anIter2->second;
6301 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6302 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6303 const TPlaneInfo& aPlaneInfo = *anIter3;
6304 int aPlaneId = aPlaneInfo.PlaneId;
6305 const TActorList& anActorList = aPlaneInfo.ActorList;
6306 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6310 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6314 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6316 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6317 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6318 const TPlaneData& aPlaneData = *anIter4;
6319 if( aPlaneData.Id == aPlaneId ) {
6320 SMESH::OrientedPlane* aPlane =
6321 SMESHGUI_ClippingDlg::AddPlane( anActorList,
6323 (SMESH::Orientation)aPlaneData.Orientation,
6324 aPlaneData.Distance,
6327 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6328 aClippingPlaneInfo.Plane = aPlane;
6329 aClippingPlaneInfo.ActorList = anActorList;
6330 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6338 // update all VTK views
6339 QList<SUIT_ViewManager*> lst;
6340 getApp()->viewManagers(lst);
6341 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6342 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6343 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6344 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6345 vtkView->getRenderer()->ResetCameraClippingRange();
6352 \brief Adds preferences for dfont of VTK viewer
6354 \param pIf group identifier
6355 \param param parameter
6356 \return identifier of preferences
6358 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6360 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6362 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6365 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6366 fam.append( tr( "SMESH_FONT_COURIER" ) );
6367 fam.append( tr( "SMESH_FONT_TIMES" ) );
6369 setPreferenceProperty( tfont, "fonts", fam );
6371 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6372 if ( needSize ) f = f | QtxFontEdit::Size;
6373 setPreferenceProperty( tfont, "features", f );
6379 \brief Actions after hypothesis edition
6380 Updates object browser after hypothesis edition
6382 void SMESHGUI::onHypothesisEdit( int result )
6385 SMESHGUI::Modified();
6386 updateObjBrowser( true );
6391 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6392 \param pview view being closed
6394 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6395 #ifndef DISABLE_PLOT2DVIEWER
6396 //Crear all Plot2d Viewers if need.
6397 SMESH::ClearPlot2Viewers(pview);
6401 void SMESHGUI::message( const QString& msg )
6404 QStringList data = msg.split("/");
6405 if ( data.count() > 0 ) {
6406 if ( data.first() == "mesh_loading" ) {
6408 QString entry = data.count() > 1 ? data[1] : QString();
6409 if ( entry.isEmpty() )
6412 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6414 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6417 name = obj->GetName().c_str();
6418 if ( name.isEmpty() )
6421 if ( data.last() == "stop" )
6422 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6424 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6425 QApplication::processEvents();
6431 \brief Connects or disconnects signals about activating and cloning view on the module slots
6432 \param pview view which is connected/disconnected
6434 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6438 SUIT_ViewManager* viewMgr = pview->getViewManager();
6440 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6441 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6443 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6444 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6449 \brief Return \c true if object can be renamed
6451 bool SMESHGUI::renameAllowed( const QString& entry) const {
6452 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6456 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6460 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6465 if(appStudy->isComponent(entry) || obj->isReference())
6468 // check type to prevent renaming of inappropriate objects
6469 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6470 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6471 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6472 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6473 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6474 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6481 Rename object by entry.
6482 \param entry entry of the object
6483 \param name new name of the object
6484 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6486 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6488 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6492 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6497 _PTR(Study) aStudy = appStudy->studyDS();
6502 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6504 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6509 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6510 _PTR(GenericAttribute) anAttr;
6511 _PTR(AttributeName) aName;
6513 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6515 // check type to prevent renaming of inappropriate objects
6516 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6517 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6518 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6519 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6520 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6521 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6522 if ( !name.isEmpty() ) {
6523 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6525 // update name of group object and its actor
6526 Handle(SALOME_InteractiveObject) IObject =
6527 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6529 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6530 if( !aGroupObject->_is_nil() ) {
6531 aGroupObject->SetName( qPrintable(name) );
6532 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6533 anActor->setName( qPrintable(name) );