1 // Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FileInfoDlg.h"
48 #include "SMESHGUI_FileValidator.h"
49 #include "SMESHGUI_FilterDlg.h"
50 #include "SMESHGUI_FilterLibraryDlg.h"
51 #include "SMESHGUI_FindElemByPointDlg.h"
52 #include "SMESHGUI_GroupDlg.h"
53 #include "SMESHGUI_GroupOnShapeDlg.h"
54 #include "SMESHGUI_GroupOpDlg.h"
55 #include "SMESHGUI_Hypotheses.h"
56 #include "SMESHGUI_Make2DFrom3DOp.h"
57 #include "SMESHGUI_MakeNodeAtPointDlg.h"
58 #include "SMESHGUI_Measurements.h"
59 #include "SMESHGUI_MergeDlg.h"
60 #include "SMESHGUI_MeshInfo.h"
61 #include "SMESHGUI_MeshOp.h"
62 #include "SMESHGUI_MeshOrderOp.h"
63 #include "SMESHGUI_MeshPatternDlg.h"
64 #include "SMESHGUI_MultiEditDlg.h"
65 #include "SMESHGUI_NodesDlg.h"
66 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
67 #include "SMESHGUI_PropertiesDlg.h"
68 #include "SMESHGUI_RemoveElementsDlg.h"
69 #include "SMESHGUI_RemoveNodesDlg.h"
70 #include "SMESHGUI_RenumberingDlg.h"
71 #include "SMESHGUI_ReorientFacesDlg.h"
72 #include "SMESHGUI_RevolutionDlg.h"
73 #include "SMESHGUI_RotationDlg.h"
74 #include "SMESHGUI_ScaleDlg.h"
75 #include "SMESHGUI_Selection.h"
76 #include "SMESHGUI_SewingDlg.h"
77 #include "SMESHGUI_SingleEditDlg.h"
78 #include "SMESHGUI_SmoothingDlg.h"
79 #include "SMESHGUI_SymmetryDlg.h"
80 #include "SMESHGUI_TranslationDlg.h"
81 #include "SMESHGUI_TransparencyDlg.h"
83 #include "SMESHGUI_FilterUtils.h"
84 #include "SMESHGUI_GroupUtils.h"
85 #include "SMESHGUI_HypothesesUtils.h"
86 #include "SMESHGUI_MeshUtils.h"
87 #include "SMESHGUI_PatternUtils.h"
88 #include "SMESHGUI_Utils.h"
89 #include "SMESHGUI_VTKUtils.h"
91 #include <SMESH_version.h>
93 #include "SMESH_ControlsDef.hxx"
94 #include <SMESH_Actor.h>
95 #include <SMESH_ActorUtils.h>
96 #include <SMESH_Client.hxx>
97 #include <SMESH_ScalarBarActor.h>
98 #include <SMESH_TypeFilter.hxx>
100 // SALOME GUI includes
101 #include <SalomeApp_Application.h>
102 #include <SalomeApp_CheckFileDlg.h>
103 #include <SalomeApp_DataObject.h>
104 #include <SalomeApp_Study.h>
105 #include <SalomeApp_Tools.h>
107 #include <LightApp_DataOwner.h>
108 #include <LightApp_NameDlg.h>
109 #include <LightApp_Preferences.h>
110 #include <LightApp_SelectionMgr.h>
111 #include <LightApp_UpdateFlags.h>
113 #include <SVTK_ViewManager.h>
114 #include <SVTK_ViewModel.h>
115 #include <SVTK_ViewWindow.h>
117 #include <VTKViewer_Algorithm.h>
119 #include <SUIT_Desktop.h>
120 #include <SUIT_FileDlg.h>
121 #include <SUIT_MessageBox.h>
122 #include <SUIT_OverrideCursor.h>
123 #include <SUIT_ResourceMgr.h>
124 #include <SUIT_Session.h>
126 #include <QtxPopupMgr.h>
127 #include <QtxFontEdit.h>
129 #include <SALOME_ListIO.hxx>
130 #include <SALOME_ListIteratorOfListIO.hxx>
132 #ifndef DISABLE_PLOT2DVIEWER
133 #include <SPlot2d_ViewModel.h>
134 #include <SPlot2d_Histogram.h>
138 #include <SALOMEconfig.h>
139 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
140 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
141 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
144 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
145 #include <QApplication>
147 #include <QTextStream>
150 #include <boost/shared_ptr.hpp>
153 #include <vtkCallbackCommand.h>
154 #include <vtkCamera.h>
155 #include <vtkLookupTable.h>
156 #include <vtkPlane.h>
157 #include <vtkRenderer.h>
159 // SALOME KERNEL includes
160 #include <SALOMEDSClient_ClientFactory.hxx>
161 #include <SALOMEDSClient_IParameters.hxx>
162 #include <SALOMEDSClient_SComponent.hxx>
163 #include <SALOMEDSClient_StudyBuilder.hxx>
164 #include <SALOMEDS_Study.hxx>
167 #include <Standard_ErrorHandler.hxx>
168 #include <NCollection_DataMap.hxx>
170 #include <Basics_Utils.hxx>
172 //To disable automatic genericobj management, the following line should be commented.
173 //Otherwise, it should be uncommented.
174 //Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
175 #define WITHGENERICOBJ
179 //=============================================================
180 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
183 void ExportMeshToFile(int theCommandID);
185 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
187 void SetDisplayEntity(int theCommandID);
189 void Control( int theCommandID );
193 //=============================================================
194 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
198 std::string myExtension;
200 if ( theCommandID == 113 ) {
201 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
202 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
204 else if ( theCommandID == 112 ) {
205 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
207 else if ( theCommandID == 111 ) {
208 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
210 else if ( theCommandID == 115 ) {
211 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
213 else if ( theCommandID == 116 ) {
214 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
216 else if ( theCommandID == 117 ) {
217 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
218 filter.append( QObject::tr( "All files (*)" ) );
220 else if ( theCommandID == 118 ) {
221 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
222 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
225 QString anInitialPath = "";
226 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
227 anInitialPath = QDir::currentPath();
229 QStringList filenames;
230 bool toCreateGroups = true;
232 // if ( theCommandID == 118 ) { // GMF
233 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
234 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
235 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
236 // fd->setNameFilters( filter );
237 // fd->SetChecked( true );
239 // filenames << fd->selectedFile();
240 // toCreateGroups = fd->IsChecked();
246 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
249 QObject::tr( "SMESH_IMPORT_MESH" ) );
251 if ( filenames.count() > 0 ) {
252 SUIT_OverrideCursor wc;
253 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
256 QStringList anEntryList;
257 bool isEmpty = false;
258 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
259 QString filename = *it;
260 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
262 switch ( theCommandID ) {
265 // DAT format (currently unsupported)
266 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
267 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
273 aMeshes->length( 1 );
274 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toLatin1().constData() );
275 if ( aMeshes[0]->_is_nil() )
276 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
277 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
283 SMESH::DriverMED_ReadStatus res;
284 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toLatin1().constData(), res );
285 if ( res != SMESH::DRS_OK ) {
286 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
287 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
294 aMeshes->length( 1 );
295 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toLatin1().constData() );
296 if ( aMeshes[0]->_is_nil() ) {
297 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
298 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
305 SMESH::DriverMED_ReadStatus res;
306 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toLatin1().constData(), res );
307 if ( res != SMESH::DRS_OK ) {
308 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
309 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
316 SMESH::DriverMED_ReadStatus res;
317 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toLatin1().constData(), res );
318 if ( res != SMESH::DRS_OK ) {
319 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
320 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
327 SMESH::ComputeError_var res;
328 aMeshes->length( 1 );
329 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toLatin1().constData(),
332 if ( res->code != SMESH::DRS_OK ) {
333 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
334 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
335 if ( strlen( res->comment.in() ) > 0 ) {
336 errors.back() += ": ";
337 errors.back() += res->comment.in();
344 catch ( const SALOME::SALOME_Exception& S_ex ) {
345 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
346 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
349 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
350 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
352 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
353 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
354 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
355 if ( theCommandID == 112 ) // mesh names aren't taken from the file for UNV import
356 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
358 anEntryList.append( aMeshSO->GetID().c_str() );
360 // obj has been published in study. Its refcount has been incremented.
361 // It is safe to decrement its refcount
362 // so that it will be destroyed when the entry in study will be removed
363 aMeshes[i]->UnRegister();
371 // update Object browser
372 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
374 // browse to the published meshes
375 if( LightApp_Application* anApp =
376 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
377 anApp->browseObjects( anEntryList );
379 // show Error message box if there were errors
380 if ( errors.count() > 0 ) {
381 SUIT_MessageBox::critical( SMESHGUI::desktop(),
382 QObject::tr( "SMESH_ERROR" ),
383 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
386 // show warning message box, if some imported mesh is empty
388 SUIT_MessageBox::warning( SMESHGUI::desktop(),
389 QObject::tr( "SMESH_WRN_WARNING" ),
390 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
395 //================================================================================
397 * \brief Export selected meshes or groups into a file
399 //================================================================================
401 void ExportMeshToFile( int theCommandID )
403 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
404 SALOME_ListIO selected;
406 aSel->selectedObjects( selected );
408 const bool isMED = ( theCommandID == 122 || theCommandID == 125 );
409 const bool isDAT = ( theCommandID == 121 || theCommandID == 124 );
410 const bool isUNV = ( theCommandID == 123 || theCommandID == 126 );
411 const bool isSTL = ( theCommandID == 140 || theCommandID == 141 );
412 const bool isCGNS= ( theCommandID == 142 || theCommandID == 143 );
413 const bool isSAUV= ( theCommandID == 144 || theCommandID == 145 );
414 const bool isGMF = ( theCommandID == 146 || theCommandID == 147 );
416 // actually, the following condition can't be met (added for insurance)
417 if( selected.Extent() == 0 ||
418 ( selected.Extent() > 1 && !isMED && !isSTL ))
421 // get mesh object from selection and check duplication of their names
422 bool hasDuplicatedMeshNames = false;
423 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
424 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
425 SALOME_ListIteratorOfListIO It( selected );
426 for( ; It.More(); It.Next() )
428 Handle(SALOME_InteractiveObject) anIObject = It.Value();
429 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
430 if ( aMeshItem->_is_nil() ) {
431 SUIT_MessageBox::warning( SMESHGUI::desktop(),
432 QObject::tr( "SMESH_WRN_WARNING" ),
433 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
437 QString aMeshName = anIObject->getName();
439 // check for name duplications
440 if ( !hasDuplicatedMeshNames )
441 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
442 if( aMeshName == (*aMeshIter).second ) {
443 hasDuplicatedMeshNames = true;
448 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
451 if( hasDuplicatedMeshNames && isMED ) {
452 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
453 QObject::tr("SMESH_WRN_WARNING"),
454 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
455 QObject::tr("SMESH_BUT_YES"),
456 QObject::tr("SMESH_BUT_NO"), 0, 1);
461 aMeshIter = aMeshList.begin();
462 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
463 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
464 QString aMeshName = (*aMeshIter).second;
466 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
468 // check for equal group names within each mesh
469 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
470 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
471 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
472 int aRet = SUIT_MessageBox::warning
473 (SMESHGUI::desktop(),
474 QObject::tr("SMESH_WRN_WARNING"),
475 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
476 QObject::tr("SMESH_BUT_YES"),
477 QObject::tr("SMESH_BUT_NO"), 0, 1);
484 // Warn the user about presence of not supported elements
486 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
490 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Quadrangle );
491 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
492 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
493 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
494 notSupportedElemTypes.push_back( SMESH::Entity_Tetra );
495 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Tetra );
496 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
497 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
498 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Hexa );
499 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
500 notSupportedElemTypes.push_back( SMESH::Entity_Penta );
501 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
502 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
503 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
504 notSupportedElemTypes.push_back( SMESH::Entity_0D );
505 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
510 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
511 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
512 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
513 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
514 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
515 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
516 notSupportedElemTypes.push_back( SMESH::Entity_0D );
517 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
522 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
523 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
524 notSupportedElemTypes.push_back( SMESH::Entity_0D );
525 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
530 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
535 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
536 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
537 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
538 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
539 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
540 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
545 notSupportedElemTypes.push_back( SMESH::Entity_0D );
546 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
547 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
548 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
549 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
550 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
551 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
552 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
553 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
555 if ( ! notSupportedElemTypes.empty() )
557 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
558 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
559 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
560 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
562 if ( !presentNotSupported.empty() )
565 const char* typeMsg[SMESH::Entity_Last] = { "SMESH_NODES",
566 "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES","SMESH_TRIANGLES",
567 "SMESH_QUADRATIC_TRIANGLES","SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES",
568 "SMESH_BIQUADRATIC_QUADRANGLES","SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
569 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
570 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
571 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
572 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
574 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
575 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
576 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
577 if ( iType != presentNotSupported.size() - 1 )
578 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
580 int aRet = SUIT_MessageBox::warning
581 (SMESHGUI::desktop(),
582 QObject::tr("SMESH_WRN_WARNING"),
583 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
584 QObject::tr("SMESH_BUT_YES"),
585 QObject::tr("SMESH_BUT_NO"), 0, 1);
590 // Get parameters of export operation
593 SMESH::MED_VERSION aFormat;
594 // Init the parameters with the default values
595 bool aIsASCII_STL = true;
596 bool toCreateGroups = false;
597 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
599 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
600 bool toOverwrite = true;
602 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
603 QString anInitialPath = "";
604 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
605 anInitialPath = QDir::currentPath();
607 // Get a file name to write in and additional otions
608 if ( isUNV || isDAT || isGMF ) // Export w/o options
611 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
613 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
615 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
616 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
617 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
618 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
619 anInitialPath + QString("/") + aMeshName,
620 aFilter, aTitle, false);
622 // else if ( isGMF )// Export to GMF
624 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
625 // ( SMESHGUI::desktop(), false, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
626 // QStringList filters;
627 // filters << QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)"
628 // << QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
629 // fd->setWindowTitle( aTitle );
630 // fd->setNameFilters( filters );
632 // if ( !aMeshOrGroup->_is_equivalent( aMesh ))
633 // toCreateGroups = false;
635 // toCreateGroups = ( aMesh->NbGroups() > 0 );
637 // fd->SetChecked( true );
638 // if ( !anInitialPath.isEmpty() )
639 // fd->setDirectory( anInitialPath );
640 // fd->selectFile(aMeshName);
643 // aFilename = fd->selectedFile();
644 // toCreateGroups = fd->IsChecked();
648 else if ( isCGNS )// Export to CGNS
650 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
651 fd->setWindowTitle( aTitle );
652 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
653 if ( !anInitialPath.isEmpty() )
654 fd->setDirectory( anInitialPath );
655 fd->selectFile(aMeshName);
656 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
657 fd->setValidator( fv );
660 aFilename = fd->selectedFile();
661 toOverwrite = fv->isOverwrite();
665 else if ( isSTL ) // Export to STL
667 QMap<QString, int> aFilterMap;
668 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
669 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
672 QMap<QString, int>::const_iterator it = aFilterMap.begin();
673 for ( ; it != aFilterMap.end(); ++it )
674 filters.push_back( it.key() );
676 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
677 fd->setWindowTitle( aTitle );
678 fd->setNameFilters( filters );
679 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
680 if ( !anInitialPath.isEmpty() )
681 fd->setDirectory( anInitialPath );
682 fd->selectFile(aMeshName);
686 aFilename = fd->selectedFile();
687 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
692 else if ( isMED || isSAUV ) // Export to MED or SAUV
694 QMap<QString, SMESH::MED_VERSION> aFilterMap;
695 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
697 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
698 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
699 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
702 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
703 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
704 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
708 QString aDefaultFilter;
709 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
710 for ( ; it != aFilterMap.end(); ++it ) {
711 filters.push_back( it.key() );
712 if (it.value() == SMESH::MED_V2_2)
713 aDefaultFilter = it.key();
716 SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
717 ( SMESHGUI::desktop(), false, QObject::tr("SMESH_AUTO_GROUPS"), true, true );
718 fd->setWindowTitle( aTitle );
719 fd->setNameFilters( filters );
720 fd->selectNameFilter(aDefaultFilter);
721 fd->SetChecked(toCreateGroups);
722 if ( !anInitialPath.isEmpty() )
723 fd->setDirectory( anInitialPath );
724 fd->selectFile(aMeshName);
726 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
727 fd->setValidator( fv );
732 aFilename = fd->selectedFile();
734 aFilename = QString::null;
737 aFormat = aFilterMap[fd->selectedNameFilter()];
738 toOverwrite = fv->isOverwrite();
740 if ( !aFilename.isEmpty() ) {
741 // med-2.1 does not support poly elements
742 if ( aFormat==SMESH::MED_V2_1 )
743 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
744 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
745 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
746 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
747 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
749 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
750 QObject::tr("SMESH_WRN_WARNING"),
751 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
752 QObject::tr("SMESH_BUT_YES"),
753 QObject::tr("SMESH_BUT_NO"), 0, 1);
761 // can't append to an existing using other format
762 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
763 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toLatin1().constData(), aVersion );
764 if( !isVersionOk || aVersion != aFormat ) {
765 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
766 QObject::tr("SMESH_WRN_WARNING"),
767 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
768 QObject::tr("SMESH_BUT_YES"),
769 QObject::tr("SMESH_BUT_NO"), 0, 1);
776 QStringList aMeshNamesCollisionList;
777 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toLatin1().constData() );
778 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
779 QString anExistingMeshName( aMeshNames[ i ] );
780 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
781 QString anExportMeshName = (*aMeshIter).second;
782 if( anExportMeshName == anExistingMeshName ) {
783 aMeshNamesCollisionList.append( anExportMeshName );
788 if( !aMeshNamesCollisionList.isEmpty() ) {
789 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
790 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
791 QObject::tr("SMESH_WRN_WARNING"),
792 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
793 QObject::tr("SMESH_BUT_YES"),
794 QObject::tr("SMESH_BUT_NO"),
795 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
804 toCreateGroups = fd->IsChecked();
814 if ( !aFilename.isEmpty() ) {
815 // Check whether the file already exists and delete it if yes
816 QFile aFile( aFilename );
817 if ( aFile.exists() && toOverwrite )
819 SUIT_OverrideCursor wc;
822 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
823 // bool Renumber = false;
824 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
826 // Renumber= resMgr->booleanValue("renumbering");
828 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
829 // aMeshEditor->RenumberNodes();
830 // aMeshEditor->RenumberElements();
831 // if ( SMESHGUI::automaticUpdate() )
832 // SMESH::UpdateView();
836 aMeshIter = aMeshList.begin();
837 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
839 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
840 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
841 if ( aMeshOrGroup->_is_equivalent( aMeshItem ))
842 aMeshItem->ExportToMEDX( aFilename.toLatin1().data(), toCreateGroups,
843 aFormat, toOverwrite && aMeshIndex == 0 );
845 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups,
846 aFormat, toOverwrite && aMeshIndex == 0 );
851 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
853 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
854 if( !aMeshItem->_is_nil() )
855 aMeshItem->ExportSAUV( aFilename.toLatin1().data(), toCreateGroups );
860 if ( aMeshOrGroup->_is_equivalent( aMesh ))
861 aMesh->ExportDAT( aFilename.toLatin1().data() );
863 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toLatin1().data() );
867 if ( aMeshOrGroup->_is_equivalent( aMesh ))
868 aMesh->ExportUNV( aFilename.toLatin1().data() );
870 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toLatin1().data() );
874 if ( aMeshOrGroup->_is_equivalent( aMesh ))
875 aMesh->ExportSTL( aFilename.toLatin1().data(), aIsASCII_STL );
877 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toLatin1().data(), aIsASCII_STL );
881 aMeshIter = aMeshList.begin();
882 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
884 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
885 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
886 aMeshItem->ExportCGNS( aMeshOrGroup,
887 aFilename.toLatin1().data(),
888 toOverwrite && aMeshIndex == 0 );
893 toCreateGroups = true;
894 aMesh->ExportGMF( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups );
897 catch (const SALOME::SALOME_Exception& S_ex){
899 SUIT_MessageBox::warning(SMESHGUI::desktop(),
900 QObject::tr("SMESH_WRN_WARNING"),
901 QObject::tr("SMESH_EXPORT_FAILED"));
907 inline void InverseEntityMode(unsigned int& theOutputMode,
908 unsigned int theMode)
910 bool anIsNotPresent = ~theOutputMode & theMode;
912 theOutputMode |= theMode;
914 theOutputMode &= ~theMode;
917 void SetDisplayEntity(int theCommandID){
918 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
919 SALOME_ListIO selected;
921 aSel->selectedObjects( selected );
923 if(selected.Extent() >= 1){
924 SALOME_ListIteratorOfListIO It( selected );
925 for( ; It.More(); It.Next()){
926 Handle(SALOME_InteractiveObject) IObject = It.Value();
927 if(IObject->hasEntry()){
928 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
929 unsigned int aMode = anActor->GetEntityMode();
930 switch(theCommandID){
932 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
935 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
938 InverseEntityMode(aMode,SMESH_Actor::eEdges);
941 InverseEntityMode(aMode,SMESH_Actor::eFaces);
944 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
947 aMode = SMESH_Actor::eAllEntity;
951 anActor->SetEntityMode(aMode);
959 SALOME_ListIO selected;
960 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
964 LightApp_SelectionMgr* aSel = app->selectionMgr();
965 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
966 if( !aSel || !appStudy )
969 aSel->selectedObjects( selected );
970 if( selected.IsEmpty() )
973 Handle(SALOME_InteractiveObject) anIObject = selected.First();
975 _PTR(Study) aStudy = appStudy->studyDS();
976 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
977 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
978 if( aMainObject->_is_nil() )
981 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
983 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
984 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
986 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
987 SALOMEDS::Color aColor = aGroupObject->GetColor();
988 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
992 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
993 switch ( aGroupObject->GetType ()) {
995 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
997 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
999 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1001 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1003 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1004 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1007 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1008 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1014 SMESH::RepaintCurrentView();
1017 QString functorToString( SMESH::Controls::FunctorPtr f )
1019 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1020 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1021 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1022 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1023 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1024 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1025 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1026 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1027 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1028 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1029 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1030 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1031 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1032 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1033 type = QObject::tr( "WARP_ELEMENTS" );
1034 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1035 type = QObject::tr( "TAPER_ELEMENTS" );
1036 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1037 type = QObject::tr( "SKEW_ELEMENTS" );
1038 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1039 type = QObject::tr( "AREA_ELEMENTS" );
1040 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1041 type = QObject::tr( "LENGTH_EDGES" );
1042 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1043 type = QObject::tr( "LENGTH2D_EDGES" );
1044 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1045 type = QObject::tr( "MULTI_BORDERS" );
1046 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1047 type = QObject::tr( "MULTI2D_BORDERS" );
1048 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1049 type = QObject::tr( "FREE_NODES" );
1050 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1051 type = QObject::tr( "FREE_EDGES" );
1052 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1053 type = QObject::tr( "FREE_BORDERS" );
1054 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1055 type = QObject::tr( "FREE_FACES" );
1056 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1057 type = QObject::tr( "BARE_BORDER_VOLUME" );
1058 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1059 type = QObject::tr( "BARE_BORDER_FACE" );
1060 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1061 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1062 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1063 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1064 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1065 type = QObject::tr( "EQUAL_NODE" );
1066 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1067 type = QObject::tr( "EQUAL_EDGE" );
1068 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1069 type = QObject::tr( "EQUAL_FACE" );
1070 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1071 type = QObject::tr( "EQUAL_VOLUME" );
1075 void SaveDistribution()
1077 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1078 SALOME_ListIO selected;
1080 aSel->selectedObjects( selected );
1082 if ( selected.Extent() == 1 ) {
1083 Handle(SALOME_InteractiveObject) anIO = selected.First();
1084 if ( anIO->hasEntry() ) {
1085 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1086 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1087 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1088 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1089 if ( aScalarBarActor && aFunctor ) {
1090 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1092 std::vector<int> elements;
1093 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1094 if ( mesh->_is_nil() ) {
1095 SMESH::SMESH_IDSource_var idSource =
1096 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1097 if ( !idSource->_is_nil() )
1099 SMESH::long_array_var ids = idSource->GetIDs();
1100 elements.resize( ids->length() );
1101 for ( unsigned i = 0; i < elements.size(); ++i )
1102 elements[i] = ids[i];
1105 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1106 vtkLookupTable* lookupTable =
1107 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1108 double * minmax = lookupTable->GetRange();
1109 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1110 std::vector<int> nbEvents;
1111 std::vector<double> funValues;
1112 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
1113 QString anInitialPath = "";
1114 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1115 anInitialPath = QDir::currentPath();
1116 QString aMeshName = anIO->getName();
1118 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1119 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1120 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1121 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1122 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1125 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1127 if ( !aFilename.isEmpty() ) {
1128 QFile f( aFilename );
1129 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1130 QTextStream out( &f );
1131 out << "# Mesh: " << aMeshName << endl;
1132 out << "# Control: " << functorToString( aFunctor ) << endl;
1134 out.setFieldWidth( 10 );
1135 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1136 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1147 void ShowDistribution() {
1148 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1149 SALOME_ListIO selected;
1151 aSel->selectedObjects( selected );
1153 if ( selected.Extent() == 1 ) {
1154 Handle(SALOME_InteractiveObject) anIO = selected.First();
1155 if ( anIO->hasEntry() ) {
1156 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1157 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1158 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1159 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1165 #ifndef DISABLE_PLOT2DVIEWER
1166 void PlotDistribution() {
1167 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1171 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1172 SALOME_ListIO selected;
1174 aSel->selectedObjects( selected );
1176 if ( selected.Extent() == 1 ) {
1177 Handle(SALOME_InteractiveObject) anIO = selected.First();
1178 if ( anIO->hasEntry() ) {
1179 //Find Actor by entry before getting Plot2d viewer,
1180 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1181 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1183 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1188 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1192 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1196 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1197 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1198 QString functorName = functorToString( anActor->GetFunctor());
1199 QString aHistogramName("%1 : %2");
1200 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1201 aHistogram->setName(aHistogramName);
1202 aHistogram->setHorTitle(functorName);
1203 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1204 aPlot->displayObject(aHistogram, true);
1209 #endif //DISABLE_PLOT2DVIEWER
1211 void DisableAutoColor(){
1212 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1213 SALOME_ListIO selected;
1215 aSel->selectedObjects( selected );
1217 if(selected.Extent()){
1218 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1219 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1220 if ( !aMesh->_is_nil() ) {
1221 aMesh->SetAutoColor( false );
1226 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1228 SALOME_ListIO selected;
1229 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1233 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1234 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1235 if( !aSel || !appStudy )
1238 if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection
1239 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1240 aModule->EmitSignalDeactivateDialog();
1241 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1242 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1247 _PTR(Study) aStudy = appStudy->studyDS();
1249 aSel->selectedObjects( selected );
1251 if(selected.Extent() >= 1){
1252 switch(theCommandID){
1254 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1255 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1259 vtkFloatingPointType color[3];
1260 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1261 QColor orientationColor, outlineColor, volumeColor;
1262 int deltaF = 0, deltaV = 0;
1266 int outlineWidth = 1;
1267 vtkFloatingPointType shrinkCoef = 0.0;
1268 vtkFloatingPointType orientationScale = 0.0;
1269 bool orientation3d = false;
1270 VTK::MarkerType markerType = VTK::MT_NONE;
1271 VTK::MarkerScale markerScale = VTK::MS_NONE;
1273 bool hasNodes = false;
1274 int presentEntities = 0;
1275 bool firstTime = true;
1277 SALOME_ListIteratorOfListIO It( selected );
1278 for ( ; It.More(); It.Next() ) {
1279 Handle(SALOME_InteractiveObject) IObject = It.Value();
1280 if ( !IObject->hasEntry() ) continue;
1281 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1282 if ( !anActor || !anActor->GetObject() ) continue;
1285 // nodes: color, marker
1286 anActor->GetNodeColor( color[0], color[1], color[2] );
1287 nodeColor.setRgbF( color[0], color[1], color[2] );
1288 markerType = anActor->GetMarkerType();
1289 markerScale = anActor->GetMarkerScale();
1290 markerId = anActor->GetMarkerTexture();
1291 // edges: color, width
1292 anActor->GetEdgeColor( color[0], color[1], color[2] );
1293 edgeColor.setRgbF( color[0], color[1], color[2] );
1294 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1295 // faces: front color, back color (delta)
1296 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1297 faceColor.setRgbF( color[0], color[1], color[2] );
1298 // faces: front color, back color (delta)
1299 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1300 volumeColor.setRgbF( color[0], color[1], color[2] );
1301 // 0d elements: color, size
1302 anActor->Get0DColor( color[0], color[1], color[2] );
1303 elem0dColor.setRgbF( color[0], color[1], color[2] );
1304 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1305 // balls: color, size
1306 anActor->GetBallColor( color[0], color[1], color[2] );
1307 ballColor.setRgbF( color[0], color[1], color[2] );
1308 ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1310 anActor->GetOutlineColor( color[0], color[1], color[2] );
1311 outlineColor.setRgbF( color[0], color[1], color[2] );
1312 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1313 // orientation vectors: color, scale, 3d flag
1314 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1315 orientationColor.setRgbF( color[0], color[1], color[2] );
1316 orientationScale = anActor->GetFacesOrientationScale();
1317 orientation3d = anActor->GetFacesOrientation3DVectors();
1319 shrinkCoef = anActor->GetShrinkFactor();
1322 firstTime = false; // we only take properties from first object (for performance reasons)
1325 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1326 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1327 presentEntities = presentEntities | SMESH_Actor::eEdges;
1328 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1329 presentEntities = presentEntities | SMESH_Actor::eFaces;
1330 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1331 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1332 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1333 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1334 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1335 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1337 // as we know that all types of elements are present, we can exit the loop
1338 if ( presentEntities == SMESH_Actor::eAllEntity )
1342 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1343 // nodes: color, marker
1344 dlg.setNodeColor( nodeColor );
1345 if( markerType != VTK::MT_USER )
1346 dlg.setNodeMarker( markerType, markerScale );
1348 dlg.setNodeCustomMarker( markerId );
1349 // edges: color, line width
1350 dlg.setEdgeColor( edgeColor );
1351 dlg.setEdgeWidth( edgeWidth );
1352 // faces: front color, back color
1353 dlg.setFaceColor( faceColor, deltaF );
1354 // volumes: normal color, reversed color
1355 dlg.setVolumeColor( volumeColor, deltaV );
1356 // outlines: color, line width
1357 dlg.setOutlineColor( outlineColor );
1358 dlg.setOutlineWidth( outlineWidth );
1359 // 0d elements: color, size
1360 dlg.setElem0dColor( elem0dColor );
1361 dlg.setElem0dSize( elem0dSize );
1362 // balls: color, size
1363 dlg.setBallColor( ballColor );
1364 dlg.setBallSize( ballSize );
1365 // orientation: color, scale, 3d flag
1366 dlg.setOrientationColor( orientationColor );
1367 dlg.setOrientationSize( int( orientationScale * 100. ) );
1368 dlg.setOrientation3d( orientation3d );
1369 // shrink: scale factor
1370 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1371 // hide unused controls
1372 dlg.showControls( presentEntities, hasNodes );
1375 nodeColor = dlg.nodeColor();
1376 markerType = dlg.nodeMarkerType();
1377 markerScale = dlg.nodeMarkerScale();
1378 markerId = dlg.nodeMarkerId();
1379 edgeColor = dlg.edgeColor();
1380 edgeWidth = dlg.edgeWidth();
1381 faceColor = dlg.faceColor();
1382 deltaF = dlg.faceColorDelta();
1383 volumeColor = dlg.volumeColor();
1384 deltaV = dlg.volumeColorDelta();
1385 outlineColor = dlg.outlineColor();
1386 outlineWidth = dlg.outlineWidth();
1387 elem0dColor = dlg.elem0dColor();
1388 elem0dSize = dlg.elem0dSize();
1389 ballColor = dlg.ballColor();
1390 ballSize = dlg.ballSize();
1391 orientationColor = dlg.orientationColor();
1392 orientationScale = dlg.orientationSize() / 100.;
1393 orientation3d = dlg.orientation3d();
1394 shrinkCoef = dlg.shrinkCoef() / 100.;
1396 // store point markers map that might be changed by the user
1397 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1399 // set properties from dialog box to the presentations
1400 SALOME_ListIteratorOfListIO It( selected );
1401 for ( ; It.More(); It.Next() ) {
1402 Handle(SALOME_InteractiveObject) IObject = It.Value();
1403 if ( !IObject->hasEntry() ) continue;
1404 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1405 if ( !anActor ) continue;
1407 // nodes: color, marker
1408 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1409 if ( markerType != VTK::MT_USER ) {
1410 anActor->SetMarkerStd( markerType, markerScale );
1413 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1414 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1415 if ( iter != markerMap.end() )
1416 anActor->SetMarkerTexture( markerId, iter->second.second );
1418 // volumes: normal color, reversed color (delta)
1419 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1420 // faces: front color, back color (delta)
1421 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1422 // edges: color, width
1423 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1424 anActor->SetLineWidth( edgeWidth );
1426 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1427 anActor->SetOutlineWidth( outlineWidth );
1428 // 0D elements: color, size
1429 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1430 anActor->Set0DSize( elem0dSize );
1431 // balls: color, size
1432 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1433 anActor->SetBallSize( ballSize );
1434 // orientation: color, scale, 3d flag
1435 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1436 anActor->SetFacesOrientationScale( orientationScale );
1437 anActor->SetFacesOrientation3DVectors( orientation3d );
1439 anActor->SetShrinkFactor( shrinkCoef );
1441 // for groups, set also proper color
1442 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1443 if ( !aGroupObject->_is_nil() ) {
1444 SMESH::ElementType anElementType = aGroupObject->GetType();
1446 switch( anElementType ) {
1448 aColor = nodeColor; break;
1450 aColor = edgeColor; break;
1452 aColor = faceColor; break;
1454 aColor = volumeColor; break;
1456 aColor = elem0dColor; break;
1458 aColor = ballColor; break;
1462 if ( aColor.isValid() ) {
1463 SALOMEDS::Color aGroupColor;
1464 aGroupColor.R = aColor.redF();
1465 aGroupColor.G = aColor.greenF();
1466 aGroupColor.B = aColor.blueF();
1467 aGroupObject->SetColor( aGroupColor );
1469 } // if ( !aGroupObject->_is_nil() )
1470 } // for ( ; It.More(); It.Next() )
1471 SMESH::RepaintCurrentView();
1472 } // if ( dlg.exec() )
1475 } // switch(theCommandID)
1476 SALOME_ListIteratorOfListIO It( selected );
1477 for( ; It.More(); It.Next()){
1478 Handle(SALOME_InteractiveObject) IObject = It.Value();
1479 if(IObject->hasEntry()){
1480 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1481 switch(theCommandID){
1483 anActor->SetRepresentation(SMESH_Actor::eEdge);
1486 anActor->SetRepresentation(SMESH_Actor::eSurface);
1489 if(anActor->IsShrunk())
1490 anActor->UnShrink();
1492 anActor->SetShrink();
1495 anActor->SetRepresentation(SMESH_Actor::ePoint);
1498 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1499 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1502 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1503 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1509 SMESH::RepaintCurrentView();
1513 void Control( int theCommandID )
1515 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1516 SALOME_ListIO selected;
1518 aSel->selectedObjects( selected );
1520 if( !selected.IsEmpty() ){
1521 Handle(SALOME_InteractiveObject) anIO = selected.First();
1523 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1524 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1525 switch ( theCommandID ){
1527 aControl = SMESH_Actor::eLength;
1530 aControl = SMESH_Actor::eLength2D;
1533 aControl = SMESH_Actor::eFreeEdges;
1536 aControl = SMESH_Actor::eFreeBorders;
1539 aControl = SMESH_Actor::eMultiConnection;
1542 aControl = SMESH_Actor::eFreeNodes;
1545 aControl = SMESH_Actor::eMultiConnection2D;
1548 aControl = SMESH_Actor::eArea;
1551 aControl = SMESH_Actor::eTaper;
1554 aControl = SMESH_Actor::eAspectRatio;
1557 aControl = SMESH_Actor::eAspectRatio3D;
1560 aControl = SMESH_Actor::eMinimumAngle;
1563 aControl = SMESH_Actor::eWarping;
1566 aControl = SMESH_Actor::eSkew;
1569 aControl = SMESH_Actor::eVolume3D;
1572 aControl = SMESH_Actor::eFreeFaces;
1575 aControl = SMESH_Actor::eMaxElementLength2D;
1578 aControl = SMESH_Actor::eMaxElementLength3D;
1581 aControl = SMESH_Actor::eBareBorderVolume;
1584 aControl = SMESH_Actor::eBareBorderFace;
1587 aControl = SMESH_Actor::eOverConstrainedVolume;
1590 aControl = SMESH_Actor::eOverConstrainedFace;
1593 aControl = SMESH_Actor::eCoincidentNodes;
1596 aControl = SMESH_Actor::eCoincidentElems1D;
1599 aControl = SMESH_Actor:: eCoincidentElems2D;
1602 aControl = SMESH_Actor::eCoincidentElems3D;
1606 anActor->SetControlMode(aControl);
1607 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1608 SMESH::RepaintCurrentView();
1609 #ifndef DISABLE_PLOT2DVIEWER
1610 if(anActor->GetPlot2Histogram()) {
1611 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1612 QString functorName = functorToString( anActor->GetFunctor());
1613 QString aHistogramName("%1 : %2");
1614 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1615 aHistogram->setName(aHistogramName);
1616 aHistogram->setHorTitle(functorName);
1617 SMESH::ProcessIn2DViewers(anActor);
1626 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1627 SMESH::MeshObjectType theType,
1628 const QString theInTypeName,
1629 QString & theOutTypeName)
1631 SMESH_TypeFilter aTypeFilter( theType );
1633 if( !theIO.IsNull() )
1635 entry = theIO->getEntry();
1636 LightApp_DataOwner owner( entry );
1637 if ( aTypeFilter.isOk( &owner )) {
1638 theOutTypeName = theInTypeName;
1646 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1648 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1649 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1651 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1652 CORBA::String_var anID = aSComp->GetID().c_str();
1653 if (!strcmp(anID.in(),theIO->getEntry()))
1659 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1660 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1661 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1662 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1663 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1671 QString CheckHomogeneousSelection()
1673 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1674 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1675 SALOME_ListIO selected;
1677 aSel->selectedObjects( selected );
1679 QString RefType = CheckTypeObject(selected.First());
1680 SALOME_ListIteratorOfListIO It(selected);
1681 for ( ; It.More(); It.Next())
1683 Handle(SALOME_InteractiveObject) IObject = It.Value();
1684 QString Type = CheckTypeObject(IObject);
1685 if (Type.compare(RefType) != 0)
1686 return "Heterogeneous Selection";
1693 void SMESHGUI::OnEditDelete()
1695 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1696 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1697 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1699 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1700 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1701 _PTR(GenericAttribute) anAttr;
1702 _PTR(AttributeIOR) anIOR;
1704 int objectCount = 0;
1706 QString aParentComponent = QString::null;
1707 Handle(SALOME_InteractiveObject) anIO;
1708 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1710 anIO = anIt.Value();
1711 QString cur = anIO->getComponentDataType();
1712 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1714 // check if object is reference
1715 _PTR(SObject) aRefSObj;
1716 aNameList.append("\n - ");
1717 if ( aSO->ReferencedObject( aRefSObj ) ) {
1718 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1719 aNameList.append( aRefName );
1720 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1723 aNameList.append(anIO->getName());
1727 if( aParentComponent.isNull() )
1728 aParentComponent = cur;
1729 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1730 aParentComponent = "";
1733 if ( objectCount == 0 )
1734 return; // No Valid Objects Selected
1736 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1737 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1738 QObject::tr("ERR_ERROR"),
1739 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1742 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1743 if (SUIT_MessageBox::warning
1744 (SMESHGUI::desktop(),
1745 QObject::tr("SMESH_WRN_WARNING"),
1746 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1747 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1748 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1751 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1753 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1754 // then treat them all starting from the deepest objects (at list back)
1755 std::list< _PTR(SObject) > listSO;
1756 SALOME_ListIteratorOfListIO It(selected);
1757 for( ; It.More(); It.Next()) // loop on selected IO's
1759 Handle(SALOME_InteractiveObject) IObject = It.Value();
1760 if(IObject->hasEntry()) {
1761 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1763 // disable removal of "SMESH" component object
1764 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1766 if ( engineIOR() == anIOR->Value().c_str() )
1769 //Check the referenced object
1770 _PTR(SObject) aRefSObject;
1771 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1772 aSO = aRefSObject; // Delete main Object instead of reference
1774 listSO.push_back( aSO );
1775 std::list< _PTR(SObject) >::iterator itSO = listSO.begin();
1776 for ( ; itSO != listSO.end(); ++itSO ) {
1777 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1778 for (it->InitEx(false); it->More(); it->Next())
1779 listSO.push_back( it->Value() );
1783 // Check if none of objects to delete is referred from outside
1784 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1785 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1787 _PTR(SObject) SO = *ritSO;
1788 if ( !SO ) continue;
1789 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1790 for (size_t i = 0; i < aReferences.size(); i++) {
1791 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1792 std::string type = aComponent->ComponentDataType();
1793 if ( type != "SMESH" )
1795 SUIT_MessageBox::warning( anApp->desktop(),
1796 QObject::tr("WRN_WARNING"),
1797 QObject::tr("DEP_OBJECT") );
1798 return; // outside SMESH, there is an object depending on a SMESH object
1803 // Treat SO's in the list starting from the back
1804 aStudyBuilder->NewCommand(); // There is a transaction
1805 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1807 _PTR(SObject) SO = *ritSO;
1808 if ( !SO ) continue;
1809 std::string anEntry = SO->GetID();
1811 /** Erase graphical object **/
1812 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1813 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1814 // ViewManagerList aViewMenegers = anApp->viewManagers();
1815 // ViewManagerList::const_iterator it = aViewMenegers.begin();
1816 // for( ; it != aViewMenegers.end(); it++) {
1817 // SUIT_ViewManager* vm = *it;
1818 // int nbSf = vm ? vm->getViewsCount() : 0;
1820 // QVector<SUIT_ViewWindow*> aViews = vm->getViews();
1821 // for(int i = 0; i < nbSf; i++){
1822 // SUIT_ViewWindow *sf = aViews[i];
1823 // if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
1824 // SMESH::RemoveActor(sf,anActor);
1830 /** Remove an object from data structures **/
1831 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1832 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1833 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1834 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1835 aMesh->RemoveGroup( aGroup );
1837 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1838 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1839 aMesh->RemoveSubMesh( aSubMesh );
1841 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1843 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1846 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1847 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1848 QString objType = CheckTypeObject(IObject);
1849 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1850 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1851 aStudyBuilder->RemoveObjectWithChildren( SO );
1853 else {// default action: remove SObject from the study
1854 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1855 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1857 aStudyBuilder->RemoveObjectWithChildren( SO );
1861 } /* listSO back loop */
1863 aStudyBuilder->CommitCommand();
1865 /* Clear any previous selection */
1867 aSel->setSelectedObjects( l1 );
1869 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1874 SMESHGUI_EXPORT CAM_Module* createModule()
1876 return new SMESHGUI();
1879 SMESHGUI_EXPORT char* getModuleVersion() {
1880 return (char*)SMESH_VERSION_STR;
1884 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1886 //=============================================================================
1890 //=============================================================================
1891 SMESHGUI::SMESHGUI() :
1892 SalomeApp_Module( "SMESH" )
1894 if ( CORBA::is_nil( myComponentSMESH ) )
1896 CORBA::Boolean anIsEmbeddedMode;
1897 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1898 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1900 // 0019923: EDF 765 SMESH : default values of hypothesis
1901 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1902 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1903 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1904 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1905 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1907 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1908 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1909 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1911 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1912 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1916 myActiveDialogBox = 0;
1917 myFilterLibraryDlg = 0;
1921 myEventCallbackCommand = vtkCallbackCommand::New();
1922 myEventCallbackCommand->Delete();
1923 myEventCallbackCommand->SetClientData( this );
1924 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1927 /* load resources for all available meshers */
1928 SMESH::InitAvailableHypotheses();
1931 //=============================================================================
1935 //=============================================================================
1936 SMESHGUI::~SMESHGUI()
1940 //=============================================================================
1944 //=============================================================================
1945 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1947 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1949 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1954 //=============================================================================
1958 //=============================================================================
1959 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1961 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1965 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
1966 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1967 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
1968 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
1969 return autoUpdate && !exceeded;
1972 //=============================================================================
1976 //=============================================================================
1977 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
1979 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
1982 //=============================================================================
1986 //=============================================================================
1987 SMESHGUI* SMESHGUI::GetSMESHGUI()
1989 SMESHGUI* smeshMod = 0;
1990 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
1993 CAM_Module* module = app->module( "Mesh" );
1994 smeshMod = dynamic_cast<SMESHGUI*>( module );
1997 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
1999 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2002 _PTR(Study) aStudy = study->studyDS();
2004 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2013 Standard_EXPORT SMESHGUI* GetComponentGUI()
2015 return SMESHGUI::GetSMESHGUI();
2019 //=============================================================================
2023 //=============================================================================
2024 void SMESHGUI::SetState(int aState)
2029 //=============================================================================
2033 //=============================================================================
2034 void SMESHGUI::ResetState()
2039 //=============================================================================
2043 //=============================================================================
2044 void SMESHGUI::EmitSignalDeactivateDialog()
2046 emit SignalDeactivateActiveDialog();
2049 //=============================================================================
2053 //=============================================================================
2054 void SMESHGUI::EmitSignalStudyFrameChanged()
2056 emit SignalStudyFrameChanged();
2059 //=============================================================================
2063 //=============================================================================
2064 void SMESHGUI::EmitSignalCloseAllDialogs()
2066 emit SignalCloseAllDialogs();
2069 //=============================================================================
2073 //=============================================================================
2074 void SMESHGUI::EmitSignalVisibilityChanged()
2076 emit SignalVisibilityChanged();
2079 //=============================================================================
2083 //=============================================================================
2084 QDialog *SMESHGUI::GetActiveDialogBox()
2086 return myActiveDialogBox;
2089 //=============================================================================
2093 //=============================================================================
2094 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2096 myActiveDialogBox = (QDialog *) aDlg;
2100 //=============================================================================
2104 //=============================================================================
2105 SUIT_Desktop* SMESHGUI::desktop()
2107 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2109 return app->desktop();
2114 //=============================================================================
2118 //=============================================================================
2119 SalomeApp_Study* SMESHGUI::activeStudy()
2121 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2123 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2128 //=============================================================================
2132 //=============================================================================
2133 void SMESHGUI::Modified( bool theIsUpdateActions )
2135 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2136 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2137 appStudy->Modified();
2138 if( theIsUpdateActions )
2139 app->updateActions();
2144 //=============================================================================
2148 //=============================================================================
2149 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2151 /* Here the position is on the bottom right corner - 10 */
2152 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2154 SUIT_Desktop *PP = desktop();
2155 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2156 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2160 //=============================================================================
2164 //=============================================================================
2165 static int isStudyLocked(_PTR(Study) theStudy){
2166 return theStudy->GetProperties()->IsLocked();
2169 static bool checkLock(_PTR(Study) theStudy) {
2170 if (isStudyLocked(theStudy)) {
2171 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2172 QObject::tr("WRN_WARNING"),
2173 QObject::tr("WRN_STUDY_LOCKED") );
2179 //=======================================================================
2180 //function : CheckActiveStudyLocked
2182 //=======================================================================
2184 bool SMESHGUI::isActiveStudyLocked()
2186 _PTR(Study) aStudy = activeStudy()->studyDS();
2187 return checkLock( aStudy );
2190 //=============================================================================
2194 //=============================================================================
2195 bool SMESHGUI::OnGUIEvent( int theCommandID )
2197 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2201 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2202 SUIT_ResourceMgr* mgr = resourceMgr();
2206 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2207 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2210 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2211 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2213 //QAction* act = action( theCommandID );
2215 switch (theCommandID) {
2217 if(checkLock(aStudy)) break;
2229 if(checkLock(aStudy)) break;
2230 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2234 case 150: //MED FILE INFORMATION
2236 SALOME_ListIO selected;
2237 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2239 aSel->selectedObjects( selected );
2240 if( selected.Extent() )
2242 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2243 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2244 if ( !aMesh->_is_nil() )
2246 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2253 case 122: // EXPORT MED
2268 ::ExportMeshToFile(theCommandID);
2272 case 200: // SCALAR BAR
2274 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2275 SALOME_ListIO selected;
2277 aSel->selectedObjects( selected );
2279 if( selected.Extent() ) {
2280 Handle(SALOME_InteractiveObject) anIO = selected.First();
2281 if( anIO->hasEntry() ) {
2282 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2283 anActor->SetControlMode( SMESH_Actor::eNone );
2284 #ifndef DISABLE_PLOT2DVIEWER
2285 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2294 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2299 // dump control distribution data to the text file
2300 ::SaveDistribution();
2306 // show/ distribution
2307 ::ShowDistribution();
2311 #ifndef DISABLE_PLOT2DVIEWER
2314 // plot distribution
2315 ::PlotDistribution();
2326 ::DisableAutoColor();
2329 case 1134: // Clipping
2330 case 1133: // Tranparency
2331 case 1132: // Display preferences (colors, shrink size, line width, ...)
2338 ::SetDisplayMode(theCommandID, myMarkerMap);
2341 //2D quadratic representation
2344 ::SetDisplayMode(theCommandID, myMarkerMap);
2348 case 216: // 0D elements
2351 case 219: // Volumes
2352 case 220: // All Entity
2354 ::SetDisplayEntity(theCommandID);
2357 case 221: // Orientation of faces
2359 LightApp_SelectionMgr* mgr = selectionMgr();
2360 SALOME_ListIO selected; mgr->selectedObjects( selected );
2362 SALOME_ListIteratorOfListIO it(selected);
2363 for( ; it.More(); it.Next()) {
2364 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2365 if(anIObject->hasEntry()) {
2366 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2367 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2376 if(checkLock(aStudy)) break;
2378 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2381 SMESH::UpdateView();
2383 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2384 SMESH::OnVisuException();
2386 catch (...) { // PAL16774 (Crash after display of many groups)
2387 SMESH::OnVisuException();
2391 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2392 aSel->selectedObjects( l );
2393 aSel->setSelectedObjects( l );
2398 case 301: // DISPLAY
2399 case 302: // DISPLAY ONLY
2401 SMESH::EDisplaing anAction;
2402 switch (theCommandID) {
2403 case 300: anAction = SMESH::eErase; break;
2404 case 301: anAction = SMESH::eDisplay; break;
2405 case 302: anAction = SMESH::eDisplayOnly; break;
2408 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2409 SALOME_ListIO sel_objects, to_process;
2411 aSel->selectedObjects( sel_objects );
2413 if( theCommandID==302 )
2415 MESSAGE("anAction = SMESH::eDisplayOnly");
2416 startOperation( myEraseAll );
2419 extractContainers( sel_objects, to_process );
2422 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2426 SALOME_ListIteratorOfListIO It( to_process );
2427 for ( ; It.More(); It.Next()) {
2429 Handle(SALOME_InteractiveObject) IOS = It.Value();
2430 if (IOS->hasEntry()) {
2432 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2433 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2434 break; // PAL16774 (Crash after display of many groups)
2436 if (anAction == SMESH::eDisplayOnly)
2438 MESSAGE("anAction = SMESH::eDisplayOnly");
2439 anAction = SMESH::eDisplay;
2445 // PAL13338 + PAL15161 -->
2446 if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2447 MESSAGE("anAction = SMESH::eDisplayOnly");
2448 SMESH::UpdateView();
2449 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2451 // PAL13338 + PAL15161 <--
2453 catch (...) { // PAL16774 (Crash after display of many groups)
2454 SMESH::OnVisuException();
2457 if (anAction == SMESH::eErase) {
2458 MESSAGE("anAction == SMESH::eErase");
2460 aSel->setSelectedObjects( l1 );
2463 aSel->setSelectedObjects( to_process );
2470 if(checkLock(aStudy)) break;
2473 EmitSignalDeactivateDialog();
2475 ( new SMESHGUI_NodesDlg( this ) )->show();
2478 SUIT_MessageBox::warning(desktop(),
2479 tr("SMESH_WRN_WARNING"),
2480 tr("SMESH_WRN_VIEWER_VTK"));
2485 case 2151: // FILTER
2489 EmitSignalDeactivateDialog();
2490 ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2495 case 701: // COMPUTE MESH
2496 case 711: // PRECOMPUTE MESH
2497 case 712: // EVALUATE MESH
2498 case 713: // MESH ORDER
2499 case 702: // Create mesh
2500 case 703: // Create sub-mesh
2501 case 704: // Edit mesh/sub-mesh
2502 startOperation( theCommandID );
2504 case 705: // copy mesh
2506 if (checkLock(aStudy)) break;
2507 EmitSignalDeactivateDialog();
2508 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2511 case 710: // Build compound mesh
2513 if (checkLock(aStudy)) break;
2514 EmitSignalDeactivateDialog();
2515 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2519 case 407: // DIAGONAL INVERSION
2520 case 408: // Delete diagonal
2524 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2525 tr( "NOT_A_VTK_VIEWER" ) );
2529 if ( checkLock( aStudy ) )
2532 /*Standard_Boolean aRes;
2533 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2534 if ( aMesh->_is_nil() )
2536 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2537 tr( "SMESH_BAD_SELECTION" ) );
2541 EmitSignalDeactivateDialog();
2542 if ( theCommandID == 407 )
2543 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2545 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2548 case 409: // Change orientation
2549 case 410: // Union of triangles
2550 case 411: // Cutting of quadrangles
2551 case 419: // Splitting volumes into tetrahedra
2555 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2556 tr( "NOT_A_VTK_VIEWER" ) );
2560 if ( checkLock( aStudy ) )
2563 EmitSignalDeactivateDialog();
2564 SMESHGUI_MultiEditDlg* aDlg = NULL;
2565 if ( theCommandID == 409 )
2566 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2567 else if ( theCommandID == 410 )
2568 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2569 else if ( theCommandID == 419 )
2570 aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2572 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2577 case 412: // Smoothing
2579 if(checkLock(aStudy)) break;
2581 EmitSignalDeactivateDialog();
2582 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2585 SUIT_MessageBox::warning(desktop(),
2586 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2590 case 413: // Extrusion
2592 if (checkLock(aStudy)) break;
2594 EmitSignalDeactivateDialog();
2595 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2597 SUIT_MessageBox::warning(desktop(),
2598 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2602 case 414: // Revolution
2604 if(checkLock(aStudy)) break;
2606 EmitSignalDeactivateDialog();
2607 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2610 SUIT_MessageBox::warning(desktop(),
2611 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2615 case 415: // Pattern mapping
2617 if ( checkLock( aStudy ) )
2621 EmitSignalDeactivateDialog();
2622 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2625 SUIT_MessageBox::warning(desktop(),
2626 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2630 case 416: // Extrusion along a path
2632 if (checkLock(aStudy)) break;
2634 EmitSignalDeactivateDialog();
2635 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2637 SUIT_MessageBox::warning(desktop(),
2638 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2642 case 417: // Convert mesh to quadratic
2643 case 418: // create 2D mesh from 3D
2644 case 420: // Reorient faces
2645 case 806: // CREATE GEO GROUP
2647 startOperation( theCommandID );
2650 case 801: // CREATE GROUP
2654 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2655 tr( "NOT_A_VTK_VIEWER" ) );
2659 if(checkLock(aStudy)) break;
2660 EmitSignalDeactivateDialog();
2661 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2663 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2664 SALOME_ListIO selected;
2666 aSel->selectedObjects( selected );
2668 int nbSel = selected.Extent();
2670 // check if mesh is selected
2671 aMesh = SMESH::GetMeshByIO( selected.First() );
2673 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2678 case 802: // CONSTRUCT GROUP
2682 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2683 tr( "NOT_A_VTK_VIEWER" ) );
2687 if(checkLock(aStudy)) break;
2688 EmitSignalDeactivateDialog();
2690 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2691 SALOME_ListIO selected;
2693 aSel->selectedObjects( selected );
2695 int nbSel = selected.Extent();
2697 // check if submesh is selected
2698 Handle(SALOME_InteractiveObject) IObject = selected.First();
2699 if (IObject->hasEntry()) {
2700 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2702 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2703 if (!aSubMesh->_is_nil()) {
2705 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2706 // get submesh elements list by types
2707 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2708 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2709 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2710 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2711 // create group for each type o elements
2712 QString aName = IObject->getName();
2713 QStringList anEntryList;
2714 if (aNodes->length() > 0) {
2715 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2716 aGroup->Add(aNodes.inout());
2717 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2718 anEntryList.append( aSObject->GetID().c_str() );
2720 if (aEdges->length() > 0) {
2721 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2722 aGroup->Add(aEdges.inout());
2723 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2724 anEntryList.append( aSObject->GetID().c_str() );
2726 if (aFaces->length() > 0) {
2727 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2728 aGroup->Add(aFaces.inout());
2729 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2730 anEntryList.append( aSObject->GetID().c_str() );
2732 if (aVolumes->length() > 0) {
2733 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2734 aGroup->Add(aVolumes.inout());
2735 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2736 anEntryList.append( aSObject->GetID().c_str() );
2739 anApp->browseObjects( anEntryList );
2741 catch(const SALOME::SALOME_Exception & S_ex){
2742 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2749 SUIT_MessageBox::warning(desktop(),
2750 tr("SMESH_WRN_WARNING"),
2751 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2756 case 803: // EDIT GROUP
2760 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2761 tr( "NOT_A_VTK_VIEWER" ) );
2765 if(checkLock(aStudy)) break;
2766 EmitSignalDeactivateDialog();
2768 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2769 SALOME_ListIO selected;
2771 aSel->selectedObjects( selected );
2773 SALOME_ListIteratorOfListIO It (selected);
2774 int nbSelectedGroups = 0;
2775 for ( ; It.More(); It.Next() )
2777 SMESH::SMESH_GroupBase_var aGroup =
2778 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2779 if (!aGroup->_is_nil()) {
2781 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2785 if (nbSelectedGroups == 0)
2787 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2793 case 804: // Add elements to group
2795 if(checkLock(aStudy)) break;
2796 if (myState == 800) {
2797 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2798 if (aDlg) aDlg->onAdd();
2803 case 805: // Remove elements from group
2805 if(checkLock(aStudy)) break;
2806 if (myState == 800) {
2807 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2808 if (aDlg) aDlg->onRemove();
2813 case 815: // Edit GEOM GROUP as standalone
2817 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2818 tr( "NOT_A_VTK_VIEWER" ) );
2822 if(checkLock(aStudy)) break;
2823 EmitSignalDeactivateDialog();
2825 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2826 SALOME_ListIO selected;
2828 aSel->selectedObjects( selected );
2830 SALOME_ListIteratorOfListIO It (selected);
2831 for ( ; It.More(); It.Next() )
2833 SMESH::SMESH_GroupOnGeom_var aGroup =
2834 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2835 if (!aGroup->_is_nil()) {
2836 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2841 SMESH::SMESH_GroupOnFilter_var aGroup =
2842 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2843 if (!aGroup->_is_nil()) {
2844 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2852 case 810: // Union Groups
2853 case 811: // Intersect groups
2854 case 812: // Cut groups
2858 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2859 tr( "NOT_A_VTK_VIEWER" ) );
2863 if ( checkLock( aStudy ) )
2866 EmitSignalDeactivateDialog();
2868 SMESHGUI_GroupOpDlg* aDlg = 0;
2869 if ( theCommandID == 810 )
2870 aDlg = new SMESHGUI_UnionGroupsDlg( this );
2871 else if ( theCommandID == 811 )
2872 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2874 aDlg = new SMESHGUI_CutGroupsDlg( this );
2881 case 814: // Create groups of entities from existing groups of superior dimensions
2883 if ( checkLock( aStudy ) )
2886 EmitSignalDeactivateDialog();
2887 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2893 case 813: // Delete groups with their contents
2897 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2898 tr( "NOT_A_VTK_VIEWER" ) );
2902 if ( checkLock( aStudy ) )
2905 EmitSignalDeactivateDialog();
2907 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2911 case 900: // MESH INFOS
2912 case 903: // WHAT IS
2914 int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2915 EmitSignalDeactivateDialog();
2916 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2917 SALOME_ListIO selected;
2919 aSel->selectedObjects( selected );
2921 if ( selected.Extent() > 1 ) { // a dlg for each IO
2922 SALOME_ListIteratorOfListIO It( selected );
2923 for ( ; It.More(); It.Next() ) {
2924 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2925 dlg->showInfo( It.Value() );
2930 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2936 case 904: // FIND ELEM
2938 startOperation( theCommandID );
2942 case 1100: // EDIT HYPOTHESIS
2944 if(checkLock(aStudy)) break;
2946 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2947 SALOME_ListIO selected;
2949 aSel->selectedObjects( selected );
2951 int nbSel = selected.Extent();
2954 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2955 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
2957 /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
2958 /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects */
2959 /* Warning : however by internal mechanism all subMeshes icons are changed ! */
2960 if ( !aHypothesis->_is_nil() )
2963 //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2964 SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2966 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
2976 case 1102: // REMOVE HYPOTHESIS / ALGORITHMS
2978 if(checkLock(aStudy)) break;
2979 SUIT_OverrideCursor wc;
2981 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2982 SALOME_ListIO selected;
2984 aSel->selectedObjects( selected, QString::null, false );
2986 SALOME_ListIteratorOfListIO It(selected);
2987 for (int i = 0; It.More(); It.Next(), i++) {
2988 Handle(SALOME_InteractiveObject) IObject = It.Value();
2989 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2992 aSel->setSelectedObjects( l1 );
2998 case 4009: // ELEM0D
3000 case 4021: // TRIANGLE
3002 case 4023: // POLYGON
3006 case 4134: // PYRAMID
3007 case 4135: // OCTA12
3009 if(checkLock(aStudy)) break;
3011 EmitSignalDeactivateDialog();
3012 SMDSAbs_EntityType type = SMDSEntity_Edge;
3013 switch (theCommandID) {
3014 case 4008: type = SMDSEntity_Ball; break;
3015 case 4009: type = SMDSEntity_0D; break;
3016 case 4021: type = SMDSEntity_Triangle; break;
3017 case 4022: type = SMDSEntity_Quadrangle; break;
3018 case 4031: type = SMDSEntity_Tetra; break;
3019 case 4023: type = SMDSEntity_Polygon; break;
3020 case 4032: type = SMDSEntity_Hexa; break;
3021 case 4133: type = SMDSEntity_Penta; break;
3022 case 4134: type = SMDSEntity_Pyramid; break;
3023 case 4135: type = SMDSEntity_Hexagonal_Prism; break;
3026 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3029 SUIT_MessageBox::warning(desktop(),
3030 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3034 case 4033: // POLYHEDRON
3036 if(checkLock(aStudy)) break;
3038 EmitSignalDeactivateDialog();
3039 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3042 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3043 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3047 case 4034: // QUADRATIC EDGE
3048 case 4035: // QUADRATIC TRIANGLE
3049 case 4036: // QUADRATIC QUADRANGLE
3050 case 4136: // BIQUADRATIC QUADRANGLE
3051 case 4037: // QUADRATIC TETRAHEDRON
3052 case 4038: // QUADRATIC PYRAMID
3053 case 4039: // QUADRATIC PENTAHEDRON
3054 case 4040: // QUADRATIC HEXAHEDRON
3055 case 4140: // TRIQUADRATIC HEXAHEDRON
3057 if(checkLock(aStudy)) break;
3059 EmitSignalDeactivateDialog();
3060 SMDSAbs_EntityType type = SMDSEntity_Last;
3062 switch (theCommandID) {
3064 type = SMDSEntity_Quad_Edge; break;
3066 type = SMDSEntity_Quad_Triangle; break;
3068 type = SMDSEntity_Quad_Quadrangle; break;
3070 type = SMDSEntity_BiQuad_Quadrangle; break;
3072 type = SMDSEntity_Quad_Tetra; break;
3074 type = SMDSEntity_Quad_Pyramid; break;
3076 type = SMDSEntity_Quad_Penta; break;
3078 type = SMDSEntity_Quad_Hexa; break;
3080 type = SMDSEntity_TriQuad_Hexa; break;
3083 if ( type != SMDSEntity_Last )
3084 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3087 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3088 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3092 case 4041: // REMOVES NODES
3094 if(checkLock(aStudy)) break;
3096 EmitSignalDeactivateDialog();
3097 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3100 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3101 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3105 case 4042: // REMOVES ELEMENTS
3107 if(checkLock(aStudy)) break;
3109 EmitSignalDeactivateDialog();
3110 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3114 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3115 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3119 case 4043: { // CLEAR_MESH
3121 if(checkLock(aStudy)) break;
3123 SALOME_ListIO selected;
3124 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3125 aSel->selectedObjects( selected );
3127 SUIT_OverrideCursor wc;
3128 SALOME_ListIteratorOfListIO It (selected);
3129 for ( ; It.More(); It.Next() )
3131 Handle(SALOME_InteractiveObject) IOS = It.Value();
3132 SMESH::SMESH_Mesh_var aMesh =
3133 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3134 if ( aMesh->_is_nil()) continue;
3136 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3138 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3139 SMESH::ModifiedMesh( aMeshSObj, false, true);
3140 // hide groups and submeshes
3141 _PTR(ChildIterator) anIter =
3142 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3143 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3145 _PTR(SObject) so = anIter->Value();
3146 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3149 catch (const SALOME::SALOME_Exception& S_ex){
3151 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3155 SMESH::UpdateView();
3159 case 4044: // REMOVE ORPHAN NODES
3161 if(checkLock(aStudy)) break;
3162 SALOME_ListIO selected;
3163 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3164 aSel->selectedObjects( selected );
3165 if ( selected.Extent() == 1 ) {
3166 Handle(SALOME_InteractiveObject) anIO = selected.First();
3167 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3168 if ( !aMesh->_is_nil() ) {
3169 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3170 tr( "SMESH_WARNING" ),
3171 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3172 SUIT_MessageBox::Yes |
3173 SUIT_MessageBox::No,
3174 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3177 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3178 int removed = aMeshEditor->RemoveOrphanNodes();
3179 SUIT_MessageBox::information(SMESHGUI::desktop(),
3180 tr("SMESH_INFORMATION"),
3181 tr("NB_NODES_REMOVED").arg(removed));
3182 if ( removed > 0 ) {
3183 SMESH::UpdateView();
3184 SMESHGUI::Modified();
3187 catch (const SALOME::SALOME_Exception& S_ex) {
3188 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3197 case 4051: // RENUMBERING NODES
3199 if(checkLock(aStudy)) break;
3201 EmitSignalDeactivateDialog();
3202 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3206 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3207 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3211 case 4052: // RENUMBERING ELEMENTS
3213 if(checkLock(aStudy)) break;
3215 EmitSignalDeactivateDialog();
3216 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3220 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3221 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3225 case 4061: // TRANSLATION
3227 if(checkLock(aStudy)) break;
3229 EmitSignalDeactivateDialog();
3230 ( new SMESHGUI_TranslationDlg( this ) )->show();
3233 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3234 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3238 case 4062: // ROTATION
3240 if(checkLock(aStudy)) break;
3242 EmitSignalDeactivateDialog();
3243 ( new SMESHGUI_RotationDlg( this ) )->show();
3246 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3247 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3251 case 4063: // SYMMETRY
3253 if(checkLock(aStudy)) break;
3255 EmitSignalDeactivateDialog();
3256 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3259 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3260 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3264 case 4064: // SEWING
3266 if(checkLock(aStudy)) break;
3268 EmitSignalDeactivateDialog();
3269 ( new SMESHGUI_SewingDlg( this ) )->show();
3272 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3273 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3277 case 4065: // MERGE NODES
3279 if(checkLock(aStudy)) break;
3281 EmitSignalDeactivateDialog();
3282 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3285 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3286 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3290 case 4066: // MERGE EQUAL ELEMENTS
3292 if (checkLock(aStudy)) break;
3294 EmitSignalDeactivateDialog();
3295 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3297 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3298 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3303 case 4067: // MAKE MESH PASS THROUGH POINT
3304 startOperation( 4067 );
3309 if(checkLock(aStudy)) break;
3311 EmitSignalDeactivateDialog();
3312 ( new SMESHGUI_ScaleDlg( this ) )->show();
3315 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3316 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3321 case 4069: // DUPLICATE NODES
3323 if(checkLock(aStudy)) break;
3325 EmitSignalDeactivateDialog();
3326 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3329 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3330 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3335 case 4070: // 0D_ON_ALL_NODES
3336 startOperation( 4070 );
3339 case 5105: // Library of selection filters
3341 static QList<int> aTypes;
3342 if ( aTypes.isEmpty() )
3344 aTypes.append( SMESH::NODE );
3345 aTypes.append( SMESH::EDGE );
3346 aTypes.append( SMESH::FACE );
3347 aTypes.append( SMESH::VOLUME );
3349 if (!myFilterLibraryDlg)
3350 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3351 else if (myFilterLibraryDlg->isHidden())
3352 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3353 myFilterLibraryDlg->raise();
3357 case 6017: // CONTROLS
3385 LightApp_SelectionMgr* mgr = selectionMgr();
3386 SALOME_ListIO selected; mgr->selectedObjects( selected );
3388 if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3389 _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3391 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3392 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
3393 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3394 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
3395 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3396 ::Control( theCommandID );
3401 SUIT_MessageBox::warning(desktop(),
3402 tr( "SMESH_WRN_WARNING" ),
3403 tr( "SMESH_BAD_SELECTION" ) );
3407 SUIT_MessageBox::warning(desktop(),
3408 tr( "SMESH_WRN_WARNING" ),
3409 tr( "NOT_A_VTK_VIEWER" ) );
3414 LightApp_SelectionMgr* mgr = selectionMgr();
3415 SALOME_ListIO selected; mgr->selectedObjects( selected );
3417 SALOME_ListIteratorOfListIO it(selected);
3418 for( ; it.More(); it.Next()) {
3419 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3420 if(anIObject->hasEntry()) {
3421 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3422 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3430 LightApp_SelectionMgr* mgr = selectionMgr();
3431 SALOME_ListIO selected; mgr->selectedObjects( selected );
3433 SALOME_ListIteratorOfListIO it(selected);
3434 for( ; it.More(); it.Next()) {
3435 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3436 if(anIObject->hasEntry())
3437 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3438 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3446 int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3447 EmitSignalDeactivateDialog();
3448 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3454 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3455 //updateObjBrowser();
3459 //=============================================================================
3463 //=============================================================================
3464 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3469 //=============================================================================
3473 //=============================================================================
3474 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3479 //=============================================================================
3483 //=============================================================================
3484 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3489 //=============================================================================
3490 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3491 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3493 //=============================================================================
3494 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3495 SUIT_ViewWindow* wnd )
3497 if(theIO->hasEntry()){
3498 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3499 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3503 //=======================================================================
3504 // function : createSMESHAction
3506 //=======================================================================
3507 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3508 const int key, const bool toggle, const QString& shortcutAction )
3511 QWidget* parent = application()->desktop();
3512 SUIT_ResourceMgr* resMgr = resourceMgr();
3514 if ( !icon_id.isEmpty() )
3515 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3517 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3518 if ( !pix.isNull() )
3519 icon = QIcon( pix );
3521 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3522 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3523 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3525 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3526 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3529 //=======================================================================
3530 // function : createPopupItem
3532 //=======================================================================
3533 void SMESHGUI::createPopupItem( const int id,
3534 const QString& clients,
3535 const QString& types,
3536 const QString& theRule,
3539 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3540 popupMgr()->insert( action( id ), pId, 0 );
3542 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3543 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3544 QString rule = "(%1) and (%2) and (%3)";
3545 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3546 if( clients.isEmpty() )
3547 rule = rule.arg( QString( "true" ) );
3549 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3550 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3553 bool cont = myRules.contains( id );
3555 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3557 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3558 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3561 //=======================================================================
3562 // function : initialize
3564 //=======================================================================
3565 void SMESHGUI::initialize( CAM_Application* app )
3567 SalomeApp_Module::initialize( app );
3569 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3571 /* Automatic Update flag */
3572 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3574 // ----- create actions --------------
3576 //createSMESHAction( 111, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3577 createSMESHAction( 112, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3578 createSMESHAction( 113, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3579 createSMESHAction( 114, "NUM" );
3580 createSMESHAction( 115, "IMPORT_STL" );
3581 createSMESHAction( 116, "IMPORT_CGNS" );
3582 createSMESHAction( 117, "IMPORT_SAUV" );
3583 createSMESHAction( 118, "IMPORT_GMF" );
3584 createSMESHAction( 121, "DAT" );
3585 createSMESHAction( 122, "MED" );
3586 createSMESHAction( 123, "UNV" );
3587 createSMESHAction( 140, "STL" );
3588 createSMESHAction( 142, "CGNS");
3589 createSMESHAction( 144, "SAUV");
3590 createSMESHAction( 146, "GMF" );
3591 createSMESHAction( 124, "DAT" );
3592 createSMESHAction( 125, "MED" );
3593 createSMESHAction( 126, "UNV" );
3594 createSMESHAction( 141, "STL" );
3595 createSMESHAction( 143, "CGNS");
3596 createSMESHAction( 145, "SAUV");
3597 createSMESHAction( 147, "GMF" );
3598 createSMESHAction( 150, "FILE_INFO" );
3599 createSMESHAction( 33, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3600 createSMESHAction( 5105, "SEL_FILTER_LIB" );
3601 createSMESHAction( 701, "COMPUTE", "ICON_COMPUTE" );
3602 createSMESHAction( 702, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3603 createSMESHAction( 703, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3604 createSMESHAction( 704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3605 createSMESHAction( 705, "COPY_MESH", "ICON_COPY_MESH" );
3606 createSMESHAction( 710, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3607 createSMESHAction( 711, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3608 createSMESHAction( 712, "EVALUATE", "ICON_COMPUTE" );
3609 createSMESHAction( 713, "MESH_ORDER", "ICON_COMPUTE" );
3610 createSMESHAction( 806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3611 createSMESHAction( 801, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3612 createSMESHAction( 802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3613 createSMESHAction( 803, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3614 createSMESHAction( 815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3615 createSMESHAction( 804, "ADD" );
3616 createSMESHAction( 805, "REMOVE" );
3617 createSMESHAction( 810, "UN_GROUP", "ICON_UNION" );
3618 createSMESHAction( 811, "INT_GROUP", "ICON_INTERSECT" );
3619 createSMESHAction( 812, "CUT_GROUP", "ICON_CUT" );
3620 createSMESHAction( 814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3621 createSMESHAction( 813, "DEL_GROUP", "ICON_DEL_GROUP" );
3622 createSMESHAction( 900, "ADV_INFO", "ICON_ADV_INFO" );
3623 //createSMESHAction( 902, "STD_INFO", "ICON_STD_INFO" );
3624 //createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3625 createSMESHAction( 904, "FIND_ELEM", "ICON_FIND_ELEM" );
3626 createSMESHAction( 6001, "LENGTH", "ICON_LENGTH", 0, true );
3627 createSMESHAction( 6002, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3628 createSMESHAction( 6021, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3629 createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3630 createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3631 createSMESHAction( 6024, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3632 createSMESHAction( 6025, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3633 createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3634 createSMESHAction( 6027, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3635 createSMESHAction( 6028, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3636 createSMESHAction( 6029, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3637 createSMESHAction( 6030, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3638 createSMESHAction( 6031, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3639 createSMESHAction( 6003, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3640 createSMESHAction( 6004, "CONNECTION", "ICON_CONNECTION", 0, true );
3641 createSMESHAction( 6005, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3642 createSMESHAction( 6011, "AREA", "ICON_AREA", 0, true );
3643 createSMESHAction( 6012, "TAPER", "ICON_TAPER", 0, true );
3644 createSMESHAction( 6013, "ASPECT", "ICON_ASPECT", 0, true );
3645 createSMESHAction( 6014, "MIN_ANG", "ICON_ANGLE", 0, true );
3646 createSMESHAction( 6015, "WARP", "ICON_WARP", 0, true );
3647 createSMESHAction( 6016, "SKEW", "ICON_SKEW", 0, true );
3648 createSMESHAction( 6017, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3649 createSMESHAction( 6018, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3650 createSMESHAction( 6019, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3651 createSMESHAction( 6009, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3652 createSMESHAction( 4000, "NODE", "ICON_DLG_NODE" );
3653 createSMESHAction( 4009, "ELEM0D", "ICON_DLG_ELEM0D" );
3654 createSMESHAction( 4008, "BALL", "ICON_DLG_BALL" );
3655 createSMESHAction( 4010, "EDGE", "ICON_DLG_EDGE" );
3656 createSMESHAction( 4021, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3657 createSMESHAction( 4022, "QUAD", "ICON_DLG_QUADRANGLE" );
3658 createSMESHAction( 4023, "POLYGON", "ICON_DLG_POLYGON" );
3659 createSMESHAction( 4031, "TETRA", "ICON_DLG_TETRAS" );
3660 createSMESHAction( 4032, "HEXA", "ICON_DLG_HEXAS" );
3661 createSMESHAction( 4133, "PENTA", "ICON_DLG_PENTA" );
3662 createSMESHAction( 4134, "PYRAMID", "ICON_DLG_PYRAMID" );
3663 createSMESHAction( 4135, "OCTA", "ICON_DLG_OCTA" );
3664 createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3665 createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3666 createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3667 createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3668 createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3669 createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3670 createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3671 createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3672 createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3673 createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3674 createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3675 createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3676 createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3677 createSMESHAction( 4043, "CLEAR_MESH" , "ICON_CLEAR_MESH" );
3678 createSMESHAction( 4051, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3679 createSMESHAction( 4052, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3680 createSMESHAction( 4061, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3681 createSMESHAction( 4062, "ROT", "ICON_DLG_MESH_ROTATION" );
3682 createSMESHAction( 4063, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3683 createSMESHAction( 4064, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3684 createSMESHAction( 4065, "MERGE", "ICON_SMESH_MERGE_NODES" );
3685 createSMESHAction( 4066, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3686 createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3687 createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" );
3688 createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3689 createSMESHAction( 4070, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3690 createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" );
3691 createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" );
3692 createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3693 createSMESHAction( 410, "UNION", "ICON_UNIONTRI" );
3694 createSMESHAction( 411, "CUT", "ICON_CUTQUAD" );
3695 createSMESHAction( 412, "SMOOTH", "ICON_DLG_SMOOTHING" );
3696 createSMESHAction( 413, "EXTRUSION", "ICON_EXTRUSION" );
3697 createSMESHAction( 414, "REVOLUTION", "ICON_REVOLUTION" );
3698 createSMESHAction( 415, "MAP", "ICON_MAP" );
3699 createSMESHAction( 416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3700 createSMESHAction( 417, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3701 createSMESHAction( 418, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3702 createSMESHAction( 419, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3703 createSMESHAction( 420, "REORIENT_2D", "ICON_REORIENT_2D" );
3704 createSMESHAction( 200, "RESET" );
3705 createSMESHAction( 201, "SCALAR_BAR_PROP" );
3706 createSMESHAction( 2021, "SAVE_DISTRIBUTION" );
3707 createSMESHAction( 2022, "SHOW_DISTRIBUTION","",0, true );
3708 #ifndef DISABLE_PLOT2DVIEWER
3709 createSMESHAction( 2023, "PLOT_DISTRIBUTION" );
3711 createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true );
3712 createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true );
3713 createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true );
3714 createSMESHAction( 214, "UPDATE", "ICON_UPDATE" );
3715 createSMESHAction( 215, "NODES", "ICON_POINTS", 0, true );
3716 createSMESHAction( 222, "BALLS", "ICON_DLG_BALL", 0, true );
3717 createSMESHAction( 216, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3718 createSMESHAction( 217, "EDGES", "ICON_DLG_EDGE", 0, true );
3719 createSMESHAction( 218, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3720 createSMESHAction( 219, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3721 createSMESHAction( 220, "ALL" );
3722 createSMESHAction( 221, "FACE_ORIENTATION", "", 0, true );
3724 createSMESHAction( 231, "LINE_REPRESENTATION", "", 0, true );
3725 createSMESHAction( 232, "ARC_REPRESENTATION", "", 0, true );
3727 createSMESHAction( 1100, "EDIT_HYPO" );
3728 createSMESHAction( 1102, "UNASSIGN" );
3729 createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3730 createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3731 createSMESHAction( 1131, "DISPMODE" );
3732 createSMESHAction( 1132, "COLORS" );
3733 createSMESHAction( 1133, "TRANSP" );
3734 createSMESHAction( 1134, "CLIP" );
3735 createSMESHAction( 1135, "DISP_ENT" );
3736 createSMESHAction( 1136, "AUTO_COLOR" );
3737 createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3738 createSMESHAction( 2000, "CTRL" );
3740 createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3741 createSMESHAction( 502, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3743 createSMESHAction( 300, "HIDE" );
3744 createSMESHAction( 301, "SHOW" );
3745 createSMESHAction( 302, "DISPLAY_ONLY" );
3747 // ----- create menu --------------
3748 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3749 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3750 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3751 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3752 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3753 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3754 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3755 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3757 createMenu( separator(), fileId );
3759 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3760 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3761 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3762 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3763 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3764 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3765 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3766 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3767 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3768 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3770 //createMenu( 111, importId, -1 );
3771 createMenu( 112, importId, -1 );
3772 createMenu( 113, importId, -1 );
3773 createMenu( 115, importId, -1 );
3775 createMenu( 116, importId, -1 );
3777 createMenu( 117, importId, -1 );
3778 createMenu( 118, importId, -1 );
3779 createMenu( 121, exportId, -1 );
3780 createMenu( 122, exportId, -1 );
3781 createMenu( 123, exportId, -1 );
3782 createMenu( 140, exportId, -1 ); // export to STL
3784 createMenu( 142, exportId, -1 ); // export to CGNS
3786 createMenu( 144, exportId, -1 ); // export to SAUV
3787 createMenu( 146, exportId, -1 ); // export to GMF
3788 createMenu( separator(), fileId, 10 );
3790 createMenu( 33, editId, -1 );
3792 createMenu( 5105, toolsId, -1 );
3794 createMenu( 702, meshId, -1 ); // "Mesh" menu
3795 createMenu( 703, meshId, -1 );
3796 createMenu( 704, meshId, -1 );
3797 createMenu( 710, meshId, -1 );
3798 createMenu( 705, meshId, -1 );
3799 createMenu( separator(), meshId, -1 );
3800 createMenu( 701, meshId, -1 );
3801 createMenu( 711, meshId, -1 );
3802 createMenu( 712, meshId, -1 );
3803 createMenu( 713, meshId, -1 );
3804 createMenu( separator(), meshId, -1 );
3805 createMenu( 801, meshId, -1 );
3806 createMenu( 806, meshId, -1 );
3807 createMenu( 802, meshId, -1 );
3808 createMenu( 803, meshId, -1 );
3809 createMenu( 815, meshId, -1 );
3810 createMenu( separator(), meshId, -1 );
3811 createMenu( 810, meshId, -1 );
3812 createMenu( 811, meshId, -1 );
3813 createMenu( 812, meshId, -1 );
3814 createMenu( separator(), meshId, -1 );
3815 createMenu( 814, meshId, -1 );
3816 createMenu( separator(), meshId, -1 );
3817 createMenu( 900, meshId, -1 );
3818 //createMenu( 902, meshId, -1 );
3819 //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3820 createMenu( 904, meshId, -1 );
3821 createMenu( separator(), meshId, -1 );
3823 createMenu( 6005, nodeId, -1 );
3824 createMenu( 6028, nodeId, -1 );
3825 createMenu( 6002, edgeId, -1 );
3826 createMenu( 6003, edgeId, -1 );
3827 createMenu( 6001, edgeId, -1 );
3828 createMenu( 6004, edgeId, -1 );
3829 createMenu( 6029, edgeId, -1 );
3830 createMenu( 6021, faceId, -1 );
3831 createMenu( 6025, faceId, -1 );
3832 createMenu( 6027, faceId, -1 );
3833 createMenu( 6018, faceId, -1 );
3834 createMenu( 6019, faceId, -1 );
3835 createMenu( 6011, faceId, -1 );
3836 createMenu( 6012, faceId, -1 );
3837 createMenu( 6013, faceId, -1 );
3838 createMenu( 6014, faceId, -1 );
3839 createMenu( 6015, faceId, -1 );
3840 createMenu( 6016, faceId, -1 );
3841 createMenu( 6022, faceId, -1 );
3842 createMenu( 6030, faceId, -1 );
3843 createMenu( 6017, volumeId, -1 );
3844 createMenu( 6009, volumeId, -1 );
3845 createMenu( 6023, volumeId, -1 );
3846 createMenu( 6024, volumeId, -1 );
3847 createMenu( 6026, volumeId, -1 );
3848 createMenu( 6031, volumeId, -1 );
3850 createMenu( 4000, addId, -1 );
3851 createMenu( 4009, addId, -1 );
3852 createMenu( 4070, addId, -1 );
3853 createMenu( 4008, addId, -1 );
3854 createMenu( 4010, addId, -1 );
3855 createMenu( 4021, addId, -1 );
3856 createMenu( 4022, addId, -1 );
3857 createMenu( 4023, addId, -1 );
3858 createMenu( 4031, addId, -1 );
3859 createMenu( 4032, addId, -1 );
3860 createMenu( 4133, addId, -1 );
3861 createMenu( 4134, addId, -1 );
3862 createMenu( 4135, addId, -1 );
3863 createMenu( 4033, addId, -1 );
3864 createMenu( separator(), addId, -1 );
3865 createMenu( 4034, addId, -1 );
3866 createMenu( 4035, addId, -1 );
3867 createMenu( 4036, addId, -1 );
3868 createMenu( 4136, addId, -1 );
3869 createMenu( 4037, addId, -1 );
3870 createMenu( 4038, addId, -1 );
3871 createMenu( 4039, addId, -1 );
3872 createMenu( 4040, addId, -1 );
3873 createMenu( 4140, addId, -1 );
3875 createMenu( 4041, removeId, -1 );
3876 createMenu( 4042, removeId, -1 );
3877 createMenu( 4044, removeId, -1 );
3878 createMenu( separator(), removeId, -1 );
3879 createMenu( 813, removeId, -1 );
3880 createMenu( separator(), removeId, -1 );
3881 createMenu( 4043, removeId, -1 );
3883 createMenu( 4051, renumId, -1 );
3884 createMenu( 4052, renumId, -1 );
3886 createMenu( 4061, transfId, -1 );
3887 createMenu( 4062, transfId, -1 );
3888 createMenu( 4063, transfId, -1 );
3889 createMenu( 4068, transfId, -1 );
3890 createMenu( 4064, transfId, -1 );
3891 createMenu( 4065, transfId, -1 );
3892 createMenu( 4066, transfId, -1 );
3893 createMenu( 4069, transfId, -1 );
3895 createMenu( 4067,modifyId, -1 );
3896 createMenu( 407, modifyId, -1 );
3897 createMenu( 408, modifyId, -1 );
3898 createMenu( 409, modifyId, -1 );
3899 createMenu( 420, modifyId, -1 );
3900 createMenu( 410, modifyId, -1 );
3901 createMenu( 411, modifyId, -1 );
3902 createMenu( 419, modifyId, -1 );
3903 createMenu( 412, modifyId, -1 );
3904 createMenu( 413, modifyId, -1 );
3905 createMenu( 416, modifyId, -1 );
3906 createMenu( 414, modifyId, -1 );
3907 createMenu( 415, modifyId, -1 );
3908 createMenu( 417, modifyId, -1 );
3909 createMenu( 418, modifyId, -1 );
3911 createMenu( 501, measureId, -1 );
3912 createMenu( 502, measureId, -1 );
3913 createMenu( 214, viewId, -1 );
3915 // ----- create toolbars --------------
3916 int meshTb = createTool( tr( "TB_MESH" ) ),
3917 ctrlTb = createTool( tr( "TB_CTRL" ) ),
3918 addRemTb = createTool( tr( "TB_ADD_REMOVE" ) ),
3919 modifyTb = createTool( tr( "TB_MODIFY" ) ),
3920 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
3922 createTool( 702, meshTb );
3923 createTool( 703, meshTb );
3924 createTool( 704, meshTb );
3925 createTool( 710, meshTb );
3926 createTool( 705, meshTb );
3927 createTool( separator(), meshTb );
3928 createTool( 701, meshTb );
3929 createTool( 711, meshTb );
3930 createTool( 712, meshTb );
3931 createTool( 713, meshTb );
3932 createTool( separator(), meshTb );
3933 createTool( 801, meshTb );
3934 createTool( 806, meshTb );
3935 createTool( 802, meshTb );
3936 createTool( 803, meshTb );
3937 //createTool( 815, meshTb );
3938 createTool( separator(), meshTb );
3939 createTool( 900, meshTb );
3940 //createTool( 902, meshTb );
3941 //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3942 createTool( 904, meshTb );
3943 createTool( separator(), meshTb );
3945 createTool( 6005, ctrlTb );
3946 createTool( 6028, ctrlTb );
3947 createTool( separator(), ctrlTb );
3948 createTool( 6002, ctrlTb );
3949 createTool( 6003, ctrlTb );
3950 createTool( 6001, ctrlTb );
3951 createTool( 6004, ctrlTb );
3952 createTool( 6029, ctrlTb );
3953 createTool( separator(), ctrlTb );
3954 createTool( 6021, ctrlTb );
3955 createTool( 6025, ctrlTb );
3956 createTool( 6027, ctrlTb );
3957 createTool( 6018, ctrlTb );
3958 createTool( 6019, ctrlTb );
3959 createTool( 6011, ctrlTb );
3960 createTool( 6012, ctrlTb );
3961 createTool( 6013, ctrlTb );
3962 createTool( 6014, ctrlTb );
3963 createTool( 6015, ctrlTb );
3964 createTool( 6016, ctrlTb );
3965 createTool( 6022, ctrlTb );
3966 createTool( 6030, ctrlTb );
3967 createTool( separator(), ctrlTb );
3968 createTool( 6017, ctrlTb );
3969 createTool( 6009, ctrlTb );
3970 createTool( 6023, ctrlTb );
3971 createTool( 6024, ctrlTb );
3972 createTool( 6026, ctrlTb );
3973 createTool( 6031, ctrlTb );
3974 createTool( separator(), ctrlTb );
3976 createTool( 4000, addRemTb );
3977 createTool( 4009, addRemTb );
3978 createTool( 4070, addRemTb );
3979 createTool( 4008, addRemTb );
3980 createTool( 4010, addRemTb );
3981 createTool( 4021, addRemTb );
3982 createTool( 4022, addRemTb );
3983 createTool( 4023, addRemTb );
3984 createTool( 4031, addRemTb );
3985 createTool( 4032, addRemTb );
3986 createTool( 4133, addRemTb );
3987 createTool( 4134, addRemTb );
3988 createTool( 4135, addRemTb );
3989 createTool( 4033, addRemTb );
3990 createTool( separator(), addRemTb );
3991 createTool( 4034, addRemTb );
3992 createTool( 4035, addRemTb );
3993 createTool( 4036, addRemTb );
3994 createTool( 4136, addRemTb );
3995 createTool( 4037, addRemTb );
3996 createTool( 4038, addRemTb );
3997 createTool( 4039, addRemTb );
3998 createTool( 4040, addRemTb );
3999 createTool( 4140, addRemTb );
4000 createTool( separator(), addRemTb );
4001 createTool( 4041, addRemTb );
4002 createTool( 4042, addRemTb );
4003 createTool( 4044, addRemTb );
4004 createTool( 4043, addRemTb );
4005 createTool( separator(), addRemTb );
4006 createTool( 4051, addRemTb );
4007 createTool( 4052, addRemTb );
4008 createTool( separator(), addRemTb );
4009 createTool( 4061, addRemTb );
4010 createTool( 4062, addRemTb );
4011 createTool( 4063, addRemTb );
4012 createTool( 4068, addRemTb );
4013 createTool( 4064, addRemTb );
4014 createTool( 4065, addRemTb );
4015 createTool( 4066, addRemTb );
4016 createTool( 4069, addRemTb );
4017 createTool( separator(), addRemTb );
4019 createTool( 4067,modifyTb );
4020 createTool( 407, modifyTb );
4021 createTool( 408, modifyTb );
4022 createTool( 409, modifyTb );
4023 createTool( 420, modifyTb );
4024 createTool( 410, modifyTb );
4025 createTool( 411, modifyTb );
4026 createTool( 419, modifyTb );
4027 createTool( 412, modifyTb );
4028 createTool( 413, modifyTb );
4029 createTool( 416, modifyTb );
4030 createTool( 414, modifyTb );
4031 createTool( 415, modifyTb );
4032 createTool( 417, modifyTb );
4033 createTool( 418, modifyTb );
4035 createTool( 214, dispModeTb );
4037 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4038 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4041 QString OB = "'ObjectBrowser'",
4042 View = "'" + SVTK_Viewer::Type() + "'",
4044 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4045 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4046 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4047 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4048 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4049 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4050 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4051 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4052 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4053 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4054 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4056 mesh_part = mesh + " " + subMesh + " " + group,
4057 mesh_group = mesh + " " + group,
4058 hyp_alg = hypo + " " + algo;
4060 // popup for object browser
4062 isInvisible("not( isVisible )"),
4063 isEmpty("numberOfNodes = 0"),
4064 isNotEmpty("numberOfNodes <> 0"),
4066 // has nodes, edges, etc in VISIBLE! actor
4067 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4068 hasElems("(count( elemTypes ) > 0)"),
4069 hasDifferentElems("(count( elemTypes ) > 1)"),
4070 hasBalls("({'BallElem'} in elemTypes)"),
4071 hasElems0d("({'Elem0d'} in elemTypes)"),
4072 hasEdges("({'Edge'} in elemTypes)"),
4073 hasFaces("({'Face'} in elemTypes)"),
4074 hasVolumes("({'Volume'} in elemTypes)");
4076 createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
4077 createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
4078 createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
4079 createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
4080 createPopupItem( 803, OB, group ); // EDIT_GROUP
4081 createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
4083 popupMgr()->insert( separator(), -1, 0 );
4084 createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
4085 createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
4086 createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
4087 createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
4088 createPopupItem( 214, OB, mesh_part ); // UPDATE
4089 createPopupItem( 900, OB, mesh_part ); // ADV_INFO
4090 createPopupItem( 904, OB, mesh_group ); // FIND_ELEM
4091 popupMgr()->insert( separator(), -1, 0 );
4092 createPopupItem( 801, OB, mesh ); // CREATE_GROUP
4093 createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
4094 createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
4095 popupMgr()->insert( separator(), -1, 0 );
4096 createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
4097 createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4098 popupMgr()->insert( separator(), -1, 0 );
4099 createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
4100 popupMgr()->insert( separator(), -1, 0 );
4101 createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
4102 createPopupItem( 418, OB, mesh + " " + group, // create 2D mesh from 3D
4104 popupMgr()->insert( separator(), -1, 0 );
4106 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4107 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4108 QString only_one_2D = only_one_non_empty + " && dim>1";
4110 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4111 createPopupItem( 125, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_MED
4112 createPopupItem( 126, OB, mesh_group, only_one_non_empty, anId ); // EXPORT_UNV
4113 createPopupItem( 141, OB, mesh_group, only_one_2D, anId ); // EXPORT_STL
4115 createPopupItem( 143, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_CGNS
4117 createPopupItem( 145, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_SAUV
4118 createPopupItem( 147, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_GMF
4119 createPopupItem( 124, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_DAT
4120 createPopupItem( 33, OB, mesh_part + " " + hyp_alg ); // DELETE
4121 createPopupItem( 813, OB, group ); // DEL_GROUP with contents
4122 popupMgr()->insert( separator(), -1, 0 );
4125 createPopupItem( 803, View, group ); // EDIT_GROUP
4126 createPopupItem( 804, View, elems ); // ADD
4127 createPopupItem( 805, View, elems ); // REMOVE
4129 popupMgr()->insert( separator(), -1, 0 );
4130 createPopupItem( 214, View, mesh_part ); // UPDATE
4131 createPopupItem( 900, View, mesh_part ); // ADV_INFO
4132 createPopupItem( 904, View, mesh ); // FIND_ELEM
4133 popupMgr()->insert( separator(), -1, 0 );
4135 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
4136 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
4137 popupMgr()->insert( separator(), -1, 0 );
4139 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4140 QString aType = QString( "%1type in {%2}" ).arg( lc );
4141 aType = aType.arg( mesh_part );
4142 QString aMeshInVTK = aClient + "&&" + aType;
4144 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4145 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4146 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4148 //-------------------------------------------------
4150 //-------------------------------------------------
4151 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4153 popupMgr()->insert( action( 9010 ), anId, -1 );
4154 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4155 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4157 popupMgr()->insert( action( 9011 ), anId, -1 );
4158 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4159 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4161 popupMgr()->insert( separator(), -1, -1 );
4163 //-------------------------------------------------
4165 //-------------------------------------------------
4166 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4168 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4169 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4170 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4172 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4173 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4174 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4176 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4177 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4178 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4180 popupMgr()->insert( separator(), anId, -1 );
4182 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4183 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4184 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4186 //-------------------------------------------------
4188 //-------------------------------------------------
4189 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4191 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4193 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4194 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4195 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4197 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4198 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4199 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4201 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4202 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4203 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4205 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4206 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4207 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4209 popupMgr()->insert( action( 222 ), anId, -1 ); // BALLS
4210 popupMgr()->setRule( action( 222 ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4211 popupMgr()->setRule( action( 222 ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4213 popupMgr()->insert( separator(), anId, -1 );
4215 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4216 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4219 //-------------------------------------------------
4220 // Representation of the 2D Quadratic elements
4221 //-------------------------------------------------
4222 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4223 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4224 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4225 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4227 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4228 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4229 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4231 //-------------------------------------------------
4232 // Orientation of faces
4233 //-------------------------------------------------
4234 popupMgr()->insert( action( 221 ), -1, -1 );
4235 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4236 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4238 //-------------------------------------------------
4240 //-------------------------------------------------
4241 popupMgr()->insert( action( 1132 ), -1, -1 );
4242 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4244 //-------------------------------------------------
4246 //-------------------------------------------------
4247 popupMgr()->insert( action( 1133 ), -1, -1 );
4248 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4250 //-------------------------------------------------
4252 //-------------------------------------------------
4254 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4255 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4256 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4257 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4259 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4261 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4262 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4264 popupMgr()->insert( separator(), anId, -1 );
4266 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4268 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4269 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4270 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4272 popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4273 popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4274 popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4276 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4278 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4279 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4280 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4282 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4283 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4284 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4286 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4287 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4288 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4290 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4291 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4292 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4293 popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4294 popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4295 popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4297 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4299 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4300 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4301 QtxPopupMgr::VisibleRule );
4302 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4304 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4305 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4306 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4308 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4309 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4310 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4312 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4313 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4314 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4316 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4317 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4318 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4320 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4321 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4322 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4324 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4325 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4326 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4328 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4329 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4330 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4332 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4333 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4334 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4336 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4337 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4338 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4340 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4341 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4342 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4344 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4345 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4346 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4347 popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4348 popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4349 popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4351 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4353 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4354 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4355 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4357 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4358 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4359 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4361 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4362 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4363 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4365 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4366 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4367 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4369 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4370 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4371 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4373 popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4374 popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4375 popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4377 popupMgr()->insert( separator(), anId, -1 );
4379 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4380 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4382 popupMgr()->insert( separator(), anId, -1 );
4384 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4386 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4387 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4389 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4390 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4391 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4393 #ifndef DISABLE_PLOT2DVIEWER
4394 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4395 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4398 //-------------------------------------------------
4400 //-------------------------------------------------
4401 popupMgr()->insert( separator(), -1, -1 );
4402 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4403 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4404 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4405 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4407 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4408 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4410 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4411 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4413 popupMgr()->insert( separator(), -1, -1 );
4415 //-------------------------------------------------
4417 //-------------------------------------------------
4418 popupMgr()->insert( action( 1134 ), -1, -1 );
4419 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4421 popupMgr()->insert( separator(), -1, -1 );
4423 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4424 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4426 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4427 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4430 //================================================================================
4432 * \brief Return true if SMESH or GEOM objects are selected.
4433 * Is called form LightApp_Module::activateModule() which clear selection if
4434 * not isSelectionCompatible()
4436 //================================================================================
4438 bool SMESHGUI::isSelectionCompatible()
4440 bool isCompatible = true;
4441 SALOME_ListIO selected;
4442 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4443 Sel->selectedObjects( selected );
4445 SALOME_ListIteratorOfListIO It( selected );
4446 for ( ; isCompatible && It.More(); It.Next())
4448 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4449 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4451 return isCompatible;
4455 bool SMESHGUI::reusableOperation( const int id )
4457 // compute, evaluate and precompute are not reusable operations
4458 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4461 bool SMESHGUI::activateModule( SUIT_Study* study )
4463 bool res = SalomeApp_Module::activateModule( study );
4465 setMenuShown( true );
4466 setToolShown( true );
4468 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4469 PyGILState_STATE gstate = PyGILState_Ensure();
4470 PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4471 if(pluginsmanager==NULL)
4475 PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4480 PyGILState_Release(gstate);
4481 // end of GEOM plugins loading
4483 // Reset actions accelerator keys
4484 //action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4485 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4486 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4488 action( 33)->setEnabled(true); // Delete: Key_Delete
4490 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4491 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4492 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4493 if ( _PTR(Study) aStudy = s->studyDS()) {
4494 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4495 updateObjBrowser(); // objects can be removed
4498 // get all view currently opened in the study and connect their signals to
4499 // the corresponding slots of the class.
4500 SUIT_Desktop* aDesk = study->application()->desktop();
4502 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4503 SUIT_ViewWindow* wnd;
4504 foreach ( wnd, wndList )
4511 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4513 setMenuShown( false );
4514 setToolShown( false );
4516 EmitSignalCloseAllDialogs();
4518 // Unset actions accelerator keys
4519 //action(111)->setShortcut(QKeySequence()); // Import DAT
4520 action(112)->setShortcut(QKeySequence()); // Import UNV
4521 action(113)->setShortcut(QKeySequence()); // Import MED
4523 action( 33)->setEnabled(false); // Delete: Key_Delete
4525 return SalomeApp_Module::deactivateModule( study );
4528 void SMESHGUI::studyClosed( SUIT_Study* s )
4530 SMESH::RemoveVisuData( s->id() );
4531 SalomeApp_Module::studyClosed( s );
4534 void SMESHGUI::OnGUIEvent()
4536 const QObject* obj = sender();
4537 if ( !obj || !obj->inherits( "QAction" ) )
4539 int id = actionId((QAction*)obj);
4544 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4546 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4547 if ( CORBA::is_nil( myComponentSMESH ) )
4549 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4551 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4552 return aGUI.myComponentSMESH;
4555 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4556 return myComponentSMESH;
4559 QString SMESHGUI::engineIOR() const
4561 CORBA::ORB_var anORB = getApp()->orb();
4562 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4563 return QString( anIOR.in() );
4566 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4568 SalomeApp_Module::contextMenuPopup( client, menu, title );
4570 selectionMgr()->selectedObjects( lst );
4571 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4572 Handle(SALOME_InteractiveObject) io = lst.First();
4573 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4574 _PTR(Study) study = appStudy->studyDS();
4575 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4577 QString aName = QString( obj->GetName().c_str() );
4578 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4579 aName.remove( (aName.length() - 1), 1 );
4585 LightApp_Selection* SMESHGUI::createSelection() const
4587 return new SMESHGUI_Selection();
4590 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4592 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4593 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4596 void SMESHGUI::viewManagers( QStringList& list ) const
4598 list.append( SVTK_Viewer::Type() );
4601 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4603 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4604 SMESH::UpdateSelectionProp( this );
4606 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4607 for(int i = 0; i < aViews.count() ; i++){
4608 SUIT_ViewWindow *sf = aViews[i];
4614 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4616 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4617 myClippingPlaneInfoMap.erase( theViewManager );
4620 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4622 theActor->AddObserver( SMESH::DeleteActorEvent,
4623 myEventCallbackCommand.GetPointer(),
4627 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4628 unsigned long theEvent,
4629 void* theClientData,
4632 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4633 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4634 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4635 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4636 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4637 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4638 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4639 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4640 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4641 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4642 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4643 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4644 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4645 if( anActor == *anIter3 ) {
4646 anActorList.erase( anIter3 );
4657 void SMESHGUI::createPreferences()
4659 // General tab ------------------------------------------------------------------------
4660 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4662 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4663 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4664 setPreferenceProperty( lim, "min", 0 );
4665 setPreferenceProperty( lim, "max", 100000000 );
4666 setPreferenceProperty( lim, "step", 1000 );
4667 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4669 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4670 setPreferenceProperty( qaGroup, "columns", 2 );
4671 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4672 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4673 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4674 setPreferenceProperty( prec, "min", 0 );
4675 setPreferenceProperty( prec, "max", 16 );
4676 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4677 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4678 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4679 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4680 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4682 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4683 setPreferenceProperty( dispgroup, "columns", 2 );
4684 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4686 modes.append( tr("MEN_WIRE") );
4687 modes.append( tr("MEN_SHADE") );
4688 modes.append( tr("MEN_NODES") );
4689 modes.append( tr("MEN_SHRINK") );
4690 QList<QVariant> indices;
4691 indices.append( 0 );
4692 indices.append( 1 );
4693 indices.append( 2 );
4694 indices.append( 3 );
4695 setPreferenceProperty( dispmode, "strings", modes );
4696 setPreferenceProperty( dispmode, "indexes", indices );
4698 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4699 setPreferenceProperty( arcgroup, "columns", 2 );
4700 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4701 QStringList quadraticModes;
4702 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4703 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4705 indices.append( 0 );
4706 indices.append( 1 );
4707 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4708 setPreferenceProperty( quadraticmode, "indexes", indices );
4710 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4711 "SMESH", "max_angle" );
4712 setPreferenceProperty( maxAngle, "min", 1 );
4713 setPreferenceProperty( maxAngle, "max", 90 );
4717 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4718 setPreferenceProperty( exportgroup, "columns", 2 );
4719 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4720 addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4722 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4723 setPreferenceProperty( computeGroup, "columns", 2 );
4724 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4726 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4727 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4728 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4730 indices.append( 0 );
4731 indices.append( 1 );
4732 indices.append( 2 );
4733 setPreferenceProperty( notifyMode, "strings", modes );
4734 setPreferenceProperty( notifyMode, "indexes", indices );
4736 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4737 setPreferenceProperty( infoGroup, "columns", 2 );
4738 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4740 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4741 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4743 indices.append( 0 );
4744 indices.append( 1 );
4745 setPreferenceProperty( elemInfo, "strings", modes );
4746 setPreferenceProperty( elemInfo, "indexes", indices );
4747 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4748 setPreferenceProperty( nodesLim, "min", 0 );
4749 setPreferenceProperty( nodesLim, "max", 10000000 );
4750 setPreferenceProperty( nodesLim, "step", 10000 );
4751 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4752 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
4753 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
4754 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
4755 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
4757 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4758 setPreferenceProperty( segGroup, "columns", 2 );
4759 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4760 "SMESH", "segmentation" );
4761 setPreferenceProperty( segLen, "min", 1 );
4762 setPreferenceProperty( segLen, "max", 10000000 );
4763 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4764 "SMESH", "nb_segments_per_edge" );
4765 setPreferenceProperty( nbSeg, "min", 1 );
4766 setPreferenceProperty( nbSeg, "max", 10000000 );
4768 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4769 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4770 "SMESH", "forget_mesh_on_hyp_modif" );
4773 // Quantities with individual precision settings
4774 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4775 setPreferenceProperty( precGroup, "columns", 2 );
4777 const int nbQuantities = 6;
4778 int precs[nbQuantities], ii = 0;
4779 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4780 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4781 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4782 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4783 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4784 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4785 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4786 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4787 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4788 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4789 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4790 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4792 // Set property for precision value for spinboxes
4793 for ( ii = 0; ii < nbQuantities; ii++ ){
4794 setPreferenceProperty( precs[ii], "min", -14 );
4795 setPreferenceProperty( precs[ii], "max", 14 );
4796 setPreferenceProperty( precs[ii], "precision", 2 );
4799 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4800 setPreferenceProperty( previewGroup, "columns", 2 );
4801 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4802 setPreferenceProperty( chunkSize, "min", 1 );
4803 setPreferenceProperty( chunkSize, "max", 1000 );
4804 setPreferenceProperty( chunkSize, "step", 50 );
4806 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4807 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4809 // Mesh tab ------------------------------------------------------------------------
4810 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4811 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4812 setPreferenceProperty( nodeGroup, "columns", 3 );
4814 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4816 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4818 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4819 QList<QVariant> aMarkerTypeIndicesList;
4820 QList<QVariant> aMarkerTypeIconsList;
4821 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4822 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4823 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4824 aMarkerTypeIndicesList << i;
4825 aMarkerTypeIconsList << pixmap;
4827 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4828 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4830 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4832 QList<QVariant> aMarkerScaleIndicesList;
4833 QStringList aMarkerScaleValuesList;
4834 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4835 aMarkerScaleIndicesList << i;
4836 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4838 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4839 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4841 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4842 //setPreferenceProperty( elemGroup, "columns", 2 );
4844 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4845 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4846 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
4847 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
4848 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4849 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
4850 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4851 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4854 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4855 setPreferenceProperty( grpGroup, "columns", 2 );
4857 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4858 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
4860 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4861 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4862 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
4863 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
4864 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4865 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4866 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
4867 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
4868 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4869 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4871 setPreferenceProperty( size0d, "min", 1 );
4872 setPreferenceProperty( size0d, "max", 10 );
4874 setPreferenceProperty( ballSize, "min", 1 );
4875 setPreferenceProperty( ballSize, "max", 10 );
4877 setPreferenceProperty( elemW, "min", 1 );
4878 setPreferenceProperty( elemW, "max", 5 );
4880 setPreferenceProperty( outW, "min", 1 );
4881 setPreferenceProperty( outW, "max", 5 );
4883 setPreferenceProperty( shrink, "min", 0 );
4884 setPreferenceProperty( shrink, "max", 100 );
4886 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
4887 setPreferenceProperty( numGroup, "columns", 2 );
4889 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
4890 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
4892 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
4893 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
4895 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4896 setPreferenceProperty( orientGroup, "columns", 1 );
4898 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4899 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4901 setPreferenceProperty( orientScale, "min", 0.05 );
4902 setPreferenceProperty( orientScale, "max", 0.5 );
4903 setPreferenceProperty( orientScale, "step", 0.05 );
4905 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4907 // Selection tab ------------------------------------------------------------------------
4908 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4910 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4911 setPreferenceProperty( selGroup, "columns", 2 );
4913 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4914 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4916 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4917 setPreferenceProperty( preGroup, "columns", 2 );
4919 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4921 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4922 setPreferenceProperty( precSelGroup, "columns", 2 );
4924 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4925 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4926 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4928 // Scalar Bar tab ------------------------------------------------------------------------
4929 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4930 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4931 setPreferenceProperty( fontGr, "columns", 2 );
4933 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4934 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4936 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4937 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4939 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4940 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4942 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4943 setPreferenceProperty( numcol, "min", 2 );
4944 setPreferenceProperty( numcol, "max", 256 );
4946 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4947 setPreferenceProperty( numlab, "min", 2 );
4948 setPreferenceProperty( numlab, "max", 65 );
4950 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4951 setPreferenceProperty( orientGr, "columns", 2 );
4952 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4953 QStringList orients;
4954 orients.append( tr( "SMESH_VERTICAL" ) );
4955 orients.append( tr( "SMESH_HORIZONTAL" ) );
4956 indices.clear(); indices.append( 0 ); indices.append( 1 );
4957 setPreferenceProperty( orient, "strings", orients );
4958 setPreferenceProperty( orient, "indexes", indices );
4960 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4961 setPreferenceProperty( posVSizeGr, "columns", 2 );
4962 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4963 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4964 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4965 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4966 setPreferenceProperty( xv, "step", 0.1 );
4967 setPreferenceProperty( xv, "min", 0.0 );
4968 setPreferenceProperty( xv, "max", 1.0 );
4969 setPreferenceProperty( yv, "step", 0.1 );
4970 setPreferenceProperty( yv, "min", 0.0 );
4971 setPreferenceProperty( yv, "max", 1.0 );
4972 setPreferenceProperty( wv, "step", 0.1 );
4973 setPreferenceProperty( wv, "min", 0.0 );
4974 setPreferenceProperty( wv, "max", 1.0 );
4975 setPreferenceProperty( hv, "min", 0.0 );
4976 setPreferenceProperty( hv, "max", 1.0 );
4977 setPreferenceProperty( hv, "step", 0.1 );
4979 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
4980 setPreferenceProperty( posHSizeGr, "columns", 2 );
4981 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
4982 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
4983 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
4984 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
4985 setPreferenceProperty( xv, "min", 0.0 );
4986 setPreferenceProperty( xv, "max", 1.0 );
4987 setPreferenceProperty( xv, "step", 0.1 );
4988 setPreferenceProperty( xh, "min", 0.0 );
4989 setPreferenceProperty( xh, "max", 1.0 );
4990 setPreferenceProperty( xh, "step", 0.1 );
4991 setPreferenceProperty( yh, "min", 0.0 );
4992 setPreferenceProperty( yh, "max", 1.0 );
4993 setPreferenceProperty( yh, "step", 0.1 );
4994 setPreferenceProperty( wh, "min", 0.0 );
4995 setPreferenceProperty( wh, "max", 1.0 );
4996 setPreferenceProperty( wh, "step", 0.1 );
4997 setPreferenceProperty( hh, "min", 0.0 );
4998 setPreferenceProperty( hh, "max", 1.0 );
4999 setPreferenceProperty( hh, "step", 0.1 );
5001 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5002 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5003 setPreferenceProperty( distributionGr, "columns", 3 );
5005 types.append( tr( "SMESH_MONOCOLOR" ) );
5006 types.append( tr( "SMESH_MULTICOLOR" ) );
5007 indices.clear(); indices.append( 0 ); indices.append( 1 );
5008 setPreferenceProperty( coloringType, "strings", types );
5009 setPreferenceProperty( coloringType, "indexes", indices );
5010 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5014 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5016 if( sect=="SMESH" ) {
5017 float sbX1,sbY1,sbW,sbH;
5018 float aTol = 1.00000009999999;
5019 std::string aWarning;
5020 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5021 if( name=="selection_object_color" || name=="selection_element_color" ||
5022 name=="highlight_color" ||
5023 name=="selection_precision_node" || name=="selection_precision_element" ||
5024 name=="selection_precision_object")
5025 SMESH::UpdateSelectionProp( this );
5026 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5027 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5028 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5029 if(sbX1+sbW > aTol){
5030 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5033 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5034 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5037 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5038 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5039 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5040 if(sbY1+sbH > aTol){
5041 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5042 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5043 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5046 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5047 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5048 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5049 if(sbX1+sbW > aTol){
5050 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5053 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5054 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5057 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5058 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5059 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5060 if(sbY1+sbH > aTol){
5061 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5064 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5065 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5068 else if ( name == "segmentation" ) {
5069 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5070 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5072 else if ( name == "nb_segments_per_edge" ) {
5073 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5074 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5076 else if ( name == "historical_python_dump" ||
5077 name == "forget_mesh_on_hyp_modif") {
5078 QString val = aResourceMgr->stringValue( "SMESH", name );
5079 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5081 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5082 SMESH::UpdateFontProp( this );
5084 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5085 SMESH::UpdateFontProp( this );
5088 if(aWarning.size() != 0){
5089 aWarning += "The default values are applied instead.";
5090 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5091 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5092 QObject::tr(aWarning.c_str()));
5097 //================================================================================
5099 * \brief Update something in accordance with update flags
5100 * \param theFlags - update flags
5102 * Update viewer or/and object browser etc. in accordance with update flags ( see
5103 * LightApp_UpdateFlags enumeration ).
5105 //================================================================================
5106 void SMESHGUI::update( const int flags )
5108 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5109 SMESH::UpdateView();
5111 SalomeApp_Module::update( flags );
5114 //================================================================================
5116 * \brief Set default selection mode
5118 * SLOT called when operation commited. Sets default selection mode
5120 //================================================================================
5121 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5123 SVTK_ViewWindow* vtkWnd =
5124 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5126 vtkWnd->SetSelectionMode( ActorSelection );
5129 //================================================================================
5131 * \brief Set default selection mode
5133 * SLOT called when operation aborted. Sets default selection mode
5135 //================================================================================
5136 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5138 SVTK_ViewWindow* vtkWnd =
5139 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5141 vtkWnd->SetSelectionMode( ActorSelection );
5144 //================================================================================
5146 * \brief Creates operation with given identifier
5147 * \param id - identifier of operation to be started
5148 * \return Pointer on created operation or NULL if operation is not created
5150 * Virtual method redefined from the base class creates operation with given id.
5151 * It is called called automatically from startOperation method of base class.
5153 //================================================================================
5154 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5156 LightApp_Operation* op = 0;
5157 // to do : create operation here
5160 case 417: //convert to quadratic
5161 op = new SMESHGUI_ConvToQuadOp();
5163 case 418: // create 2D mesh as boundary on 3D
5164 op = new SMESHGUI_Make2DFrom3DOp();
5166 case 420: // Reorient faces
5167 op = new SMESHGUI_ReorientFacesOp();
5169 case 701: // Compute mesh
5170 op = new SMESHGUI_ComputeOp();
5172 case 702: // Create mesh
5173 op = new SMESHGUI_MeshOp( true, true );
5175 case 703: // Create sub-mesh
5176 op = new SMESHGUI_MeshOp( true, false );
5178 case 704: // Edit mesh/sub-mesh
5179 op = new SMESHGUI_MeshOp( false );
5181 case 711: // Precompute mesh
5182 op = new SMESHGUI_PrecomputeOp();
5184 case 712: // Evaluate mesh
5185 op = new SMESHGUI_EvaluateOp();
5187 case 713: // Evaluate mesh
5188 op = new SMESHGUI_MeshOrderOp();
5190 case 806: // Create group on geom
5191 op = new SMESHGUI_GroupOnShapeOp();
5193 case 904: // Find element
5194 op = new SMESHGUI_FindElemByPointOp();
5196 case 4067: // Make mesh pass through point
5197 op = new SMESHGUI_MakeNodeAtPointOp();
5199 case 4070: // Create 0D elements on all nodes
5200 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5207 op = SalomeApp_Module::createOperation( id );
5211 //================================================================================
5213 * \brief Stops current operations and starts a given one
5214 * \param id - The id of the operation to start
5216 //================================================================================
5218 void SMESHGUI::switchToOperation(int id)
5220 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5221 activeStudy()->abortAllOperations();
5222 startOperation( id );
5225 LightApp_Displayer* SMESHGUI::displayer()
5228 myDisplayer = new SMESHGUI_Displayer( getApp() );
5232 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5235 int aTolerance = 64;
5236 int anIterations = 0;
5242 if( anIterations % aPeriod == 0 )
5245 if( aTolerance < 1 )
5249 aHue = (int)( 360.0 * rand() / RAND_MAX );
5252 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5253 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5254 for( ; it != itEnd; ++it )
5256 SALOMEDS::Color anAutoColor = *it;
5257 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5260 aQColor.getHsv( &h, &s, &v );
5261 if( abs( h - aHue ) < aTolerance )
5273 aColor.setHsv( aHue, 255, 255 );
5275 SALOMEDS::Color aSColor;
5276 aSColor.R = aColor.redF();
5277 aSColor.G = aColor.greenF();
5278 aSColor.B = aColor.blueF();
5283 const char* gSeparator = "_"; // character used to separate parameter names
5284 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5285 const char* gPathSep = "|"; // character used to separate paths
5288 * \brief Store visual parameters
5290 * This method is called just before the study document is saved.
5291 * Store visual parameters in AttributeParameter attribue(s)
5293 void SMESHGUI::storeVisualParameters (int savePoint)
5296 Kernel_Utils::Localizer loc;
5298 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5299 if (!appStudy || !appStudy->studyDS())
5301 _PTR(Study) studyDS = appStudy->studyDS();
5303 // componentName is used for encoding of entries when storing them in IParameters
5304 std::string componentName = myComponentSMESH->ComponentDataType();
5305 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5306 //if (!aSComponent) return;
5309 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5310 componentName.c_str(),
5312 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5314 // store map of custom markers
5315 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5316 if( !aMarkerMap.empty() )
5318 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5319 for( ; anIter != aMarkerMap.end(); anIter++ )
5321 int anId = anIter->first;
5322 VTK::MarkerData aMarkerData = anIter->second;
5323 std::string aMarkerFileName = aMarkerData.first;
5324 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5325 if( aMarkerTexture.size() < 3 )
5326 continue; // should contain at least width, height and the first value
5328 QString aPropertyName( "texture" );
5329 aPropertyName += gSeparator;
5330 aPropertyName += QString::number( anId );
5332 QString aPropertyValue = aMarkerFileName.c_str();
5333 aPropertyValue += gPathSep;
5335 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5336 ushort aWidth = *aTextureIter++;
5337 ushort aHeight = *aTextureIter++;
5338 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5339 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5340 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5341 aPropertyValue += QString::number( *aTextureIter );
5343 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5347 // viewers counters are used for storing view_numbers in IParameters
5350 // main cycle to store parameters of displayed objects
5351 QList<SUIT_ViewManager*> lst;
5352 QList<SUIT_ViewManager*>::Iterator it;
5353 getApp()->viewManagers(lst);
5354 for (it = lst.begin(); it != lst.end(); it++)
5356 SUIT_ViewManager* vman = *it;
5357 QString vType = vman->getType();
5359 // saving VTK actors properties
5360 if (vType == SVTK_Viewer::Type())
5362 // store the clipping planes attached to the view manager
5363 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5364 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5365 if( anIter != myClippingPlaneInfoMap.end() )
5366 aClippingPlaneInfoList = anIter->second;
5368 if( !aClippingPlaneInfoList.empty() ) {
5369 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5370 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5372 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5373 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5375 QString aPropertyName( "ClippingPlane" );
5376 aPropertyName += gSeparator;
5377 aPropertyName += QString::number( vtkViewers );
5378 aPropertyName += gSeparator;
5379 aPropertyName += QString::number( anId );
5381 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5382 aPropertyValue += gDigitsSep;
5383 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5384 aPropertyValue += gDigitsSep;
5385 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5386 aPropertyValue += gDigitsSep;
5387 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5389 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5393 QVector<SUIT_ViewWindow*> views = vman->getViews();
5394 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5396 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5398 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5399 vtkActorCollection* allActors = aCopy.GetActors();
5400 allActors->InitTraversal();
5401 while (vtkActor* actor = allActors->GetNextActor())
5403 if (actor->GetVisibility()) // store only visible actors
5405 SMESH_Actor* aSmeshActor = 0;
5406 if (actor->IsA("SMESH_Actor"))
5407 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5408 if (aSmeshActor && aSmeshActor->hasIO())
5410 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5413 // entry is "encoded" = it does NOT contain component adress,
5414 // since it is a subject to change on next component loading
5415 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5417 std::string param, vtkParam = vType.toLatin1().data();
5418 vtkParam += gSeparator;
5419 vtkParam += QString::number(vtkViewers).toLatin1().data();
5420 vtkParam += gSeparator;
5423 param = vtkParam + "Visibility";
5424 ip->setParameter(entry, param, "On");
5427 param = vtkParam + "Representation";
5428 ip->setParameter(entry, param, QString::number
5429 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5432 param = vtkParam + "IsShrunk";
5433 ip->setParameter(entry, param, QString::number
5434 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5436 // Displayed entities
5437 unsigned int aMode = aSmeshActor->GetEntityMode();
5438 bool isE = aMode & SMESH_Actor::eEdges;
5439 bool isF = aMode & SMESH_Actor::eFaces;
5440 bool isV = aMode & SMESH_Actor::eVolumes;
5441 bool is0d = aMode & SMESH_Actor::e0DElements;
5442 bool isB = aMode & SMESH_Actor::eBallElem;
5444 QString modeStr ("e");
5445 modeStr += gDigitsSep; modeStr += QString::number(isE);
5446 modeStr += gDigitsSep; modeStr += "f";
5447 modeStr += gDigitsSep; modeStr += QString::number(isF);
5448 modeStr += gDigitsSep; modeStr += "v";
5449 modeStr += gDigitsSep; modeStr += QString::number(isV);
5450 modeStr += gDigitsSep; modeStr += "0d";
5451 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5452 modeStr += gDigitsSep; modeStr += "b";
5453 modeStr += gDigitsSep; modeStr += QString::number(isB);
5455 param = vtkParam + "Entities";
5456 ip->setParameter(entry, param, modeStr.toLatin1().data());
5459 vtkFloatingPointType r, g, b;
5462 aSmeshActor->GetSufaceColor(r, g, b, delta);
5463 QStringList colorStr;
5464 colorStr << "surface";
5465 colorStr << QString::number(r);
5466 colorStr << QString::number(g);
5467 colorStr << QString::number(b);
5469 colorStr << "backsurface";
5470 colorStr << QString::number(delta);
5472 aSmeshActor->GetVolumeColor(r, g, b, delta);
5473 colorStr << "volume";
5474 colorStr << QString::number(r);
5475 colorStr << QString::number(g);
5476 colorStr << QString::number(b);
5477 colorStr << QString::number(delta);
5479 aSmeshActor->GetEdgeColor(r, g, b);
5481 colorStr << QString::number(r);
5482 colorStr << QString::number(g);
5483 colorStr << QString::number(b);
5485 aSmeshActor->GetNodeColor(r, g, b);
5487 colorStr << QString::number(r);
5488 colorStr << QString::number(g);
5489 colorStr << QString::number(b);
5491 aSmeshActor->GetOutlineColor(r, g, b);
5492 colorStr << "outline";
5493 colorStr << QString::number(r);
5494 colorStr << QString::number(g);
5495 colorStr << QString::number(b);
5497 aSmeshActor->Get0DColor(r, g, b);
5498 colorStr << "elem0d";
5499 colorStr << QString::number(r);
5500 colorStr << QString::number(g);
5501 colorStr << QString::number(b);
5503 aSmeshActor->GetBallColor(r, g, b);
5505 colorStr << QString::number(r);
5506 colorStr << QString::number(g);
5507 colorStr << QString::number(b);
5509 aSmeshActor->GetFacesOrientationColor(r, g, b);
5510 colorStr << "orientation";
5511 colorStr << QString::number(r);
5512 colorStr << QString::number(g);
5513 colorStr << QString::number(b);
5515 param = vtkParam + "Colors";
5516 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5519 QStringList sizeStr;
5521 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5522 sizeStr << "outline";
5523 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5524 sizeStr << "elem0d";
5525 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5527 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5528 sizeStr << "shrink";
5529 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5530 sizeStr << "orientation";
5531 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5532 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5534 param = vtkParam + "Sizes";
5535 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5540 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5541 if( aMarkerType == VTK::MT_USER ) {
5542 markerStr += "custom";
5543 markerStr += gDigitsSep;
5544 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5548 markerStr += gDigitsSep;
5549 markerStr += QString::number( (int)aMarkerType );
5550 markerStr += gDigitsSep;
5551 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5554 param = vtkParam + "PointMarker";
5555 ip->setParameter(entry, param, markerStr.toLatin1().data());
5558 param = vtkParam + "Opacity";
5559 ip->setParameter(entry, param,
5560 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5563 param = vtkParam + "ClippingPlane";
5565 if( !aClippingPlaneInfoList.empty() ) {
5566 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5567 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5569 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5570 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5571 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5572 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5573 if( aSmeshActor == *anIter2 ) {
5574 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5575 QString::number( anId ).toLatin1().constData() );
5582 ip->setParameter( entry, param, "Off" );
5583 } // if (io->hasEntry())
5584 } // SMESH_Actor && hasIO
5586 } // while.. actors traversal
5590 } // if (SVTK view model)
5591 } // for (viewManagers)
5594 // data structures for clipping planes processing
5597 vtkIdType Orientation;
5598 vtkFloatingPointType Distance;
5599 vtkFloatingPointType Angle[2];
5601 typedef std::list<TPlaneData> TPlaneDataList;
5602 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5604 typedef std::list<vtkActor*> TActorList;
5607 TActorList ActorList;
5608 SUIT_ViewManager* ViewManager;
5610 typedef std::list<TPlaneInfo> TPlaneInfoList;
5611 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5614 * \brief Restore visual parameters
5616 * This method is called after the study document is opened.
5617 * Restore visual parameters from AttributeParameter attribue(s)
5619 void SMESHGUI::restoreVisualParameters (int savePoint)
5622 Kernel_Utils::Localizer loc;
5624 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5625 if (!appStudy || !appStudy->studyDS())
5627 _PTR(Study) studyDS = appStudy->studyDS();
5629 // componentName is used for encoding of entries when storing them in IParameters
5630 std::string componentName = myComponentSMESH->ComponentDataType();
5631 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5632 //if (!aSComponent) return;
5635 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5636 componentName.c_str(),
5638 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5640 // restore map of custom markers and map of clipping planes
5641 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5642 TPlaneDataMap aPlaneDataMap;
5644 std::vector<std::string> properties = ip->getProperties();
5645 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5647 std::string property = *propIt;
5648 QString aPropertyName( property.c_str() );
5649 QString aPropertyValue( ip->getProperty( property ).c_str() );
5651 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5652 if( aPropertyNameList.isEmpty() )
5655 QString aPropertyType = aPropertyNameList[0];
5656 if( aPropertyType == "texture" )
5658 if( aPropertyNameList.size() != 2 )
5662 int anId = aPropertyNameList[1].toInt( &ok );
5663 if( !ok || anId < 1 )
5666 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5667 if( aPropertyValueList.size() != 2 )
5670 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5671 QString aMarkerTextureString = aPropertyValueList[1];
5672 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5673 if( aMarkerTextureStringList.size() != 3 )
5677 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5682 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5686 VTK::MarkerTexture aMarkerTexture;
5687 aMarkerTexture.push_back( aWidth );
5688 aMarkerTexture.push_back( aHeight );
5690 QString aMarkerTextureData = aMarkerTextureStringList[2];
5691 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5693 QChar aChar = aMarkerTextureData.at( i );
5694 if( aChar.isDigit() )
5695 aMarkerTexture.push_back( aChar.digitValue() );
5698 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5700 else if( aPropertyType == "ClippingPlane" )
5702 if( aPropertyNameList.size() != 3 )
5706 int aViewId = aPropertyNameList[1].toInt( &ok );
5707 if( !ok || aViewId < 0 )
5711 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5712 if( !ok || aClippingPlaneId < 0 )
5715 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5716 if( aPropertyValueList.size() != 4 )
5719 TPlaneData aPlaneData;
5720 aPlaneData.Id = aClippingPlaneId;
5723 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5728 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5733 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5738 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5742 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5743 aPlaneDataList.push_back( aPlaneData );
5747 TPlaneInfoMap aPlaneInfoMap;
5749 std::vector<std::string> entries = ip->getEntries();
5751 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5753 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5754 QString entry (ip->decodeEntry(*entIt).c_str());
5756 // Check that the entry corresponds to a real object in the Study
5757 // as the object may be deleted or modified after the visual state is saved.
5758 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5759 if (!so) continue; //Skip the not existent entry
5761 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5762 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5764 std::vector<std::string>::iterator namesIt = paramNames.begin();
5765 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5767 // actors are stored in a map after displaying of them for
5768 // quicker access in the future: map < viewID to actor >
5769 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5771 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5773 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5774 // '_' is used as separator and should not be used in viewer type or parameter names.
5775 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5776 if (lst.size() != 3)
5779 QString viewerTypStr = lst[0];
5780 QString viewIndexStr = lst[1];
5781 QString paramNameStr = lst[2];
5784 int viewIndex = viewIndexStr.toUInt(&ok);
5785 if (!ok) // bad conversion of view index to integer
5789 if (viewerTypStr == SVTK_Viewer::Type())
5791 SMESH_Actor* aSmeshActor = 0;
5792 if (vtkActors.IsBound(viewIndex))
5793 aSmeshActor = vtkActors.Find(viewIndex);
5795 QList<SUIT_ViewManager*> lst;
5796 getApp()->viewManagers(viewerTypStr, lst);
5798 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5799 SUIT_ViewManager* vman = NULL;
5800 if (viewIndex >= 0 && viewIndex < lst.count())
5801 vman = lst.at(viewIndex);
5803 if (paramNameStr == "Visibility")
5805 if (!aSmeshActor && displayer() && vman)
5807 SUIT_ViewModel* vmodel = vman->getViewModel();
5808 // SVTK view model can be casted to SALOME_View
5809 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5811 // store displayed actor in a temporary map for quicker
5812 // access later when restoring other parameters
5813 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5814 vtkRenderer* Renderer = vtkView->getRenderer();
5815 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5816 vtkActorCollection* theActors = aCopy.GetActors();
5817 theActors->InitTraversal();
5818 bool isFound = false;
5819 vtkActor *ac = theActors->GetNextActor();
5820 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5821 if (ac->IsA("SMESH_Actor")) {
5822 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5823 if (aGeomAc->hasIO()) {
5824 Handle(SALOME_InteractiveObject) io =
5825 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5826 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5828 vtkActors.Bind(viewIndex, aGeomAc);
5834 } // if (paramNameStr == "Visibility")
5837 // the rest properties "work" with SMESH_Actor
5840 QString val ((*valuesIt).c_str());
5843 if (paramNameStr == "Representation") {
5844 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5847 else if (paramNameStr == "IsShrunk") {
5849 if (!aSmeshActor->IsShrunk())
5850 aSmeshActor->SetShrink();
5853 if (aSmeshActor->IsShrunk())
5854 aSmeshActor->UnShrink();
5857 // Displayed entities
5858 else if (paramNameStr == "Entities") {
5859 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5860 int aEntityMode = SMESH_Actor::eAllEntity;
5861 for ( int i = 0; i < mode.count(); i+=2 ) {
5862 if ( i < mode.count()-1 ) {
5863 QString type = mode[i];
5864 bool val = mode[i+1].toInt();
5865 if ( type == "e" && !val )
5866 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
5867 else if ( type == "f" && !val )
5868 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
5869 else if ( type == "v" && !val )
5870 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
5871 else if ( type == "0d" && !val )
5872 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
5873 else if ( type == "b" && !val )
5874 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
5877 aSmeshActor->SetEntityMode( aEntityMode );
5880 else if (paramNameStr == "Colors") {
5881 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5888 QColor outlineColor;
5889 QColor orientationColor;
5895 // below lines are required to get default values for delta coefficients
5896 // of backface color for faces and color of reversed volumes
5897 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
5898 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
5899 for ( int i = 0; i < colors.count(); i++ ) {
5900 QString type = colors[i];
5901 if ( type == "surface" ) {
5902 // face color is set by 3 values r:g:b, where
5903 // - r,g,b - is rgb color components
5904 if ( i+1 >= colors.count() ) break; // format error
5905 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5906 if ( i+2 >= colors.count() ) break; // format error
5907 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5908 if ( i+3 >= colors.count() ) break; // format error
5909 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5910 faceColor.setRgbF( r, g, b );
5913 else if ( type == "backsurface" ) {
5914 // backface color can be defined in several ways
5915 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
5916 // - in latest versions, it is set as delta coefficient
5917 bool rgbOk = false, deltaOk;
5918 if ( i+1 >= colors.count() ) break; // format error
5919 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5920 int delta = colors[i+1].toInt( &deltaOk );
5922 if ( i+1 < colors.count() ) // index is shifted to 1
5923 g = colors[i+1].toDouble( &rgbOk );
5924 if ( rgbOk ) i++; // shift index
5925 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
5926 b = colors[i+1].toDouble( &rgbOk );
5928 // - as currently there's no way to set directly backsurface color as it was before,
5929 // we ignore old dump where r,g,b triple was set
5930 // - also we check that delta parameter is set properly
5931 if ( !rgbOk && deltaOk )
5934 else if ( type == "volume" ) {
5935 // volume color is set by 4 values r:g:b:delta, where
5936 // - r,g,b - is a normal volume rgb color components
5937 // - delta - is a reversed volume color delta coefficient
5938 if ( i+1 >= colors.count() ) break; // format error
5939 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5940 if ( i+2 >= colors.count() ) break; // format error
5941 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5942 if ( i+3 >= colors.count() ) break; // format error
5943 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5944 if ( i+4 >= colors.count() ) break; // format error
5945 int delta = colors[i+4].toInt( &bOk );
5946 if ( !bOk ) break; // format error
5947 volumeColor.setRgbF( r, g, b );
5951 else if ( type == "edge" ) {
5952 // edge color is set by 3 values r:g:b, where
5953 // - r,g,b - is rgb color components
5954 if ( i+1 >= colors.count() ) break; // format error
5955 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5956 if ( i+2 >= colors.count() ) break; // format error
5957 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5958 if ( i+3 >= colors.count() ) break; // format error
5959 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5960 edgeColor.setRgbF( r, g, b );
5963 else if ( type == "node" ) {
5964 // node color is set by 3 values r:g:b, where
5965 // - r,g,b - is rgb color components
5966 if ( i+1 >= colors.count() ) break; // format error
5967 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5968 if ( i+2 >= colors.count() ) break; // format error
5969 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5970 if ( i+3 >= colors.count() ) break; // format error
5971 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5972 nodeColor.setRgbF( r, g, b );
5975 else if ( type == "elem0d" ) {
5976 // 0d element color is set by 3 values r:g:b, where
5977 // - r,g,b - is rgb color components
5978 if ( i+1 >= colors.count() ) break; // format error
5979 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5980 if ( i+2 >= colors.count() ) break; // format error
5981 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5982 if ( i+3 >= colors.count() ) break; // format error
5983 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5984 elem0dColor.setRgbF( r, g, b );
5987 else if ( type == "ball" ) {
5988 // ball color is set by 3 values r:g:b, where
5989 // - r,g,b - is rgb color components
5990 if ( i+1 >= colors.count() ) break; // format error
5991 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5992 if ( i+2 >= colors.count() ) break; // format error
5993 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5994 if ( i+3 >= colors.count() ) break; // format error
5995 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5996 ballColor.setRgbF( r, g, b );
5999 else if ( type == "outline" ) {
6000 // outline color is set by 3 values r:g:b, where
6001 // - r,g,b - is rgb color components
6002 if ( i+1 >= colors.count() ) break; // format error
6003 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6004 if ( i+2 >= colors.count() ) break; // format error
6005 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6006 if ( i+3 >= colors.count() ) break; // format error
6007 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6008 outlineColor.setRgbF( r, g, b );
6011 else if ( type == "orientation" ) {
6012 // orientation color is set by 3 values r:g:b, where
6013 // - r,g,b - is rgb color components
6014 if ( i+1 >= colors.count() ) break; // format error
6015 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6016 if ( i+2 >= colors.count() ) break; // format error
6017 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6018 if ( i+3 >= colors.count() ) break; // format error
6019 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6020 orientationColor.setRgbF( r, g, b );
6025 if ( nodeColor.isValid() )
6026 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6028 if ( edgeColor.isValid() )
6029 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6031 if ( faceColor.isValid() )
6032 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6034 if ( volumeColor.isValid() )
6035 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6036 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6037 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6039 if ( elem0dColor.isValid() )
6040 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6042 if ( ballColor.isValid() )
6043 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6045 if ( outlineColor.isValid() )
6046 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6047 // orientation color
6048 if ( orientationColor.isValid() )
6049 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6052 else if (paramNameStr == "Sizes") {
6053 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6056 int outlineWidth = -1;
6057 int elem0dSize = -1;
6059 double shrinkSize = -1;
6060 double orientationSize = -1;
6061 bool orientation3d = false;
6062 for ( int i = 0; i < sizes.count(); i++ ) {
6063 QString type = sizes[i];
6064 if ( type == "line" ) {
6065 // line (wireframe) width is given as single integer value
6066 if ( i+1 >= sizes.count() ) break; // format error
6067 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6071 if ( type == "outline" ) {
6072 // outline width is given as single integer value
6073 if ( i+1 >= sizes.count() ) break; // format error
6074 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6078 else if ( type == "elem0d" ) {
6079 // 0d element size is given as single integer value
6080 if ( i+1 >= sizes.count() ) break; // format error
6081 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6085 else if ( type == "ball" ) {
6086 // ball size is given as single integer value
6087 if ( i+1 >= sizes.count() ) break; // format error
6088 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6092 else if ( type == "shrink" ) {
6093 // shrink factor is given as single floating point value
6094 if ( i+1 >= sizes.count() ) break; // format error
6095 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6099 else if ( type == "orientation" ) {
6100 // orientation vectors are specified by two values size:3d, where
6101 // - size - is a floating point value specifying scale factor
6102 // - 3d - is a boolean
6103 if ( i+1 >= sizes.count() ) break; // format error
6104 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6105 if ( i+2 >= sizes.count() ) break; // format error
6106 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6107 orientationSize = v1;
6108 orientation3d = (bool)v2;
6112 // line (wireframe) width
6113 if ( lineWidth > 0 )
6114 aSmeshActor->SetLineWidth( lineWidth );
6116 if ( outlineWidth > 0 )
6117 aSmeshActor->SetOutlineWidth( outlineWidth );
6118 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6119 aSmeshActor->SetOutlineWidth( lineWidth );
6121 if ( elem0dSize > 0 )
6122 aSmeshActor->Set0DSize( elem0dSize );
6125 aSmeshActor->SetBallSize( ballSize );
6127 if ( shrinkSize > 0 )
6128 aSmeshActor->SetShrinkFactor( shrinkSize );
6129 // orientation vectors
6130 if ( orientationSize > 0 ) {
6131 aSmeshActor->SetFacesOrientationScale( orientationSize );
6132 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6136 else if (paramNameStr == "PointMarker") {
6137 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6138 if( data.count() >= 2 ) {
6140 int aParam1 = data[1].toInt( &ok );
6142 if( data[0] == "std" && data.count() == 3 ) {
6143 int aParam2 = data[2].toInt( &ok );
6144 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6146 else if( data[0] == "custom" ) {
6147 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6148 if( markerIt != aMarkerMap.end() ) {
6149 VTK::MarkerData aMarkerData = markerIt->second;
6150 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6157 else if (paramNameStr == "Opacity") {
6158 aSmeshActor->SetOpacity(val.toFloat());
6161 else if (paramNameStr.startsWith("ClippingPlane")) {
6162 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6163 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
6164 // new format - val looks like "Off" or "0" (plane id)
6165 // (note: in new format "Off" value is used only for consistency,
6166 // so it is processed together with values in old format)
6167 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
6168 if( anIsOldFormat ) {
6169 if (paramNameStr == "ClippingPlane1" || val == "Off")
6170 aSmeshActor->RemoveAllClippingPlanes();
6172 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
6173 double aDistance = vals[1].toFloat();
6174 vtkFloatingPointType anAngle[2];
6175 anAngle[0] = vals[2].toFloat();
6176 anAngle[1] = vals[3].toFloat();
6178 QList<SUIT_ViewManager*> lst;
6179 getApp()->viewManagers(viewerTypStr, lst);
6180 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6181 if (viewIndex >= 0 && viewIndex < lst.count()) {
6182 SUIT_ViewManager* vman = lst.at(viewIndex);
6183 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6185 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6187 SMESH::TActorList anActorList;
6188 anActorList.push_back( aSmeshActor );
6189 SMESH::OrientedPlane* aPlane =
6190 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
6192 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6193 aClippingPlaneInfo.Plane = aPlane;
6194 aClippingPlaneInfo.ActorList = anActorList;
6195 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6202 int aPlaneId = val.toInt( &ok );
6203 if( ok && aPlaneId >= 0 ) {
6204 bool anIsDefinedPlane = false;
6205 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6206 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6207 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6208 TPlaneInfo& aPlaneInfo = *anIter;
6209 if( aPlaneInfo.PlaneId == aPlaneId ) {
6210 aPlaneInfo.ActorList.push_back( aSmeshActor );
6211 anIsDefinedPlane = true;
6215 if( !anIsDefinedPlane ) {
6216 TPlaneInfo aPlaneInfo;
6217 aPlaneInfo.PlaneId = aPlaneId;
6218 aPlaneInfo.ActorList.push_back( aSmeshActor );
6219 aPlaneInfo.ViewManager = vman;
6221 // to make the list sorted by plane id
6222 anIter = aPlaneInfoList.begin();
6223 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6224 const TPlaneInfo& aPlaneInfoRef = *anIter;
6225 if( aPlaneInfoRef.PlaneId > aPlaneId )
6228 aPlaneInfoList.insert( anIter, aPlaneInfo );
6233 } // if (aSmeshActor)
6234 } // other parameters than Visibility
6236 } // for names/parameters iterator
6237 } // for entries iterator
6239 // take into account planes with empty list of actors referred to them
6240 QList<SUIT_ViewManager*> aVMList;
6241 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6243 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6244 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6245 int aViewId = aPlaneDataIter->first;
6246 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6247 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6249 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6251 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6252 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6253 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6254 const TPlaneData& aPlaneData = *anIter2;
6255 int aPlaneId = aPlaneData.Id;
6257 bool anIsFound = false;
6258 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6259 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6260 const TPlaneInfo& aPlaneInfo = *anIter3;
6261 if( aPlaneInfo.PlaneId == aPlaneId ) {
6268 TPlaneInfo aPlaneInfo; // ActorList field is empty
6269 aPlaneInfo.PlaneId = aPlaneId;
6270 aPlaneInfo.ViewManager = aViewManager;
6272 // to make the list sorted by plane id
6273 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6274 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6275 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6276 if( aPlaneInfoRef.PlaneId > aPlaneId )
6279 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6285 // add clipping planes to actors according to the restored parameters
6286 // and update the clipping plane map
6287 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6288 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6289 int aViewId = anIter1->first;
6290 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6292 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6293 if( anIter2 == aPlaneDataMap.end() )
6295 const TPlaneDataList& aPlaneDataList = anIter2->second;
6297 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6298 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6299 const TPlaneInfo& aPlaneInfo = *anIter3;
6300 int aPlaneId = aPlaneInfo.PlaneId;
6301 const TActorList& anActorList = aPlaneInfo.ActorList;
6302 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6306 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6310 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6312 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6313 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6314 const TPlaneData& aPlaneData = *anIter4;
6315 if( aPlaneData.Id == aPlaneId ) {
6316 SMESH::OrientedPlane* aPlane =
6317 SMESHGUI_ClippingDlg::AddPlane( anActorList,
6319 (SMESH::Orientation)aPlaneData.Orientation,
6320 aPlaneData.Distance,
6323 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6324 aClippingPlaneInfo.Plane = aPlane;
6325 aClippingPlaneInfo.ActorList = anActorList;
6326 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6334 // update all VTK views
6335 QList<SUIT_ViewManager*> lst;
6336 getApp()->viewManagers(lst);
6337 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6338 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6339 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6340 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6341 vtkView->getRenderer()->ResetCameraClippingRange();
6348 \brief Adds preferences for dfont of VTK viewer
6350 \param pIf group identifier
6351 \param param parameter
6352 \return identifier of preferences
6354 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6356 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6358 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6361 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6362 fam.append( tr( "SMESH_FONT_COURIER" ) );
6363 fam.append( tr( "SMESH_FONT_TIMES" ) );
6365 setPreferenceProperty( tfont, "fonts", fam );
6367 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6368 if ( needSize ) f = f | QtxFontEdit::Size;
6369 setPreferenceProperty( tfont, "features", f );
6375 \brief Actions after hypothesis edition
6376 Updates object browser after hypothesis edition
6378 void SMESHGUI::onHypothesisEdit( int result )
6381 SMESHGUI::Modified();
6382 updateObjBrowser( true );
6387 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6388 \param pview view being closed
6390 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6391 #ifndef DISABLE_PLOT2DVIEWER
6392 //Crear all Plot2d Viewers if need.
6393 SMESH::ClearPlot2Viewers(pview);
6397 void SMESHGUI::message( const QString& msg )
6400 QStringList data = msg.split("/");
6401 if ( data.count() > 0 ) {
6402 if ( data.first() == "mesh_loading" ) {
6404 QString entry = data.count() > 1 ? data[1] : QString();
6405 if ( entry.isEmpty() )
6408 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6410 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6413 name = obj->GetName().c_str();
6414 if ( name.isEmpty() )
6417 if ( data.last() == "stop" )
6418 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6420 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6421 QApplication::processEvents();
6427 \brief Connects or disconnects signals about activating and cloning view on the module slots
6428 \param pview view which is connected/disconnected
6430 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6434 SUIT_ViewManager* viewMgr = pview->getViewManager();
6436 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6437 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6439 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6440 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6445 \brief Return \c true if object can be renamed
6447 bool SMESHGUI::renameAllowed( const QString& entry) const {
6448 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6452 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6456 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6461 if(appStudy->isComponent(entry) || obj->isReference())
6464 // check type to prevent renaming of inappropriate objects
6465 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6466 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6467 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6468 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6469 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6470 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6477 Rename object by entry.
6478 \param entry entry of the object
6479 \param name new name of the object
6480 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6482 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6484 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6488 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6493 _PTR(Study) aStudy = appStudy->studyDS();
6498 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6500 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6505 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6506 _PTR(GenericAttribute) anAttr;
6507 _PTR(AttributeName) aName;
6509 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6511 // check type to prevent renaming of inappropriate objects
6512 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6513 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6514 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6515 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6516 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6517 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6518 if ( !name.isEmpty() ) {
6519 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6521 // update name of group object and its actor
6522 Handle(SALOME_InteractiveObject) IObject =
6523 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6525 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6526 if( !aGroupObject->_is_nil() ) {
6527 aGroupObject->SetName( qPrintable(name) );
6528 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6529 anActor->setName( qPrintable(name) );