1 // Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FileInfoDlg.h"
48 #include "SMESHGUI_FileValidator.h"
49 #include "SMESHGUI_FilterDlg.h"
50 #include "SMESHGUI_FilterLibraryDlg.h"
51 #include "SMESHGUI_FindElemByPointDlg.h"
52 #include "SMESHGUI_GroupDlg.h"
53 #include "SMESHGUI_GroupOnShapeDlg.h"
54 #include "SMESHGUI_GroupOpDlg.h"
55 #include "SMESHGUI_Hypotheses.h"
56 #include "SMESHGUI_Make2DFrom3DOp.h"
57 #include "SMESHGUI_MakeNodeAtPointDlg.h"
58 #include "SMESHGUI_Measurements.h"
59 #include "SMESHGUI_MergeDlg.h"
60 #include "SMESHGUI_MeshInfo.h"
61 #include "SMESHGUI_MeshOp.h"
62 #include "SMESHGUI_MeshOrderOp.h"
63 #include "SMESHGUI_MeshPatternDlg.h"
64 #include "SMESHGUI_MultiEditDlg.h"
65 #include "SMESHGUI_NodesDlg.h"
66 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
67 #include "SMESHGUI_PropertiesDlg.h"
68 #include "SMESHGUI_RemoveElementsDlg.h"
69 #include "SMESHGUI_RemoveNodesDlg.h"
70 #include "SMESHGUI_RenumberingDlg.h"
71 #include "SMESHGUI_ReorientFacesDlg.h"
72 #include "SMESHGUI_RevolutionDlg.h"
73 #include "SMESHGUI_RotationDlg.h"
74 #include "SMESHGUI_ScaleDlg.h"
75 #include "SMESHGUI_Selection.h"
76 #include "SMESHGUI_SewingDlg.h"
77 #include "SMESHGUI_SingleEditDlg.h"
78 #include "SMESHGUI_SmoothingDlg.h"
79 #include "SMESHGUI_SymmetryDlg.h"
80 #include "SMESHGUI_TranslationDlg.h"
81 #include "SMESHGUI_TransparencyDlg.h"
83 #include "SMESHGUI_FilterUtils.h"
84 #include "SMESHGUI_GroupUtils.h"
85 #include "SMESHGUI_HypothesesUtils.h"
86 #include "SMESHGUI_MeshUtils.h"
87 #include "SMESHGUI_PatternUtils.h"
88 #include "SMESHGUI_Utils.h"
89 #include "SMESHGUI_VTKUtils.h"
91 #include <SMESH_version.h>
93 #include "SMESH_ControlsDef.hxx"
94 #include <SMESH_Actor.h>
95 #include <SMESH_ActorUtils.h>
96 #include <SMESH_Client.hxx>
97 #include <SMESH_ScalarBarActor.h>
98 #include <SMESH_TypeFilter.hxx>
100 // SALOME GUI includes
101 #include <SalomeApp_Application.h>
102 #include <SalomeApp_CheckFileDlg.h>
103 #include <SalomeApp_DataObject.h>
104 #include <SalomeApp_Study.h>
105 #include <SalomeApp_Tools.h>
107 #include <LightApp_DataOwner.h>
108 #include <LightApp_NameDlg.h>
109 #include <LightApp_Preferences.h>
110 #include <LightApp_SelectionMgr.h>
111 #include <LightApp_UpdateFlags.h>
113 #include <SVTK_ViewManager.h>
114 #include <SVTK_ViewModel.h>
115 #include <SVTK_ViewWindow.h>
117 #include <VTKViewer_Algorithm.h>
119 #include <SUIT_Desktop.h>
120 #include <SUIT_FileDlg.h>
121 #include <SUIT_MessageBox.h>
122 #include <SUIT_OverrideCursor.h>
123 #include <SUIT_ResourceMgr.h>
124 #include <SUIT_Session.h>
126 #include <QtxPopupMgr.h>
127 #include <QtxFontEdit.h>
129 #include <SALOME_ListIO.hxx>
130 #include <SALOME_ListIteratorOfListIO.hxx>
132 #ifndef DISABLE_PLOT2DVIEWER
133 #include <SPlot2d_ViewModel.h>
134 #include <SPlot2d_Histogram.h>
138 #include <SALOMEconfig.h>
139 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
140 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
141 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
144 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
145 #include <QApplication>
147 #include <QTextStream>
150 #include <boost/shared_ptr.hpp>
153 #include <vtkCallbackCommand.h>
154 #include <vtkCamera.h>
155 #include <vtkLookupTable.h>
156 #include <vtkPlane.h>
157 #include <vtkRenderer.h>
159 // SALOME KERNEL includes
160 #include <SALOMEDSClient_ClientFactory.hxx>
161 #include <SALOMEDSClient_IParameters.hxx>
162 #include <SALOMEDSClient_SComponent.hxx>
163 #include <SALOMEDSClient_StudyBuilder.hxx>
164 #include <SALOMEDS_Study.hxx>
167 #include <Standard_ErrorHandler.hxx>
168 #include <NCollection_DataMap.hxx>
170 #include <Basics_Utils.hxx>
172 //To disable automatic genericobj management, the following line should be commented.
173 //Otherwise, it should be uncommented.
174 //Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
175 #define WITHGENERICOBJ
177 // Below macro, when uncommented, switches on simplified (more performant) algorithm
178 // of auto-color picking up
179 #define SIMPLE_AUTOCOLOR
183 //=============================================================
184 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
187 void ExportMeshToFile(int theCommandID);
189 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
191 void SetDisplayEntity(int theCommandID);
193 void Control( int theCommandID );
197 //=============================================================
198 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
202 std::string myExtension;
204 if ( theCommandID == 113 ) {
205 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
206 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
208 else if ( theCommandID == 112 ) {
209 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
211 else if ( theCommandID == 111 ) {
212 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
214 else if ( theCommandID == 115 ) {
215 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
217 else if ( theCommandID == 116 ) {
218 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
220 else if ( theCommandID == 117 ) {
221 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
222 filter.append( QObject::tr( "All files (*)" ) );
224 else if ( theCommandID == 118 ) {
225 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
226 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
229 QString anInitialPath = "";
230 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
231 anInitialPath = QDir::currentPath();
233 QStringList filenames;
234 bool toCreateGroups = true;
236 // if ( theCommandID == 118 ) { // GMF
237 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
238 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
239 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
240 // fd->setNameFilters( filter );
241 // fd->SetChecked( true );
243 // filenames << fd->selectedFile();
244 // toCreateGroups = fd->IsChecked();
250 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
253 QObject::tr( "SMESH_IMPORT_MESH" ) );
255 if ( filenames.count() > 0 ) {
256 SUIT_OverrideCursor wc;
257 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
260 QStringList anEntryList;
261 bool isEmpty = false;
262 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
263 QString filename = *it;
264 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
266 switch ( theCommandID ) {
269 // DAT format (currently unsupported)
270 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
271 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
277 aMeshes->length( 1 );
278 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toLatin1().constData() );
279 if ( aMeshes[0]->_is_nil() )
280 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
281 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
287 SMESH::DriverMED_ReadStatus res;
288 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toLatin1().constData(), res );
289 if ( res != SMESH::DRS_OK ) {
290 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
291 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
298 aMeshes->length( 1 );
299 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toLatin1().constData() );
300 if ( aMeshes[0]->_is_nil() ) {
301 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
302 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
309 SMESH::DriverMED_ReadStatus res;
310 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toLatin1().constData(), res );
311 if ( res != SMESH::DRS_OK ) {
312 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
313 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
320 SMESH::DriverMED_ReadStatus res;
321 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toLatin1().constData(), res );
322 if ( res != SMESH::DRS_OK ) {
323 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
324 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
331 SMESH::ComputeError_var res;
332 aMeshes->length( 1 );
333 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toLatin1().constData(),
336 if ( res->code != SMESH::DRS_OK ) {
337 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
338 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
339 if ( strlen( res->comment.in() ) > 0 ) {
340 errors.back() += ": ";
341 errors.back() += res->comment.in();
348 catch ( const SALOME::SALOME_Exception& S_ex ) {
349 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
350 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
353 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
354 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
356 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
357 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
358 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
359 if ( theCommandID == 112 ) // mesh names aren't taken from the file for UNV import
360 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
362 anEntryList.append( aMeshSO->GetID().c_str() );
364 // obj has been published in study. Its refcount has been incremented.
365 // It is safe to decrement its refcount
366 // so that it will be destroyed when the entry in study will be removed
367 aMeshes[i]->UnRegister();
375 // update Object browser
376 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
378 // browse to the published meshes
379 if( LightApp_Application* anApp =
380 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
381 anApp->browseObjects( anEntryList );
383 // show Error message box if there were errors
384 if ( errors.count() > 0 ) {
385 SUIT_MessageBox::critical( SMESHGUI::desktop(),
386 QObject::tr( "SMESH_ERROR" ),
387 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
390 // show warning message box, if some imported mesh is empty
392 SUIT_MessageBox::warning( SMESHGUI::desktop(),
393 QObject::tr( "SMESH_WRN_WARNING" ),
394 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
399 //================================================================================
401 * \brief Export selected meshes or groups into a file
403 //================================================================================
405 void ExportMeshToFile( int theCommandID )
407 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
408 SALOME_ListIO selected;
410 aSel->selectedObjects( selected );
412 const bool isMED = ( theCommandID == 122 || theCommandID == 125 );
413 const bool isDAT = ( theCommandID == 121 || theCommandID == 124 );
414 const bool isUNV = ( theCommandID == 123 || theCommandID == 126 );
415 const bool isSTL = ( theCommandID == 140 || theCommandID == 141 );
416 const bool isCGNS= ( theCommandID == 142 || theCommandID == 143 );
417 const bool isSAUV= ( theCommandID == 144 || theCommandID == 145 );
418 const bool isGMF = ( theCommandID == 146 || theCommandID == 147 );
420 // actually, the following condition can't be met (added for insurance)
421 if( selected.Extent() == 0 ||
422 ( selected.Extent() > 1 && !isMED && !isSTL ))
425 // get mesh object from selection and check duplication of their names
426 bool hasDuplicatedMeshNames = false;
427 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
428 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
429 SALOME_ListIteratorOfListIO It( selected );
430 for( ; It.More(); It.Next() )
432 Handle(SALOME_InteractiveObject) anIObject = It.Value();
433 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
434 if ( aMeshItem->_is_nil() ) {
435 SUIT_MessageBox::warning( SMESHGUI::desktop(),
436 QObject::tr( "SMESH_WRN_WARNING" ),
437 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
441 QString aMeshName = anIObject->getName();
443 // check for name duplications
444 if ( !hasDuplicatedMeshNames )
445 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
446 if( aMeshName == (*aMeshIter).second ) {
447 hasDuplicatedMeshNames = true;
452 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
455 if( hasDuplicatedMeshNames && isMED ) {
456 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
457 QObject::tr("SMESH_WRN_WARNING"),
458 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
459 QObject::tr("SMESH_BUT_YES"),
460 QObject::tr("SMESH_BUT_NO"), 0, 1);
465 aMeshIter = aMeshList.begin();
466 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
467 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
468 QString aMeshName = (*aMeshIter).second;
470 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
472 // check for equal group names within each mesh
473 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
474 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
475 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
476 int aRet = SUIT_MessageBox::warning
477 (SMESHGUI::desktop(),
478 QObject::tr("SMESH_WRN_WARNING"),
479 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
480 QObject::tr("SMESH_BUT_YES"),
481 QObject::tr("SMESH_BUT_NO"), 0, 1);
488 // Warn the user about presence of not supported elements
490 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
494 notSupportedElemTypes.push_back( SMESH::Entity_0D );
495 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
500 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
501 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
502 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
503 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
504 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
505 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
506 notSupportedElemTypes.push_back( SMESH::Entity_0D );
507 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
512 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
513 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
514 notSupportedElemTypes.push_back( SMESH::Entity_0D );
515 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
520 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
521 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
526 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
527 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
528 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
529 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
530 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
531 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
532 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
537 notSupportedElemTypes.push_back( SMESH::Entity_0D );
538 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
539 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
540 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
541 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
542 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
543 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
544 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
545 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
547 if ( ! notSupportedElemTypes.empty() )
549 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
550 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
551 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
552 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
554 if ( !presentNotSupported.empty() )
557 const char* typeMsg[SMESH::Entity_Last] = {
558 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
559 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
560 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
561 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
562 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
563 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
564 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
565 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
567 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
568 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
569 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
570 if ( iType != presentNotSupported.size() - 1 )
571 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
573 int aRet = SUIT_MessageBox::warning
574 (SMESHGUI::desktop(),
575 QObject::tr("SMESH_WRN_WARNING"),
576 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
577 QObject::tr("SMESH_BUT_YES"),
578 QObject::tr("SMESH_BUT_NO"), 0, 1);
583 // Get parameters of export operation
586 SMESH::MED_VERSION aFormat;
587 // Init the parameters with the default values
588 bool aIsASCII_STL = true;
589 bool toCreateGroups = false;
590 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
592 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
593 bool toOverwrite = true;
594 bool toFindOutDim = true;
596 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
597 QString anInitialPath = "";
598 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
599 anInitialPath = QDir::currentPath();
601 // Get a file name to write in and additional otions
602 if ( isUNV || isDAT || isGMF ) // Export w/o options
605 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
607 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
609 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
610 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
611 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
612 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
613 anInitialPath + QString("/") + aMeshName,
614 aFilter, aTitle, false);
616 else if ( isCGNS )// Export to CGNS
618 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
619 fd->setWindowTitle( aTitle );
620 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
621 if ( !anInitialPath.isEmpty() )
622 fd->setDirectory( anInitialPath );
623 fd->selectFile(aMeshName);
624 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
625 fd->setValidator( fv );
628 aFilename = fd->selectedFile();
629 toOverwrite = fv->isOverwrite();
633 else if ( isSTL ) // Export to STL
635 QMap<QString, int> aFilterMap;
636 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
637 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
640 QMap<QString, int>::const_iterator it = aFilterMap.begin();
641 for ( ; it != aFilterMap.end(); ++it )
642 filters.push_back( it.key() );
644 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
645 fd->setWindowTitle( aTitle );
646 fd->setNameFilters( filters );
647 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
648 if ( !anInitialPath.isEmpty() )
649 fd->setDirectory( anInitialPath );
650 fd->selectFile(aMeshName);
654 aFilename = fd->selectedFile();
655 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
660 else if ( isMED || isSAUV ) // Export to MED or SAUV
662 QMap<QString, SMESH::MED_VERSION> aFilterMap;
663 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
665 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
666 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
667 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
670 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
671 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
672 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
676 QString aDefaultFilter;
677 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
678 for ( ; it != aFilterMap.end(); ++it ) {
679 filters.push_back( it.key() );
680 if (it.value() == SMESH::MED_V2_2)
681 aDefaultFilter = it.key();
683 QStringList checkBoxes;
684 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
686 SalomeApp_CheckFileDlg* fd =
687 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
688 fd->setWindowTitle( aTitle );
689 fd->setNameFilters( filters );
690 fd->selectNameFilter(aDefaultFilter);
691 fd->SetChecked(0,toCreateGroups);
692 fd->SetChecked(1,toFindOutDim);
693 if ( !anInitialPath.isEmpty() )
694 fd->setDirectory( anInitialPath );
695 fd->selectFile(aMeshName);
697 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
698 fd->setValidator( fv );
703 aFilename = fd->selectedFile();
705 aFilename = QString::null;
708 aFormat = aFilterMap[fd->selectedNameFilter()];
709 toOverwrite = fv->isOverwrite();
711 if ( !aFilename.isEmpty() ) {
712 // med-2.1 does not support poly elements
713 if ( aFormat==SMESH::MED_V2_1 )
714 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
715 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
716 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
717 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
718 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
720 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
721 QObject::tr("SMESH_WRN_WARNING"),
722 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
723 QObject::tr("SMESH_BUT_YES"),
724 QObject::tr("SMESH_BUT_NO"), 0, 1);
732 // can't append to an existing using other format
733 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
734 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toLatin1().constData(), aVersion );
735 if( !isVersionOk || aVersion != aFormat ) {
736 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
737 QObject::tr("SMESH_WRN_WARNING"),
738 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
739 QObject::tr("SMESH_BUT_YES"),
740 QObject::tr("SMESH_BUT_NO"), 0, 1);
747 QStringList aMeshNamesCollisionList;
748 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toLatin1().constData() );
749 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
750 QString anExistingMeshName( aMeshNames[ i ] );
751 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
752 QString anExportMeshName = (*aMeshIter).second;
753 if( anExportMeshName == anExistingMeshName ) {
754 aMeshNamesCollisionList.append( anExportMeshName );
759 if( !aMeshNamesCollisionList.isEmpty() ) {
760 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
761 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
762 QObject::tr("SMESH_WRN_WARNING"),
763 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
764 QObject::tr("SMESH_BUT_YES"),
765 QObject::tr("SMESH_BUT_NO"),
766 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
775 toCreateGroups = fd->IsChecked(0);
776 toFindOutDim = fd->IsChecked(1);
786 if ( !aFilename.isEmpty() ) {
787 // Check whether the file already exists and delete it if yes
788 QFile aFile( aFilename );
789 if ( aFile.exists() && toOverwrite )
791 SUIT_OverrideCursor wc;
794 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
795 // bool Renumber = false;
796 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
798 // Renumber= resMgr->booleanValue("renumbering");
800 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
801 // aMeshEditor->RenumberNodes();
802 // aMeshEditor->RenumberElements();
803 // if ( SMESHGUI::automaticUpdate() )
804 // SMESH::UpdateView();
808 aMeshIter = aMeshList.begin();
809 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
811 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
812 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
813 if ( aMeshOrGroup->_is_equivalent( aMeshItem ))
814 aMeshItem->ExportToMEDX( aFilename.toLatin1().data(), toCreateGroups,
815 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
817 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups,
818 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
823 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
825 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
826 if( !aMeshItem->_is_nil() )
827 aMeshItem->ExportSAUV( aFilename.toLatin1().data(), toCreateGroups );
832 if ( aMeshOrGroup->_is_equivalent( aMesh ))
833 aMesh->ExportDAT( aFilename.toLatin1().data() );
835 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toLatin1().data() );
839 if ( aMeshOrGroup->_is_equivalent( aMesh ))
840 aMesh->ExportUNV( aFilename.toLatin1().data() );
842 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toLatin1().data() );
846 if ( aMeshOrGroup->_is_equivalent( aMesh ))
847 aMesh->ExportSTL( aFilename.toLatin1().data(), aIsASCII_STL );
849 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toLatin1().data(), aIsASCII_STL );
853 aMeshIter = aMeshList.begin();
854 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
856 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
857 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
858 aMeshItem->ExportCGNS( aMeshOrGroup,
859 aFilename.toLatin1().data(),
860 toOverwrite && aMeshIndex == 0 );
865 toCreateGroups = true;
866 aMesh->ExportGMF( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups );
869 catch (const SALOME::SALOME_Exception& S_ex){
871 SUIT_MessageBox::warning(SMESHGUI::desktop(),
872 QObject::tr("SMESH_WRN_WARNING"),
873 QObject::tr("SMESH_EXPORT_FAILED"));
879 inline void InverseEntityMode(unsigned int& theOutputMode,
880 unsigned int theMode)
882 bool anIsNotPresent = ~theOutputMode & theMode;
884 theOutputMode |= theMode;
886 theOutputMode &= ~theMode;
889 void SetDisplayEntity(int theCommandID){
890 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
891 SALOME_ListIO selected;
893 aSel->selectedObjects( selected );
895 if(selected.Extent() >= 1){
896 SALOME_ListIteratorOfListIO It( selected );
897 for( ; It.More(); It.Next()){
898 Handle(SALOME_InteractiveObject) IObject = It.Value();
899 if(IObject->hasEntry()){
900 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
901 unsigned int aMode = anActor->GetEntityMode();
902 switch(theCommandID){
904 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
907 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
910 InverseEntityMode(aMode,SMESH_Actor::eEdges);
913 InverseEntityMode(aMode,SMESH_Actor::eFaces);
916 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
919 aMode = SMESH_Actor::eAllEntity;
923 anActor->SetEntityMode(aMode);
931 SALOME_ListIO selected;
932 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
936 LightApp_SelectionMgr* aSel = app->selectionMgr();
937 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
938 if( !aSel || !appStudy )
941 aSel->selectedObjects( selected );
942 if( selected.IsEmpty() )
945 Handle(SALOME_InteractiveObject) anIObject = selected.First();
947 _PTR(Study) aStudy = appStudy->studyDS();
948 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
949 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
950 if( aMainObject->_is_nil() )
953 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
955 QList<SALOMEDS::Color> aReservedColors;
957 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
958 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
960 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
961 //SALOMEDS::Color aColor = aGroupObject->GetColor();
963 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
964 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
965 #else // old algorithm for auto-colors
966 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
967 aReservedColors.append( aColor );
968 #endif // SIMPLE_AUTOCOLOR
970 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
974 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
975 switch ( aGroupObject->GetType ()) {
977 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
979 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
981 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
983 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
985 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
986 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
989 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
990 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
996 SMESH::RepaintCurrentView();
999 QString functorToString( SMESH::Controls::FunctorPtr f )
1001 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1002 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1003 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1004 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1005 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1006 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1007 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1008 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1009 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1010 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1011 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1012 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1013 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1014 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1015 type = QObject::tr( "WARP_ELEMENTS" );
1016 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1017 type = QObject::tr( "TAPER_ELEMENTS" );
1018 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1019 type = QObject::tr( "SKEW_ELEMENTS" );
1020 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1021 type = QObject::tr( "AREA_ELEMENTS" );
1022 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1023 type = QObject::tr( "LENGTH_EDGES" );
1024 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1025 type = QObject::tr( "LENGTH2D_EDGES" );
1026 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1027 type = QObject::tr( "MULTI_BORDERS" );
1028 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1029 type = QObject::tr( "MULTI2D_BORDERS" );
1030 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1031 type = QObject::tr( "FREE_NODES" );
1032 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1033 type = QObject::tr( "FREE_EDGES" );
1034 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1035 type = QObject::tr( "FREE_BORDERS" );
1036 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1037 type = QObject::tr( "FREE_FACES" );
1038 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1039 type = QObject::tr( "BARE_BORDER_VOLUME" );
1040 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1041 type = QObject::tr( "BARE_BORDER_FACE" );
1042 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1043 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1044 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1045 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1046 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1047 type = QObject::tr( "EQUAL_NODE" );
1048 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1049 type = QObject::tr( "EQUAL_EDGE" );
1050 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1051 type = QObject::tr( "EQUAL_FACE" );
1052 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1053 type = QObject::tr( "EQUAL_VOLUME" );
1057 void SaveDistribution()
1059 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1060 SALOME_ListIO selected;
1062 aSel->selectedObjects( selected );
1064 if ( selected.Extent() == 1 ) {
1065 Handle(SALOME_InteractiveObject) anIO = selected.First();
1066 if ( anIO->hasEntry() ) {
1067 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1068 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1069 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1070 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1071 if ( aScalarBarActor && aFunctor ) {
1072 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1074 std::vector<int> elements;
1075 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1076 if ( mesh->_is_nil() ) {
1077 SMESH::SMESH_IDSource_var idSource =
1078 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1079 if ( !idSource->_is_nil() )
1081 SMESH::long_array_var ids = idSource->GetIDs();
1082 elements.resize( ids->length() );
1083 for ( unsigned i = 0; i < elements.size(); ++i )
1084 elements[i] = ids[i];
1087 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1088 vtkLookupTable* lookupTable =
1089 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1090 double * minmax = lookupTable->GetRange();
1091 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1092 std::vector<int> nbEvents;
1093 std::vector<double> funValues;
1094 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
1095 QString anInitialPath = "";
1096 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1097 anInitialPath = QDir::currentPath();
1098 QString aMeshName = anIO->getName();
1100 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1101 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1102 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1103 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1104 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1107 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1109 if ( !aFilename.isEmpty() ) {
1110 QFile f( aFilename );
1111 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1112 QTextStream out( &f );
1113 out << "# Mesh: " << aMeshName << endl;
1114 out << "# Control: " << functorToString( aFunctor ) << endl;
1116 out.setFieldWidth( 10 );
1117 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1118 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1129 void ShowDistribution() {
1130 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1131 SALOME_ListIO selected;
1133 aSel->selectedObjects( selected );
1135 if ( selected.Extent() == 1 ) {
1136 Handle(SALOME_InteractiveObject) anIO = selected.First();
1137 if ( anIO->hasEntry() ) {
1138 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1139 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1140 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1141 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1147 #ifndef DISABLE_PLOT2DVIEWER
1148 void PlotDistribution() {
1149 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1153 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1154 SALOME_ListIO selected;
1156 aSel->selectedObjects( selected );
1158 if ( selected.Extent() == 1 ) {
1159 Handle(SALOME_InteractiveObject) anIO = selected.First();
1160 if ( anIO->hasEntry() ) {
1161 //Find Actor by entry before getting Plot2d viewer,
1162 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1163 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1165 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1170 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1174 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1178 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1179 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1180 QString functorName = functorToString( anActor->GetFunctor());
1181 QString aHistogramName("%1 : %2");
1182 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1183 aHistogram->setName(aHistogramName);
1184 aHistogram->setHorTitle(functorName);
1185 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1186 aPlot->displayObject(aHistogram, true);
1191 #endif //DISABLE_PLOT2DVIEWER
1193 void DisableAutoColor(){
1194 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1195 SALOME_ListIO selected;
1197 aSel->selectedObjects( selected );
1199 if(selected.Extent()){
1200 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1201 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1202 if ( !aMesh->_is_nil() ) {
1203 aMesh->SetAutoColor( false );
1208 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1210 SALOME_ListIO selected;
1211 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1215 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1216 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1217 if( !aSel || !appStudy )
1220 if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection
1221 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1222 aModule->EmitSignalDeactivateDialog();
1223 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1224 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1229 _PTR(Study) aStudy = appStudy->studyDS();
1231 aSel->selectedObjects( selected );
1233 if(selected.Extent() >= 1){
1234 switch(theCommandID){
1236 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1237 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1242 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1243 QColor orientationColor, outlineColor, volumeColor;
1244 int deltaF = 0, deltaV = 0;
1248 int outlineWidth = 1;
1249 double shrinkCoef = 0.0;
1250 double orientationScale = 0.0;
1251 bool orientation3d = false;
1252 VTK::MarkerType markerType = VTK::MT_NONE;
1253 VTK::MarkerScale markerScale = VTK::MS_NONE;
1255 bool hasNodes = false;
1256 int presentEntities = 0;
1257 bool firstTime = true;
1259 SALOME_ListIteratorOfListIO It( selected );
1260 for ( ; It.More(); It.Next() ) {
1261 Handle(SALOME_InteractiveObject) IObject = It.Value();
1262 if ( !IObject->hasEntry() ) continue;
1263 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1264 if ( !anActor || !anActor->GetObject() ) continue;
1267 // nodes: color, marker
1268 anActor->GetNodeColor( color[0], color[1], color[2] );
1269 nodeColor.setRgbF( color[0], color[1], color[2] );
1270 markerType = anActor->GetMarkerType();
1271 markerScale = anActor->GetMarkerScale();
1272 markerId = anActor->GetMarkerTexture();
1273 // edges: color, width
1274 anActor->GetEdgeColor( color[0], color[1], color[2] );
1275 edgeColor.setRgbF( color[0], color[1], color[2] );
1276 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1277 // faces: front color, back color (delta)
1278 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1279 faceColor.setRgbF( color[0], color[1], color[2] );
1280 // faces: front color, back color (delta)
1281 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1282 volumeColor.setRgbF( color[0], color[1], color[2] );
1283 // 0d elements: color, size
1284 anActor->Get0DColor( color[0], color[1], color[2] );
1285 elem0dColor.setRgbF( color[0], color[1], color[2] );
1286 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1287 // balls: color, size
1288 anActor->GetBallColor( color[0], color[1], color[2] );
1289 ballColor.setRgbF( color[0], color[1], color[2] );
1290 ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1292 anActor->GetOutlineColor( color[0], color[1], color[2] );
1293 outlineColor.setRgbF( color[0], color[1], color[2] );
1294 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1295 // orientation vectors: color, scale, 3d flag
1296 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1297 orientationColor.setRgbF( color[0], color[1], color[2] );
1298 orientationScale = anActor->GetFacesOrientationScale();
1299 orientation3d = anActor->GetFacesOrientation3DVectors();
1301 shrinkCoef = anActor->GetShrinkFactor();
1304 firstTime = false; // we only take properties from first object (for performance reasons)
1307 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1308 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1309 presentEntities = presentEntities | SMESH_Actor::eEdges;
1310 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1311 presentEntities = presentEntities | SMESH_Actor::eFaces;
1312 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1313 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1314 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1315 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1316 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1317 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1319 // as we know that all types of elements are present, we can exit the loop
1320 if ( presentEntities == SMESH_Actor::eAllEntity )
1324 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1325 // nodes: color, marker
1326 dlg.setNodeColor( nodeColor );
1327 if( markerType != VTK::MT_USER )
1328 dlg.setNodeMarker( markerType, markerScale );
1330 dlg.setNodeCustomMarker( markerId );
1331 // edges: color, line width
1332 dlg.setEdgeColor( edgeColor );
1333 dlg.setEdgeWidth( edgeWidth );
1334 // faces: front color, back color
1335 dlg.setFaceColor( faceColor, deltaF );
1336 // volumes: normal color, reversed color
1337 dlg.setVolumeColor( volumeColor, deltaV );
1338 // outlines: color, line width
1339 dlg.setOutlineColor( outlineColor );
1340 dlg.setOutlineWidth( outlineWidth );
1341 // 0d elements: color, size
1342 dlg.setElem0dColor( elem0dColor );
1343 dlg.setElem0dSize( elem0dSize );
1344 // balls: color, size
1345 dlg.setBallColor( ballColor );
1346 dlg.setBallSize( ballSize );
1347 // orientation: color, scale, 3d flag
1348 dlg.setOrientationColor( orientationColor );
1349 dlg.setOrientationSize( int( orientationScale * 100. ) );
1350 dlg.setOrientation3d( orientation3d );
1351 // shrink: scale factor
1352 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1353 // hide unused controls
1354 dlg.showControls( presentEntities, hasNodes );
1357 nodeColor = dlg.nodeColor();
1358 markerType = dlg.nodeMarkerType();
1359 markerScale = dlg.nodeMarkerScale();
1360 markerId = dlg.nodeMarkerId();
1361 edgeColor = dlg.edgeColor();
1362 edgeWidth = dlg.edgeWidth();
1363 faceColor = dlg.faceColor();
1364 deltaF = dlg.faceColorDelta();
1365 volumeColor = dlg.volumeColor();
1366 deltaV = dlg.volumeColorDelta();
1367 outlineColor = dlg.outlineColor();
1368 outlineWidth = dlg.outlineWidth();
1369 elem0dColor = dlg.elem0dColor();
1370 elem0dSize = dlg.elem0dSize();
1371 ballColor = dlg.ballColor();
1372 ballSize = dlg.ballSize();
1373 orientationColor = dlg.orientationColor();
1374 orientationScale = dlg.orientationSize() / 100.;
1375 orientation3d = dlg.orientation3d();
1376 shrinkCoef = dlg.shrinkCoef() / 100.;
1378 // store point markers map that might be changed by the user
1379 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1381 // set properties from dialog box to the presentations
1382 SALOME_ListIteratorOfListIO It( selected );
1383 for ( ; It.More(); It.Next() ) {
1384 Handle(SALOME_InteractiveObject) IObject = It.Value();
1385 if ( !IObject->hasEntry() ) continue;
1386 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1387 if ( !anActor ) continue;
1389 // nodes: color, marker
1390 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1391 if ( markerType != VTK::MT_USER ) {
1392 anActor->SetMarkerStd( markerType, markerScale );
1395 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1396 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1397 if ( iter != markerMap.end() )
1398 anActor->SetMarkerTexture( markerId, iter->second.second );
1400 // volumes: normal color, reversed color (delta)
1401 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1402 // faces: front color, back color (delta)
1403 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1404 // edges: color, width
1405 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1406 anActor->SetLineWidth( edgeWidth );
1408 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1409 anActor->SetOutlineWidth( outlineWidth );
1410 // 0D elements: color, size
1411 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1412 anActor->Set0DSize( elem0dSize );
1413 // balls: color, size
1414 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1415 anActor->SetBallSize( ballSize );
1416 // orientation: color, scale, 3d flag
1417 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1418 anActor->SetFacesOrientationScale( orientationScale );
1419 anActor->SetFacesOrientation3DVectors( orientation3d );
1421 anActor->SetShrinkFactor( shrinkCoef );
1423 // for groups, set also proper color
1424 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1425 if ( !aGroupObject->_is_nil() ) {
1426 SMESH::ElementType anElementType = aGroupObject->GetType();
1428 switch( anElementType ) {
1430 aColor = nodeColor; break;
1432 aColor = edgeColor; break;
1434 aColor = faceColor; break;
1436 aColor = volumeColor; break;
1438 aColor = elem0dColor; break;
1440 aColor = ballColor; break;
1444 if ( aColor.isValid() ) {
1445 SALOMEDS::Color aGroupColor;
1446 aGroupColor.R = aColor.redF();
1447 aGroupColor.G = aColor.greenF();
1448 aGroupColor.B = aColor.blueF();
1449 aGroupObject->SetColor( aGroupColor );
1451 } // if ( !aGroupObject->_is_nil() )
1452 } // for ( ; It.More(); It.Next() )
1453 SMESH::RepaintCurrentView();
1454 } // if ( dlg.exec() )
1457 } // switch(theCommandID)
1458 SALOME_ListIteratorOfListIO It( selected );
1459 for( ; It.More(); It.Next()){
1460 Handle(SALOME_InteractiveObject) IObject = It.Value();
1461 if(IObject->hasEntry()){
1462 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1463 switch(theCommandID){
1465 anActor->SetRepresentation(SMESH_Actor::eEdge);
1468 anActor->SetRepresentation(SMESH_Actor::eSurface);
1471 if(anActor->IsShrunk())
1472 anActor->UnShrink();
1474 anActor->SetShrink();
1477 anActor->SetRepresentation(SMESH_Actor::ePoint);
1480 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1481 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1484 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1485 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1491 SMESH::RepaintCurrentView();
1495 void Control( int theCommandID )
1497 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1498 SALOME_ListIO selected;
1500 aSel->selectedObjects( selected );
1502 if( !selected.IsEmpty() ){
1503 Handle(SALOME_InteractiveObject) anIO = selected.First();
1505 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1506 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1507 switch ( theCommandID ){
1509 aControl = SMESH_Actor::eLength;
1512 aControl = SMESH_Actor::eLength2D;
1515 aControl = SMESH_Actor::eFreeEdges;
1518 aControl = SMESH_Actor::eFreeBorders;
1521 aControl = SMESH_Actor::eMultiConnection;
1524 aControl = SMESH_Actor::eFreeNodes;
1527 aControl = SMESH_Actor::eMultiConnection2D;
1530 aControl = SMESH_Actor::eArea;
1533 aControl = SMESH_Actor::eTaper;
1536 aControl = SMESH_Actor::eAspectRatio;
1539 aControl = SMESH_Actor::eAspectRatio3D;
1542 aControl = SMESH_Actor::eMinimumAngle;
1545 aControl = SMESH_Actor::eWarping;
1548 aControl = SMESH_Actor::eSkew;
1551 aControl = SMESH_Actor::eVolume3D;
1554 aControl = SMESH_Actor::eFreeFaces;
1557 aControl = SMESH_Actor::eMaxElementLength2D;
1560 aControl = SMESH_Actor::eMaxElementLength3D;
1563 aControl = SMESH_Actor::eBareBorderVolume;
1566 aControl = SMESH_Actor::eBareBorderFace;
1569 aControl = SMESH_Actor::eOverConstrainedVolume;
1572 aControl = SMESH_Actor::eOverConstrainedFace;
1575 aControl = SMESH_Actor::eCoincidentNodes;
1578 aControl = SMESH_Actor::eCoincidentElems1D;
1581 aControl = SMESH_Actor:: eCoincidentElems2D;
1584 aControl = SMESH_Actor::eCoincidentElems3D;
1588 anActor->SetControlMode(aControl);
1589 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1590 SMESH::RepaintCurrentView();
1591 #ifndef DISABLE_PLOT2DVIEWER
1592 if(anActor->GetPlot2Histogram()) {
1593 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1594 QString functorName = functorToString( anActor->GetFunctor());
1595 QString aHistogramName("%1 : %2");
1596 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1597 aHistogram->setName(aHistogramName);
1598 aHistogram->setHorTitle(functorName);
1599 SMESH::ProcessIn2DViewers(anActor);
1608 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1609 SMESH::MeshObjectType theType,
1610 const QString theInTypeName,
1611 QString & theOutTypeName)
1613 SMESH_TypeFilter aTypeFilter( theType );
1615 if( !theIO.IsNull() )
1617 entry = theIO->getEntry();
1618 LightApp_DataOwner owner( entry );
1619 if ( aTypeFilter.isOk( &owner )) {
1620 theOutTypeName = theInTypeName;
1628 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1630 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1631 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1633 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1634 CORBA::String_var anID = aSComp->GetID().c_str();
1635 if (!strcmp(anID.in(),theIO->getEntry()))
1641 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1642 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1643 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1644 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1645 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1653 QString CheckHomogeneousSelection()
1655 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1656 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1657 SALOME_ListIO selected;
1659 aSel->selectedObjects( selected );
1661 QString RefType = CheckTypeObject(selected.First());
1662 SALOME_ListIteratorOfListIO It(selected);
1663 for ( ; It.More(); It.Next())
1665 Handle(SALOME_InteractiveObject) IObject = It.Value();
1666 QString Type = CheckTypeObject(IObject);
1667 if (Type.compare(RefType) != 0)
1668 return "Heterogeneous Selection";
1675 void SMESHGUI::OnEditDelete()
1677 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1678 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1679 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1681 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1682 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1683 _PTR(GenericAttribute) anAttr;
1684 _PTR(AttributeIOR) anIOR;
1686 int objectCount = 0;
1688 QString aParentComponent = QString::null;
1689 Handle(SALOME_InteractiveObject) anIO;
1690 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1692 anIO = anIt.Value();
1693 QString cur = anIO->getComponentDataType();
1694 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1696 // check if object is reference
1697 _PTR(SObject) aRefSObj;
1698 aNameList.append("\n - ");
1699 if ( aSO->ReferencedObject( aRefSObj ) ) {
1700 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1701 aNameList.append( aRefName );
1702 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1705 aNameList.append(anIO->getName());
1709 if( aParentComponent.isNull() )
1710 aParentComponent = cur;
1711 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1712 aParentComponent = "";
1715 if ( objectCount == 0 )
1716 return; // No Valid Objects Selected
1718 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1719 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1720 QObject::tr("ERR_ERROR"),
1721 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1724 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1725 if (SUIT_MessageBox::warning
1726 (SMESHGUI::desktop(),
1727 QObject::tr("SMESH_WRN_WARNING"),
1728 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1729 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1730 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1733 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1735 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1736 // then treat them all starting from the deepest objects (at list back)
1737 std::list< _PTR(SObject) > listSO;
1738 SALOME_ListIteratorOfListIO It(selected);
1739 for( ; It.More(); It.Next()) // loop on selected IO's
1741 Handle(SALOME_InteractiveObject) IObject = It.Value();
1742 if(IObject->hasEntry()) {
1743 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1745 // disable removal of "SMESH" component object
1746 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1748 if ( engineIOR() == anIOR->Value().c_str() )
1751 //Check the referenced object
1752 _PTR(SObject) aRefSObject;
1753 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1754 aSO = aRefSObject; // Delete main Object instead of reference
1756 listSO.push_back( aSO );
1757 std::list< _PTR(SObject) >::iterator itSO = listSO.begin();
1758 for ( ; itSO != listSO.end(); ++itSO ) {
1759 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1760 for (it->InitEx(false); it->More(); it->Next())
1761 listSO.push_back( it->Value() );
1765 // Check if none of objects to delete is referred from outside
1766 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1767 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1769 _PTR(SObject) SO = *ritSO;
1770 if ( !SO ) continue;
1771 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1772 for (size_t i = 0; i < aReferences.size(); i++) {
1773 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1774 std::string type = aComponent->ComponentDataType();
1775 if ( type != "SMESH" )
1777 SUIT_MessageBox::warning( anApp->desktop(),
1778 QObject::tr("WRN_WARNING"),
1779 QObject::tr("DEP_OBJECT") );
1780 return; // outside SMESH, there is an object depending on a SMESH object
1785 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1786 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1788 Handle(SALOME_InteractiveObject) IObject = It.Value();
1789 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1790 if ( !mesh->_is_nil() )
1794 // Treat SO's in the list starting from the back
1795 aStudyBuilder->NewCommand(); // There is a transaction
1796 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1798 _PTR(SObject) SO = *ritSO;
1799 if ( !SO ) continue;
1800 std::string anEntry = SO->GetID();
1802 /** Erase graphical object **/
1803 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1804 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1805 // ViewManagerList aViewMenegers = anApp->viewManagers();
1806 // ViewManagerList::const_iterator it = aViewMenegers.begin();
1807 // for( ; it != aViewMenegers.end(); it++) {
1808 // SUIT_ViewManager* vm = *it;
1809 // int nbSf = vm ? vm->getViewsCount() : 0;
1811 // QVector<SUIT_ViewWindow*> aViews = vm->getViews();
1812 // for(int i = 0; i < nbSf; i++){
1813 // SUIT_ViewWindow *sf = aViews[i];
1814 // if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
1815 // SMESH::RemoveActor(sf,anActor);
1821 /** Remove an object from data structures **/
1822 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1823 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1824 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1825 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1826 aMesh->RemoveGroup( aGroup );
1828 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1829 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1830 aMesh->RemoveSubMesh( aSubMesh );
1832 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1834 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1837 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1838 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1839 QString objType = CheckTypeObject(IObject);
1840 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1841 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1842 aStudyBuilder->RemoveObjectWithChildren( SO );
1844 else {// default action: remove SObject from the study
1845 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1846 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1848 aStudyBuilder->RemoveObjectWithChildren( SO );
1852 } /* listSO back loop */
1854 aStudyBuilder->CommitCommand();
1856 /* Clear any previous selection */
1858 aSel->setSelectedObjects( l1 );
1860 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1865 SMESHGUI_EXPORT CAM_Module* createModule()
1867 return new SMESHGUI();
1870 SMESHGUI_EXPORT char* getModuleVersion() {
1871 return (char*)SMESH_VERSION_STR;
1875 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1877 //=============================================================================
1881 //=============================================================================
1882 SMESHGUI::SMESHGUI() :
1883 SalomeApp_Module( "SMESH" )
1885 if ( CORBA::is_nil( myComponentSMESH ) )
1887 CORBA::Boolean anIsEmbeddedMode;
1888 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1889 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1891 // 0019923: EDF 765 SMESH : default values of hypothesis
1892 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1893 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1894 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1895 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1896 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1898 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1899 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1900 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1902 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1903 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1907 myActiveDialogBox = 0;
1908 myFilterLibraryDlg = 0;
1912 myEventCallbackCommand = vtkCallbackCommand::New();
1913 myEventCallbackCommand->Delete();
1914 myEventCallbackCommand->SetClientData( this );
1915 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1918 /* load resources for all available meshers */
1919 SMESH::InitAvailableHypotheses();
1922 //=============================================================================
1926 //=============================================================================
1927 SMESHGUI::~SMESHGUI()
1931 //=============================================================================
1935 //=============================================================================
1936 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1938 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1940 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1945 //=============================================================================
1949 //=============================================================================
1950 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1952 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1956 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
1957 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1958 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
1959 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
1960 return autoUpdate && !exceeded;
1963 //=============================================================================
1967 //=============================================================================
1968 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
1970 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
1973 //=============================================================================
1977 //=============================================================================
1978 SMESHGUI* SMESHGUI::GetSMESHGUI()
1980 SMESHGUI* smeshMod = 0;
1981 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
1984 CAM_Module* module = app->module( "Mesh" );
1985 smeshMod = dynamic_cast<SMESHGUI*>( module );
1988 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
1990 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
1993 _PTR(Study) aStudy = study->studyDS();
1995 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2004 Standard_EXPORT SMESHGUI* GetComponentGUI()
2006 return SMESHGUI::GetSMESHGUI();
2010 //=============================================================================
2014 //=============================================================================
2015 void SMESHGUI::SetState(int aState)
2020 //=============================================================================
2024 //=============================================================================
2025 void SMESHGUI::ResetState()
2030 //=============================================================================
2034 //=============================================================================
2035 void SMESHGUI::EmitSignalDeactivateDialog()
2037 emit SignalDeactivateActiveDialog();
2040 //=============================================================================
2044 //=============================================================================
2045 void SMESHGUI::EmitSignalStudyFrameChanged()
2047 emit SignalStudyFrameChanged();
2050 //=============================================================================
2054 //=============================================================================
2055 void SMESHGUI::EmitSignalCloseAllDialogs()
2057 emit SignalCloseAllDialogs();
2060 //=============================================================================
2064 //=============================================================================
2065 void SMESHGUI::EmitSignalVisibilityChanged()
2067 emit SignalVisibilityChanged();
2070 //=============================================================================
2074 //=============================================================================
2075 QDialog *SMESHGUI::GetActiveDialogBox()
2077 return myActiveDialogBox;
2080 //=============================================================================
2084 //=============================================================================
2085 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2087 myActiveDialogBox = (QDialog *) aDlg;
2091 //=============================================================================
2095 //=============================================================================
2096 SUIT_Desktop* SMESHGUI::desktop()
2098 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2100 return app->desktop();
2105 //=============================================================================
2109 //=============================================================================
2110 SalomeApp_Study* SMESHGUI::activeStudy()
2112 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2114 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2119 //=============================================================================
2123 //=============================================================================
2124 void SMESHGUI::Modified( bool theIsUpdateActions )
2126 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2127 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2128 appStudy->Modified();
2129 if( theIsUpdateActions )
2130 app->updateActions();
2135 //=============================================================================
2139 //=============================================================================
2140 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2142 /* Here the position is on the bottom right corner - 10 */
2143 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2145 SUIT_Desktop *PP = desktop();
2146 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2147 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2151 //=============================================================================
2155 //=============================================================================
2156 static int isStudyLocked(_PTR(Study) theStudy){
2157 return theStudy->GetProperties()->IsLocked();
2160 static bool checkLock(_PTR(Study) theStudy) {
2161 if (isStudyLocked(theStudy)) {
2162 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2163 QObject::tr("WRN_WARNING"),
2164 QObject::tr("WRN_STUDY_LOCKED") );
2170 //=======================================================================
2171 //function : CheckActiveStudyLocked
2173 //=======================================================================
2175 bool SMESHGUI::isActiveStudyLocked()
2177 _PTR(Study) aStudy = activeStudy()->studyDS();
2178 return checkLock( aStudy );
2181 //=============================================================================
2185 //=============================================================================
2186 bool SMESHGUI::OnGUIEvent( int theCommandID )
2188 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2192 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2193 SUIT_ResourceMgr* mgr = resourceMgr();
2197 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2198 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2201 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2202 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2204 //QAction* act = action( theCommandID );
2206 switch (theCommandID) {
2208 if(checkLock(aStudy)) break;
2220 if(checkLock(aStudy)) break;
2221 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2225 case 150: //MED FILE INFORMATION
2227 SALOME_ListIO selected;
2228 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2230 aSel->selectedObjects( selected );
2231 if( selected.Extent() )
2233 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2234 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2235 if ( !aMesh->_is_nil() )
2237 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2244 case 122: // EXPORT MED
2259 ::ExportMeshToFile(theCommandID);
2263 case 200: // SCALAR BAR
2265 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2266 SALOME_ListIO selected;
2268 aSel->selectedObjects( selected );
2270 if( selected.Extent() ) {
2271 Handle(SALOME_InteractiveObject) anIO = selected.First();
2272 if( anIO->hasEntry() ) {
2273 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2274 anActor->SetControlMode( SMESH_Actor::eNone );
2275 #ifndef DISABLE_PLOT2DVIEWER
2276 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2285 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2290 // dump control distribution data to the text file
2291 ::SaveDistribution();
2297 // show/ distribution
2298 ::ShowDistribution();
2302 #ifndef DISABLE_PLOT2DVIEWER
2305 // plot distribution
2306 ::PlotDistribution();
2317 ::DisableAutoColor();
2320 case 1134: // Clipping
2321 case 1133: // Tranparency
2322 case 1132: // Display preferences (colors, shrink size, line width, ...)
2329 ::SetDisplayMode(theCommandID, myMarkerMap);
2332 //2D quadratic representation
2335 ::SetDisplayMode(theCommandID, myMarkerMap);
2339 case 216: // 0D elements
2342 case 219: // Volumes
2343 case 220: // All Entity
2345 ::SetDisplayEntity(theCommandID);
2348 case 221: // Orientation of faces
2350 LightApp_SelectionMgr* mgr = selectionMgr();
2351 SALOME_ListIO selected; mgr->selectedObjects( selected );
2353 SALOME_ListIteratorOfListIO it(selected);
2354 for( ; it.More(); it.Next()) {
2355 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2356 if(anIObject->hasEntry()) {
2357 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2358 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2367 if(checkLock(aStudy)) break;
2369 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2372 SMESH::UpdateView();
2374 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2375 SMESH::OnVisuException();
2377 catch (...) { // PAL16774 (Crash after display of many groups)
2378 SMESH::OnVisuException();
2382 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2383 aSel->selectedObjects( l );
2384 aSel->setSelectedObjects( l );
2389 case 301: // DISPLAY
2390 case 302: // DISPLAY ONLY
2392 SMESH::EDisplaing anAction;
2393 switch (theCommandID) {
2394 case 300: anAction = SMESH::eErase; break;
2395 case 301: anAction = SMESH::eDisplay; break;
2396 case 302: anAction = SMESH::eDisplayOnly; break;
2399 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2400 SALOME_ListIO sel_objects, to_process;
2402 aSel->selectedObjects( sel_objects );
2404 if( theCommandID==302 )
2406 MESSAGE("anAction = SMESH::eDisplayOnly");
2407 startOperation( myEraseAll );
2410 extractContainers( sel_objects, to_process );
2413 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2417 SALOME_ListIteratorOfListIO It( to_process );
2418 for ( ; It.More(); It.Next()) {
2420 Handle(SALOME_InteractiveObject) IOS = It.Value();
2421 if (IOS->hasEntry()) {
2423 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2424 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2425 break; // PAL16774 (Crash after display of many groups)
2427 if (anAction == SMESH::eDisplayOnly)
2429 MESSAGE("anAction = SMESH::eDisplayOnly");
2430 anAction = SMESH::eDisplay;
2436 // PAL13338 + PAL15161 -->
2437 if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2438 MESSAGE("anAction = SMESH::eDisplayOnly");
2439 SMESH::UpdateView();
2440 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2442 // PAL13338 + PAL15161 <--
2444 catch (...) { // PAL16774 (Crash after display of many groups)
2445 SMESH::OnVisuException();
2448 if (anAction == SMESH::eErase) {
2449 MESSAGE("anAction == SMESH::eErase");
2451 aSel->setSelectedObjects( l1 );
2454 aSel->setSelectedObjects( to_process );
2461 if(checkLock(aStudy)) break;
2464 EmitSignalDeactivateDialog();
2466 ( new SMESHGUI_NodesDlg( this ) )->show();
2469 SUIT_MessageBox::warning(desktop(),
2470 tr("SMESH_WRN_WARNING"),
2471 tr("SMESH_WRN_VIEWER_VTK"));
2476 case 2151: // FILTER
2480 EmitSignalDeactivateDialog();
2481 ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2486 case 701: // COMPUTE MESH
2487 case 711: // PRECOMPUTE MESH
2488 case 712: // EVALUATE MESH
2489 case 713: // MESH ORDER
2490 case 702: // Create mesh
2491 case 703: // Create sub-mesh
2492 case 704: // Edit mesh/sub-mesh
2493 startOperation( theCommandID );
2495 case 705: // copy mesh
2497 if (checkLock(aStudy)) break;
2498 EmitSignalDeactivateDialog();
2499 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2502 case 710: // Build compound mesh
2504 if (checkLock(aStudy)) break;
2505 EmitSignalDeactivateDialog();
2506 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2510 case 407: // DIAGONAL INVERSION
2511 case 408: // Delete diagonal
2515 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2516 tr( "NOT_A_VTK_VIEWER" ) );
2520 if ( checkLock( aStudy ) )
2523 /*Standard_Boolean aRes;
2524 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2525 if ( aMesh->_is_nil() )
2527 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2528 tr( "SMESH_BAD_SELECTION" ) );
2532 EmitSignalDeactivateDialog();
2533 if ( theCommandID == 407 )
2534 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2536 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2539 case 409: // Change orientation
2540 case 410: // Union of triangles
2541 case 411: // Cutting of quadrangles
2542 case 419: // Splitting volumes into tetrahedra
2546 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2547 tr( "NOT_A_VTK_VIEWER" ) );
2551 if ( checkLock( aStudy ) )
2554 EmitSignalDeactivateDialog();
2555 SMESHGUI_MultiEditDlg* aDlg = NULL;
2556 if ( theCommandID == 409 )
2557 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2558 else if ( theCommandID == 410 )
2559 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2560 else if ( theCommandID == 419 )
2561 aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2563 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2568 case 412: // Smoothing
2570 if(checkLock(aStudy)) break;
2572 EmitSignalDeactivateDialog();
2573 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2576 SUIT_MessageBox::warning(desktop(),
2577 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2581 case 413: // Extrusion
2583 if (checkLock(aStudy)) break;
2585 EmitSignalDeactivateDialog();
2586 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2588 SUIT_MessageBox::warning(desktop(),
2589 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2593 case 414: // Revolution
2595 if(checkLock(aStudy)) break;
2597 EmitSignalDeactivateDialog();
2598 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2601 SUIT_MessageBox::warning(desktop(),
2602 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2606 case 415: // Pattern mapping
2608 if ( checkLock( aStudy ) )
2612 EmitSignalDeactivateDialog();
2613 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2616 SUIT_MessageBox::warning(desktop(),
2617 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2621 case 416: // Extrusion along a path
2623 if (checkLock(aStudy)) break;
2625 EmitSignalDeactivateDialog();
2626 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2628 SUIT_MessageBox::warning(desktop(),
2629 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2633 case 417: // Convert mesh to quadratic
2634 case 418: // create 2D mesh from 3D
2635 case 420: // Reorient faces
2636 case 806: // CREATE GEO GROUP
2638 startOperation( theCommandID );
2641 case 801: // CREATE GROUP
2645 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2646 tr( "NOT_A_VTK_VIEWER" ) );
2650 if(checkLock(aStudy)) break;
2651 EmitSignalDeactivateDialog();
2652 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2654 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2655 SALOME_ListIO selected;
2657 aSel->selectedObjects( selected );
2659 int nbSel = selected.Extent();
2661 // check if mesh is selected
2662 aMesh = SMESH::GetMeshByIO( selected.First() );
2664 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2669 case 802: // CONSTRUCT GROUP
2673 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2674 tr( "NOT_A_VTK_VIEWER" ) );
2678 if(checkLock(aStudy)) break;
2679 EmitSignalDeactivateDialog();
2681 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2682 SALOME_ListIO selected;
2684 aSel->selectedObjects( selected );
2686 int nbSel = selected.Extent();
2688 // check if submesh is selected
2689 Handle(SALOME_InteractiveObject) IObject = selected.First();
2690 if (IObject->hasEntry()) {
2691 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2693 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2694 if (!aSubMesh->_is_nil()) {
2696 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2697 // get submesh elements list by types
2698 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2699 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2700 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2701 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2702 // create group for each type o elements
2703 QString aName = IObject->getName();
2704 QStringList anEntryList;
2705 if (aNodes->length() > 0) {
2706 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2707 aGroup->Add(aNodes.inout());
2708 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2709 anEntryList.append( aSObject->GetID().c_str() );
2711 if (aEdges->length() > 0) {
2712 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2713 aGroup->Add(aEdges.inout());
2714 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2715 anEntryList.append( aSObject->GetID().c_str() );
2717 if (aFaces->length() > 0) {
2718 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2719 aGroup->Add(aFaces.inout());
2720 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2721 anEntryList.append( aSObject->GetID().c_str() );
2723 if (aVolumes->length() > 0) {
2724 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2725 aGroup->Add(aVolumes.inout());
2726 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2727 anEntryList.append( aSObject->GetID().c_str() );
2730 anApp->browseObjects( anEntryList );
2732 catch(const SALOME::SALOME_Exception & S_ex){
2733 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2740 SUIT_MessageBox::warning(desktop(),
2741 tr("SMESH_WRN_WARNING"),
2742 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2747 case 803: // EDIT GROUP
2751 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2752 tr( "NOT_A_VTK_VIEWER" ) );
2756 if(checkLock(aStudy)) break;
2757 EmitSignalDeactivateDialog();
2759 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2760 SALOME_ListIO selected;
2762 aSel->selectedObjects( selected );
2764 SALOME_ListIteratorOfListIO It (selected);
2765 int nbSelectedGroups = 0;
2766 for ( ; It.More(); It.Next() )
2768 SMESH::SMESH_GroupBase_var aGroup =
2769 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2770 if (!aGroup->_is_nil()) {
2772 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2776 if (nbSelectedGroups == 0)
2778 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2784 case 804: // Add elements to group
2786 if(checkLock(aStudy)) break;
2787 if (myState == 800) {
2788 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2789 if (aDlg) aDlg->onAdd();
2794 case 805: // Remove elements from group
2796 if(checkLock(aStudy)) break;
2797 if (myState == 800) {
2798 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2799 if (aDlg) aDlg->onRemove();
2804 case 815: // Edit GEOM GROUP as standalone
2808 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2809 tr( "NOT_A_VTK_VIEWER" ) );
2813 if(checkLock(aStudy)) break;
2814 EmitSignalDeactivateDialog();
2816 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2817 SALOME_ListIO selected;
2819 aSel->selectedObjects( selected );
2821 SALOME_ListIteratorOfListIO It (selected);
2822 for ( ; It.More(); It.Next() )
2824 SMESH::SMESH_GroupOnGeom_var aGroup =
2825 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2826 if (!aGroup->_is_nil()) {
2827 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2832 SMESH::SMESH_GroupOnFilter_var aGroup =
2833 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2834 if (!aGroup->_is_nil()) {
2835 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2843 case 810: // Union Groups
2844 case 811: // Intersect groups
2845 case 812: // Cut groups
2849 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2850 tr( "NOT_A_VTK_VIEWER" ) );
2854 if ( checkLock( aStudy ) )
2857 EmitSignalDeactivateDialog();
2859 SMESHGUI_GroupOpDlg* aDlg = 0;
2860 if ( theCommandID == 810 )
2861 aDlg = new SMESHGUI_UnionGroupsDlg( this );
2862 else if ( theCommandID == 811 )
2863 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2865 aDlg = new SMESHGUI_CutGroupsDlg( this );
2872 case 814: // Create groups of entities from existing groups of superior dimensions
2874 if ( checkLock( aStudy ) )
2877 EmitSignalDeactivateDialog();
2878 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2884 case 813: // Delete groups with their contents
2888 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2889 tr( "NOT_A_VTK_VIEWER" ) );
2893 if ( checkLock( aStudy ) )
2896 EmitSignalDeactivateDialog();
2898 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2902 case 900: // MESH INFOS
2903 case 903: // WHAT IS
2905 int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2906 EmitSignalDeactivateDialog();
2907 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2908 SALOME_ListIO selected;
2910 aSel->selectedObjects( selected );
2912 if ( selected.Extent() > 1 ) { // a dlg for each IO
2913 SALOME_ListIteratorOfListIO It( selected );
2914 for ( ; It.More(); It.Next() ) {
2915 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2916 dlg->showInfo( It.Value() );
2921 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2927 case 904: // FIND ELEM
2929 startOperation( theCommandID );
2933 case 1100: // EDIT HYPOTHESIS
2935 if(checkLock(aStudy)) break;
2937 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2938 SALOME_ListIO selected;
2940 aSel->selectedObjects( selected );
2942 int nbSel = selected.Extent();
2945 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2946 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
2948 /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
2949 /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects */
2950 /* Warning : however by internal mechanism all subMeshes icons are changed ! */
2951 if ( !aHypothesis->_is_nil() )
2954 //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2955 SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2957 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
2967 case 1102: // REMOVE HYPOTHESIS / ALGORITHMS
2969 if(checkLock(aStudy)) break;
2970 SUIT_OverrideCursor wc;
2972 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2973 SALOME_ListIO selected;
2975 aSel->selectedObjects( selected, QString::null, false );
2977 SALOME_ListIteratorOfListIO It(selected);
2978 for (int i = 0; It.More(); It.Next(), i++) {
2979 Handle(SALOME_InteractiveObject) IObject = It.Value();
2980 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2983 aSel->setSelectedObjects( l1 );
2989 case 4009: // ELEM0D
2991 case 4021: // TRIANGLE
2993 case 4023: // POLYGON
2997 case 4134: // PYRAMID
2998 case 4135: // OCTA12
3000 if(checkLock(aStudy)) break;
3002 EmitSignalDeactivateDialog();
3003 SMDSAbs_EntityType type = SMDSEntity_Edge;
3004 switch (theCommandID) {
3005 case 4008: type = SMDSEntity_Ball; break;
3006 case 4009: type = SMDSEntity_0D; break;
3007 case 4021: type = SMDSEntity_Triangle; break;
3008 case 4022: type = SMDSEntity_Quadrangle; break;
3009 case 4031: type = SMDSEntity_Tetra; break;
3010 case 4023: type = SMDSEntity_Polygon; break;
3011 case 4032: type = SMDSEntity_Hexa; break;
3012 case 4133: type = SMDSEntity_Penta; break;
3013 case 4134: type = SMDSEntity_Pyramid; break;
3014 case 4135: type = SMDSEntity_Hexagonal_Prism; break;
3017 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3020 SUIT_MessageBox::warning(desktop(),
3021 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3025 case 4033: // POLYHEDRON
3027 if(checkLock(aStudy)) break;
3029 EmitSignalDeactivateDialog();
3030 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3033 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3034 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3038 case 4034: // QUADRATIC EDGE
3039 case 4035: // QUADRATIC TRIANGLE
3040 case 4036: // QUADRATIC QUADRANGLE
3041 case 4136: // BIQUADRATIC QUADRANGLE
3042 case 4137: // BIQUADRATIC TRIANGLE
3043 case 4037: // QUADRATIC TETRAHEDRON
3044 case 4038: // QUADRATIC PYRAMID
3045 case 4039: // QUADRATIC PENTAHEDRON
3046 case 4040: // QUADRATIC HEXAHEDRON
3047 case 4140: // TRIQUADRATIC HEXAHEDRON
3049 if(checkLock(aStudy)) break;
3051 EmitSignalDeactivateDialog();
3052 SMDSAbs_EntityType type = SMDSEntity_Last;
3054 switch (theCommandID) {
3056 type = SMDSEntity_Quad_Edge; break;
3058 type = SMDSEntity_Quad_Triangle; break;
3060 type = SMDSEntity_Quad_Quadrangle; break;
3062 type = SMDSEntity_BiQuad_Quadrangle; break;
3064 type = SMDSEntity_BiQuad_Triangle; break;
3066 type = SMDSEntity_Quad_Tetra; break;
3068 type = SMDSEntity_Quad_Pyramid; break;
3070 type = SMDSEntity_Quad_Penta; break;
3072 type = SMDSEntity_Quad_Hexa; break;
3074 type = SMDSEntity_TriQuad_Hexa; break;
3077 if ( type != SMDSEntity_Last )
3078 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3081 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3082 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3086 case 4041: // REMOVES NODES
3088 if(checkLock(aStudy)) break;
3090 EmitSignalDeactivateDialog();
3091 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3094 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3095 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3099 case 4042: // REMOVES ELEMENTS
3101 if(checkLock(aStudy)) break;
3103 EmitSignalDeactivateDialog();
3104 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3108 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3109 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3113 case 4043: { // CLEAR_MESH
3115 if(checkLock(aStudy)) break;
3117 SALOME_ListIO selected;
3118 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3119 aSel->selectedObjects( selected );
3121 SUIT_OverrideCursor wc;
3122 SALOME_ListIteratorOfListIO It (selected);
3123 for ( ; It.More(); It.Next() )
3125 Handle(SALOME_InteractiveObject) IOS = It.Value();
3126 SMESH::SMESH_Mesh_var aMesh =
3127 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3128 if ( aMesh->_is_nil()) continue;
3130 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3132 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3133 SMESH::ModifiedMesh( aMeshSObj, false, true);
3134 // hide groups and submeshes
3135 _PTR(ChildIterator) anIter =
3136 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3137 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3139 _PTR(SObject) so = anIter->Value();
3140 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3143 catch (const SALOME::SALOME_Exception& S_ex){
3145 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3149 SMESH::UpdateView();
3153 case 4044: // REMOVE ORPHAN NODES
3155 if(checkLock(aStudy)) break;
3156 SALOME_ListIO selected;
3157 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3158 aSel->selectedObjects( selected );
3159 if ( selected.Extent() == 1 ) {
3160 Handle(SALOME_InteractiveObject) anIO = selected.First();
3161 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3162 if ( !aMesh->_is_nil() ) {
3163 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3164 tr( "SMESH_WARNING" ),
3165 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3166 SUIT_MessageBox::Yes |
3167 SUIT_MessageBox::No,
3168 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3171 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3172 int removed = aMeshEditor->RemoveOrphanNodes();
3173 SUIT_MessageBox::information(SMESHGUI::desktop(),
3174 tr("SMESH_INFORMATION"),
3175 tr("NB_NODES_REMOVED").arg(removed));
3176 if ( removed > 0 ) {
3177 SMESH::UpdateView();
3178 SMESHGUI::Modified();
3181 catch (const SALOME::SALOME_Exception& S_ex) {
3182 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3191 case 4051: // RENUMBERING NODES
3193 if(checkLock(aStudy)) break;
3195 EmitSignalDeactivateDialog();
3196 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3200 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3201 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3205 case 4052: // RENUMBERING ELEMENTS
3207 if(checkLock(aStudy)) break;
3209 EmitSignalDeactivateDialog();
3210 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3214 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3215 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3219 case 4061: // TRANSLATION
3221 if(checkLock(aStudy)) break;
3223 EmitSignalDeactivateDialog();
3224 ( new SMESHGUI_TranslationDlg( this ) )->show();
3227 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3228 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3232 case 4062: // ROTATION
3234 if(checkLock(aStudy)) break;
3236 EmitSignalDeactivateDialog();
3237 ( new SMESHGUI_RotationDlg( this ) )->show();
3240 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3241 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3245 case 4063: // SYMMETRY
3247 if(checkLock(aStudy)) break;
3249 EmitSignalDeactivateDialog();
3250 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3253 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3254 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3258 case 4064: // SEWING
3260 if(checkLock(aStudy)) break;
3262 EmitSignalDeactivateDialog();
3263 ( new SMESHGUI_SewingDlg( this ) )->show();
3266 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3267 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3271 case 4065: // MERGE NODES
3273 if(checkLock(aStudy)) break;
3275 EmitSignalDeactivateDialog();
3276 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3279 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3280 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3284 case 4066: // MERGE EQUAL ELEMENTS
3286 if (checkLock(aStudy)) break;
3288 EmitSignalDeactivateDialog();
3289 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3291 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3292 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3297 case 4067: // MAKE MESH PASS THROUGH POINT
3298 startOperation( 4067 );
3303 if(checkLock(aStudy)) break;
3305 EmitSignalDeactivateDialog();
3306 ( new SMESHGUI_ScaleDlg( this ) )->show();
3309 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3310 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3315 case 4069: // DUPLICATE NODES
3317 if(checkLock(aStudy)) break;
3319 EmitSignalDeactivateDialog();
3320 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3323 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3324 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3329 case 4070: // 0D_ON_ALL_NODES
3330 startOperation( 4070 );
3333 case 5105: // Library of selection filters
3335 static QList<int> aTypes;
3336 if ( aTypes.isEmpty() )
3338 aTypes.append( SMESH::NODE );
3339 aTypes.append( SMESH::EDGE );
3340 aTypes.append( SMESH::FACE );
3341 aTypes.append( SMESH::VOLUME );
3343 if (!myFilterLibraryDlg)
3344 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3345 else if (myFilterLibraryDlg->isHidden())
3346 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3347 myFilterLibraryDlg->raise();
3351 case 6017: // CONTROLS
3379 LightApp_SelectionMgr* mgr = selectionMgr();
3380 SALOME_ListIO selected; mgr->selectedObjects( selected );
3382 if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3383 _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3385 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3386 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
3387 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3388 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
3389 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3390 ::Control( theCommandID );
3395 SUIT_MessageBox::warning(desktop(),
3396 tr( "SMESH_WRN_WARNING" ),
3397 tr( "SMESH_BAD_SELECTION" ) );
3401 SUIT_MessageBox::warning(desktop(),
3402 tr( "SMESH_WRN_WARNING" ),
3403 tr( "NOT_A_VTK_VIEWER" ) );
3408 LightApp_SelectionMgr* mgr = selectionMgr();
3409 SALOME_ListIO selected; mgr->selectedObjects( selected );
3411 SALOME_ListIteratorOfListIO it(selected);
3412 for( ; it.More(); it.Next()) {
3413 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3414 if(anIObject->hasEntry()) {
3415 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3416 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3424 LightApp_SelectionMgr* mgr = selectionMgr();
3425 SALOME_ListIO selected; mgr->selectedObjects( selected );
3427 SALOME_ListIteratorOfListIO it(selected);
3428 for( ; it.More(); it.Next()) {
3429 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3430 if(anIObject->hasEntry())
3431 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3432 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3440 int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3441 EmitSignalDeactivateDialog();
3442 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3448 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3449 //updateObjBrowser();
3453 //=============================================================================
3457 //=============================================================================
3458 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3463 //=============================================================================
3467 //=============================================================================
3468 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3473 //=============================================================================
3477 //=============================================================================
3478 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3483 //=============================================================================
3484 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3485 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3487 //=============================================================================
3488 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3489 SUIT_ViewWindow* wnd )
3491 if(theIO->hasEntry()){
3492 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3493 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3497 //=======================================================================
3498 // function : createSMESHAction
3500 //=======================================================================
3501 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3502 const int key, const bool toggle, const QString& shortcutAction )
3505 QWidget* parent = application()->desktop();
3506 SUIT_ResourceMgr* resMgr = resourceMgr();
3508 if ( !icon_id.isEmpty() )
3509 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3511 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3512 if ( !pix.isNull() )
3513 icon = QIcon( pix );
3515 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3516 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3517 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3519 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3520 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3523 //=======================================================================
3524 // function : createPopupItem
3526 //=======================================================================
3527 void SMESHGUI::createPopupItem( const int id,
3528 const QString& clients,
3529 const QString& types,
3530 const QString& theRule,
3533 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3534 popupMgr()->insert( action( id ), pId, 0 );
3536 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3537 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3538 QString rule = "(%1) and (%2) and (%3)";
3539 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3540 if( clients.isEmpty() )
3541 rule = rule.arg( QString( "true" ) );
3543 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3544 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3547 bool cont = myRules.contains( id );
3549 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3551 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3552 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3555 //=======================================================================
3556 // function : initialize
3558 //=======================================================================
3559 void SMESHGUI::initialize( CAM_Application* app )
3561 SalomeApp_Module::initialize( app );
3563 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3565 /* Automatic Update flag */
3566 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3568 // ----- create actions --------------
3570 //createSMESHAction( 111, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3571 createSMESHAction( 112, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3572 createSMESHAction( 113, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3573 createSMESHAction( 114, "NUM" );
3574 createSMESHAction( 115, "IMPORT_STL" );
3575 createSMESHAction( 116, "IMPORT_CGNS" );
3576 createSMESHAction( 117, "IMPORT_SAUV" );
3577 createSMESHAction( 118, "IMPORT_GMF" );
3578 createSMESHAction( 121, "DAT" );
3579 createSMESHAction( 122, "MED" );
3580 createSMESHAction( 123, "UNV" );
3581 createSMESHAction( 140, "STL" );
3582 createSMESHAction( 142, "CGNS");
3583 createSMESHAction( 144, "SAUV");
3584 createSMESHAction( 146, "GMF" );
3585 createSMESHAction( 124, "DAT" );
3586 createSMESHAction( 125, "MED" );
3587 createSMESHAction( 126, "UNV" );
3588 createSMESHAction( 141, "STL" );
3589 createSMESHAction( 143, "CGNS");
3590 createSMESHAction( 145, "SAUV");
3591 createSMESHAction( 147, "GMF" );
3592 createSMESHAction( 150, "FILE_INFO" );
3593 createSMESHAction( 33, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3594 createSMESHAction( 5105, "SEL_FILTER_LIB" );
3595 createSMESHAction( 701, "COMPUTE", "ICON_COMPUTE" );
3596 createSMESHAction( 702, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3597 createSMESHAction( 703, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3598 createSMESHAction( 704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3599 createSMESHAction( 705, "COPY_MESH", "ICON_COPY_MESH" );
3600 createSMESHAction( 710, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3601 createSMESHAction( 711, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3602 createSMESHAction( 712, "EVALUATE", "ICON_COMPUTE" );
3603 createSMESHAction( 713, "MESH_ORDER", "ICON_COMPUTE" );
3604 createSMESHAction( 806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3605 createSMESHAction( 801, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3606 createSMESHAction( 802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3607 createSMESHAction( 803, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3608 createSMESHAction( 815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3609 createSMESHAction( 804, "ADD" );
3610 createSMESHAction( 805, "REMOVE" );
3611 createSMESHAction( 810, "UN_GROUP", "ICON_UNION" );
3612 createSMESHAction( 811, "INT_GROUP", "ICON_INTERSECT" );
3613 createSMESHAction( 812, "CUT_GROUP", "ICON_CUT" );
3614 createSMESHAction( 814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3615 createSMESHAction( 813, "DEL_GROUP", "ICON_DEL_GROUP" );
3616 createSMESHAction( 900, "ADV_INFO", "ICON_ADV_INFO" );
3617 //createSMESHAction( 902, "STD_INFO", "ICON_STD_INFO" );
3618 //createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3619 createSMESHAction( 904, "FIND_ELEM", "ICON_FIND_ELEM" );
3620 createSMESHAction( 6001, "LENGTH", "ICON_LENGTH", 0, true );
3621 createSMESHAction( 6002, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3622 createSMESHAction( 6021, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3623 createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3624 createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3625 createSMESHAction( 6024, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3626 createSMESHAction( 6025, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3627 createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3628 createSMESHAction( 6027, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3629 createSMESHAction( 6028, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3630 createSMESHAction( 6029, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3631 createSMESHAction( 6030, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3632 createSMESHAction( 6031, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3633 createSMESHAction( 6003, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3634 createSMESHAction( 6004, "CONNECTION", "ICON_CONNECTION", 0, true );
3635 createSMESHAction( 6005, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3636 createSMESHAction( 6011, "AREA", "ICON_AREA", 0, true );
3637 createSMESHAction( 6012, "TAPER", "ICON_TAPER", 0, true );
3638 createSMESHAction( 6013, "ASPECT", "ICON_ASPECT", 0, true );
3639 createSMESHAction( 6014, "MIN_ANG", "ICON_ANGLE", 0, true );
3640 createSMESHAction( 6015, "WARP", "ICON_WARP", 0, true );
3641 createSMESHAction( 6016, "SKEW", "ICON_SKEW", 0, true );
3642 createSMESHAction( 6017, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3643 createSMESHAction( 6018, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3644 createSMESHAction( 6019, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3645 createSMESHAction( 6009, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3646 createSMESHAction( 4000, "NODE", "ICON_DLG_NODE" );
3647 createSMESHAction( 4009, "ELEM0D", "ICON_DLG_ELEM0D" );
3648 createSMESHAction( 4008, "BALL", "ICON_DLG_BALL" );
3649 createSMESHAction( 4010, "EDGE", "ICON_DLG_EDGE" );
3650 createSMESHAction( 4021, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3651 createSMESHAction( 4022, "QUAD", "ICON_DLG_QUADRANGLE" );
3652 createSMESHAction( 4023, "POLYGON", "ICON_DLG_POLYGON" );
3653 createSMESHAction( 4031, "TETRA", "ICON_DLG_TETRAS" );
3654 createSMESHAction( 4032, "HEXA", "ICON_DLG_HEXAS" );
3655 createSMESHAction( 4133, "PENTA", "ICON_DLG_PENTA" );
3656 createSMESHAction( 4134, "PYRAMID", "ICON_DLG_PYRAMID" );
3657 createSMESHAction( 4135, "OCTA", "ICON_DLG_OCTA" );
3658 createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3659 createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3660 createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3661 createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3662 createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3663 createSMESHAction( 4137, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3664 createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3665 createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3666 createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3667 createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3668 createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3669 createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3670 createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3671 createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3672 createSMESHAction( 4043, "CLEAR_MESH" , "ICON_CLEAR_MESH" );
3673 createSMESHAction( 4051, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3674 createSMESHAction( 4052, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3675 createSMESHAction( 4061, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3676 createSMESHAction( 4062, "ROT", "ICON_DLG_MESH_ROTATION" );
3677 createSMESHAction( 4063, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3678 createSMESHAction( 4064, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3679 createSMESHAction( 4065, "MERGE", "ICON_SMESH_MERGE_NODES" );
3680 createSMESHAction( 4066, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3681 createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3682 createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" );
3683 createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3684 createSMESHAction( 4070, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3685 createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" );
3686 createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" );
3687 createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3688 createSMESHAction( 410, "UNION", "ICON_UNIONTRI" );
3689 createSMESHAction( 411, "CUT", "ICON_CUTQUAD" );
3690 createSMESHAction( 412, "SMOOTH", "ICON_DLG_SMOOTHING" );
3691 createSMESHAction( 413, "EXTRUSION", "ICON_EXTRUSION" );
3692 createSMESHAction( 414, "REVOLUTION", "ICON_REVOLUTION" );
3693 createSMESHAction( 415, "MAP", "ICON_MAP" );
3694 createSMESHAction( 416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3695 createSMESHAction( 417, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3696 createSMESHAction( 418, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3697 createSMESHAction( 419, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3698 createSMESHAction( 420, "REORIENT_2D", "ICON_REORIENT_2D" );
3699 createSMESHAction( 200, "RESET" );
3700 createSMESHAction( 201, "SCALAR_BAR_PROP" );
3701 createSMESHAction( 2021, "SAVE_DISTRIBUTION" );
3702 createSMESHAction( 2022, "SHOW_DISTRIBUTION","",0, true );
3703 #ifndef DISABLE_PLOT2DVIEWER
3704 createSMESHAction( 2023, "PLOT_DISTRIBUTION" );
3706 createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true );
3707 createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true );
3708 createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true );
3709 createSMESHAction( 214, "UPDATE", "ICON_UPDATE" );
3710 createSMESHAction( 215, "NODES", "ICON_POINTS", 0, true );
3711 createSMESHAction( 222, "BALLS", "ICON_DLG_BALL", 0, true );
3712 createSMESHAction( 216, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3713 createSMESHAction( 217, "EDGES", "ICON_DLG_EDGE", 0, true );
3714 createSMESHAction( 218, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3715 createSMESHAction( 219, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3716 createSMESHAction( 220, "ALL" );
3717 createSMESHAction( 221, "FACE_ORIENTATION", "", 0, true );
3719 createSMESHAction( 231, "LINE_REPRESENTATION", "", 0, true );
3720 createSMESHAction( 232, "ARC_REPRESENTATION", "", 0, true );
3722 createSMESHAction( 1100, "EDIT_HYPO" );
3723 createSMESHAction( 1102, "UNASSIGN" );
3724 createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3725 createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3726 createSMESHAction( 1131, "DISPMODE" );
3727 createSMESHAction( 1132, "COLORS" );
3728 createSMESHAction( 1133, "TRANSP" );
3729 createSMESHAction( 1134, "CLIP" );
3730 createSMESHAction( 1135, "DISP_ENT" );
3731 createSMESHAction( 1136, "AUTO_COLOR" );
3732 createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3733 createSMESHAction( 2000, "CTRL" );
3735 createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3736 createSMESHAction( 502, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3738 createSMESHAction( 300, "HIDE" );
3739 createSMESHAction( 301, "SHOW" );
3740 createSMESHAction( 302, "DISPLAY_ONLY" );
3742 // ----- create menu --------------
3743 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3744 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3745 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3746 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3747 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3748 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3749 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3750 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3752 createMenu( separator(), fileId );
3754 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3755 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3756 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3757 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3758 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3759 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3760 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3761 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3762 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3763 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3765 //createMenu( 111, importId, -1 );
3766 createMenu( 112, importId, -1 );
3767 createMenu( 113, importId, -1 );
3768 createMenu( 115, importId, -1 );
3770 createMenu( 116, importId, -1 );
3772 createMenu( 117, importId, -1 );
3773 createMenu( 118, importId, -1 );
3774 createMenu( 121, exportId, -1 );
3775 createMenu( 122, exportId, -1 );
3776 createMenu( 123, exportId, -1 );
3777 createMenu( 140, exportId, -1 ); // export to STL
3779 createMenu( 142, exportId, -1 ); // export to CGNS
3781 createMenu( 144, exportId, -1 ); // export to SAUV
3782 createMenu( 146, exportId, -1 ); // export to GMF
3783 createMenu( separator(), fileId, 10 );
3785 createMenu( 33, editId, -1 );
3787 createMenu( 5105, toolsId, -1 );
3789 createMenu( 702, meshId, -1 ); // "Mesh" menu
3790 createMenu( 703, meshId, -1 );
3791 createMenu( 704, meshId, -1 );
3792 createMenu( 710, meshId, -1 );
3793 createMenu( 705, meshId, -1 );
3794 createMenu( separator(), meshId, -1 );
3795 createMenu( 701, meshId, -1 );
3796 createMenu( 711, meshId, -1 );
3797 createMenu( 712, meshId, -1 );
3798 createMenu( 713, meshId, -1 );
3799 createMenu( separator(), meshId, -1 );
3800 createMenu( 801, meshId, -1 );
3801 createMenu( 806, meshId, -1 );
3802 createMenu( 802, meshId, -1 );
3803 createMenu( 803, meshId, -1 );
3804 createMenu( 815, meshId, -1 );
3805 createMenu( separator(), meshId, -1 );
3806 createMenu( 810, meshId, -1 );
3807 createMenu( 811, meshId, -1 );
3808 createMenu( 812, meshId, -1 );
3809 createMenu( separator(), meshId, -1 );
3810 createMenu( 814, meshId, -1 );
3811 createMenu( separator(), meshId, -1 );
3812 createMenu( 900, meshId, -1 );
3813 //createMenu( 902, meshId, -1 );
3814 //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3815 createMenu( 904, meshId, -1 );
3816 createMenu( separator(), meshId, -1 );
3818 createMenu( 6005, nodeId, -1 );
3819 createMenu( 6028, nodeId, -1 );
3820 createMenu( 6002, edgeId, -1 );
3821 createMenu( 6003, edgeId, -1 );
3822 createMenu( 6001, edgeId, -1 );
3823 createMenu( 6004, edgeId, -1 );
3824 createMenu( 6029, edgeId, -1 );
3825 createMenu( 6021, faceId, -1 );
3826 createMenu( 6025, faceId, -1 );
3827 createMenu( 6027, faceId, -1 );
3828 createMenu( 6018, faceId, -1 );
3829 createMenu( 6019, faceId, -1 );
3830 createMenu( 6011, faceId, -1 );
3831 createMenu( 6012, faceId, -1 );
3832 createMenu( 6013, faceId, -1 );
3833 createMenu( 6014, faceId, -1 );
3834 createMenu( 6015, faceId, -1 );
3835 createMenu( 6016, faceId, -1 );
3836 createMenu( 6022, faceId, -1 );
3837 createMenu( 6030, faceId, -1 );
3838 createMenu( 6017, volumeId, -1 );
3839 createMenu( 6009, volumeId, -1 );
3840 createMenu( 6023, volumeId, -1 );
3841 createMenu( 6024, volumeId, -1 );
3842 createMenu( 6026, volumeId, -1 );
3843 createMenu( 6031, volumeId, -1 );
3845 createMenu( 4000, addId, -1 );
3846 createMenu( 4009, addId, -1 );
3847 createMenu( 4070, addId, -1 );
3848 createMenu( 4008, addId, -1 );
3849 createMenu( 4010, addId, -1 );
3850 createMenu( 4021, addId, -1 );
3851 createMenu( 4022, addId, -1 );
3852 createMenu( 4023, addId, -1 );
3853 createMenu( 4031, addId, -1 );
3854 createMenu( 4032, addId, -1 );
3855 createMenu( 4133, addId, -1 );
3856 createMenu( 4134, addId, -1 );
3857 createMenu( 4135, addId, -1 );
3858 createMenu( 4033, addId, -1 );
3859 createMenu( separator(), addId, -1 );
3860 createMenu( 4034, addId, -1 );
3861 createMenu( 4035, addId, -1 );
3862 createMenu( 4137, addId, -1 );
3863 createMenu( 4036, addId, -1 );
3864 createMenu( 4136, addId, -1 );
3865 createMenu( 4037, addId, -1 );
3866 createMenu( 4038, addId, -1 );
3867 createMenu( 4039, addId, -1 );
3868 createMenu( 4040, addId, -1 );
3869 createMenu( 4140, addId, -1 );
3871 createMenu( 4041, removeId, -1 );
3872 createMenu( 4042, removeId, -1 );
3873 createMenu( 4044, removeId, -1 );
3874 createMenu( separator(), removeId, -1 );
3875 createMenu( 813, removeId, -1 );
3876 createMenu( separator(), removeId, -1 );
3877 createMenu( 4043, removeId, -1 );
3879 createMenu( 4051, renumId, -1 );
3880 createMenu( 4052, renumId, -1 );
3882 createMenu( 4061, transfId, -1 );
3883 createMenu( 4062, transfId, -1 );
3884 createMenu( 4063, transfId, -1 );
3885 createMenu( 4068, transfId, -1 );
3886 createMenu( 4064, transfId, -1 );
3887 createMenu( 4065, transfId, -1 );
3888 createMenu( 4066, transfId, -1 );
3889 createMenu( 4069, transfId, -1 );
3891 createMenu( 4067,modifyId, -1 );
3892 createMenu( 407, modifyId, -1 );
3893 createMenu( 408, modifyId, -1 );
3894 createMenu( 409, modifyId, -1 );
3895 createMenu( 420, modifyId, -1 );
3896 createMenu( 410, modifyId, -1 );
3897 createMenu( 411, modifyId, -1 );
3898 createMenu( 419, modifyId, -1 );
3899 createMenu( 412, modifyId, -1 );
3900 createMenu( 413, modifyId, -1 );
3901 createMenu( 416, modifyId, -1 );
3902 createMenu( 414, modifyId, -1 );
3903 createMenu( 415, modifyId, -1 );
3904 createMenu( 417, modifyId, -1 );
3905 createMenu( 418, modifyId, -1 );
3907 createMenu( 501, measureId, -1 );
3908 createMenu( 502, measureId, -1 );
3909 createMenu( 214, viewId, -1 );
3911 // ----- create toolbars --------------
3912 int meshTb = createTool( tr( "TB_MESH" ) ),
3913 ctrlTb = createTool( tr( "TB_CTRL" ) ),
3914 addRemTb = createTool( tr( "TB_ADD_REMOVE" ) ),
3915 modifyTb = createTool( tr( "TB_MODIFY" ) ),
3916 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
3918 createTool( 702, meshTb );
3919 createTool( 703, meshTb );
3920 createTool( 704, meshTb );
3921 createTool( 710, meshTb );
3922 createTool( 705, meshTb );
3923 createTool( separator(), meshTb );
3924 createTool( 701, meshTb );
3925 createTool( 711, meshTb );
3926 createTool( 712, meshTb );
3927 createTool( 713, meshTb );
3928 createTool( separator(), meshTb );
3929 createTool( 801, meshTb );
3930 createTool( 806, meshTb );
3931 createTool( 802, meshTb );
3932 createTool( 803, meshTb );
3933 //createTool( 815, meshTb );
3934 createTool( separator(), meshTb );
3935 createTool( 900, meshTb );
3936 //createTool( 902, meshTb );
3937 //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3938 createTool( 904, meshTb );
3939 createTool( separator(), meshTb );
3941 createTool( 6005, ctrlTb );
3942 createTool( 6028, ctrlTb );
3943 createTool( separator(), ctrlTb );
3944 createTool( 6002, ctrlTb );
3945 createTool( 6003, ctrlTb );
3946 createTool( 6001, ctrlTb );
3947 createTool( 6004, ctrlTb );
3948 createTool( 6029, ctrlTb );
3949 createTool( separator(), ctrlTb );
3950 createTool( 6021, ctrlTb );
3951 createTool( 6025, ctrlTb );
3952 createTool( 6027, ctrlTb );
3953 createTool( 6018, ctrlTb );
3954 createTool( 6019, ctrlTb );
3955 createTool( 6011, ctrlTb );
3956 createTool( 6012, ctrlTb );
3957 createTool( 6013, ctrlTb );
3958 createTool( 6014, ctrlTb );
3959 createTool( 6015, ctrlTb );
3960 createTool( 6016, ctrlTb );
3961 createTool( 6022, ctrlTb );
3962 createTool( 6030, ctrlTb );
3963 createTool( separator(), ctrlTb );
3964 createTool( 6017, ctrlTb );
3965 createTool( 6009, ctrlTb );
3966 createTool( 6023, ctrlTb );
3967 createTool( 6024, ctrlTb );
3968 createTool( 6026, ctrlTb );
3969 createTool( 6031, ctrlTb );
3970 createTool( separator(), ctrlTb );
3972 createTool( 4000, addRemTb );
3973 createTool( 4009, addRemTb );
3974 createTool( 4070, addRemTb );
3975 createTool( 4008, addRemTb );
3976 createTool( 4010, addRemTb );
3977 createTool( 4021, addRemTb );
3978 createTool( 4022, addRemTb );
3979 createTool( 4023, addRemTb );
3980 createTool( 4031, addRemTb );
3981 createTool( 4032, addRemTb );
3982 createTool( 4133, addRemTb );
3983 createTool( 4134, addRemTb );
3984 createTool( 4135, addRemTb );
3985 createTool( 4033, addRemTb );
3986 createTool( separator(), addRemTb );
3987 createTool( 4034, addRemTb );
3988 createTool( 4035, addRemTb );
3989 createTool( 4137, addRemTb );
3990 createTool( 4036, addRemTb );
3991 createTool( 4136, addRemTb );
3992 createTool( 4037, addRemTb );
3993 createTool( 4038, addRemTb );
3994 createTool( 4039, addRemTb );
3995 createTool( 4040, addRemTb );
3996 createTool( 4140, addRemTb );
3997 createTool( separator(), addRemTb );
3998 createTool( 4041, addRemTb );
3999 createTool( 4042, addRemTb );
4000 createTool( 4044, addRemTb );
4001 createTool( 4043, addRemTb );
4002 createTool( separator(), addRemTb );
4003 createTool( 4051, addRemTb );
4004 createTool( 4052, addRemTb );
4005 createTool( separator(), addRemTb );
4006 createTool( 4061, addRemTb );
4007 createTool( 4062, addRemTb );
4008 createTool( 4063, addRemTb );
4009 createTool( 4068, addRemTb );
4010 createTool( 4064, addRemTb );
4011 createTool( 4065, addRemTb );
4012 createTool( 4066, addRemTb );
4013 createTool( 4069, addRemTb );
4014 createTool( separator(), addRemTb );
4016 createTool( 4067,modifyTb );
4017 createTool( 407, modifyTb );
4018 createTool( 408, modifyTb );
4019 createTool( 409, modifyTb );
4020 createTool( 420, modifyTb );
4021 createTool( 410, modifyTb );
4022 createTool( 411, modifyTb );
4023 createTool( 419, modifyTb );
4024 createTool( 412, modifyTb );
4025 createTool( 413, modifyTb );
4026 createTool( 416, modifyTb );
4027 createTool( 414, modifyTb );
4028 createTool( 415, modifyTb );
4029 createTool( 417, modifyTb );
4030 createTool( 418, modifyTb );
4032 createTool( 214, dispModeTb );
4034 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4035 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4038 QString OB = "'ObjectBrowser'",
4039 View = "'" + SVTK_Viewer::Type() + "'",
4041 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4042 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4043 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4044 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4045 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4046 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4047 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4048 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4049 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4050 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4051 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4053 mesh_part = mesh + " " + subMesh + " " + group,
4054 mesh_group = mesh + " " + group,
4055 hyp_alg = hypo + " " + algo;
4057 // popup for object browser
4059 isInvisible("not( isVisible )"),
4060 isEmpty("numberOfNodes = 0"),
4061 isNotEmpty("numberOfNodes <> 0"),
4063 // has nodes, edges, etc in VISIBLE! actor
4064 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4065 hasElems("(count( elemTypes ) > 0)"),
4066 hasDifferentElems("(count( elemTypes ) > 1)"),
4067 hasBalls("({'BallElem'} in elemTypes)"),
4068 hasElems0d("({'Elem0d'} in elemTypes)"),
4069 hasEdges("({'Edge'} in elemTypes)"),
4070 hasFaces("({'Face'} in elemTypes)"),
4071 hasVolumes("({'Volume'} in elemTypes)");
4073 createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
4074 createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
4075 createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
4076 createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
4077 createPopupItem( 803, OB, group ); // EDIT_GROUP
4078 createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
4080 popupMgr()->insert( separator(), -1, 0 );
4081 createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
4082 createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
4083 createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
4084 createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
4085 createPopupItem( 214, OB, mesh_part ); // UPDATE
4086 createPopupItem( 900, OB, mesh_part ); // ADV_INFO
4087 createPopupItem( 904, OB, mesh_group ); // FIND_ELEM
4088 popupMgr()->insert( separator(), -1, 0 );
4089 createPopupItem( 801, OB, mesh ); // CREATE_GROUP
4090 createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
4091 createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
4092 popupMgr()->insert( separator(), -1, 0 );
4093 createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
4094 createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4095 popupMgr()->insert( separator(), -1, 0 );
4096 createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
4097 popupMgr()->insert( separator(), -1, 0 );
4098 createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
4099 createPopupItem( 418, OB, mesh + " " + group, // create 2D mesh from 3D
4101 popupMgr()->insert( separator(), -1, 0 );
4103 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4104 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4105 QString only_one_2D = only_one_non_empty + " && dim>1";
4107 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4108 createPopupItem( 125, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_MED
4109 createPopupItem( 126, OB, mesh_group, only_one_non_empty, anId ); // EXPORT_UNV
4110 createPopupItem( 141, OB, mesh_group, only_one_2D, anId ); // EXPORT_STL
4112 createPopupItem( 143, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_CGNS
4114 createPopupItem( 145, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_SAUV
4115 createPopupItem( 147, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_GMF
4116 createPopupItem( 124, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_DAT
4117 createPopupItem( 33, OB, mesh_part + " " + hyp_alg ); // DELETE
4118 createPopupItem( 813, OB, group ); // DEL_GROUP with contents
4119 popupMgr()->insert( separator(), -1, 0 );
4122 createPopupItem( 803, View, group ); // EDIT_GROUP
4123 createPopupItem( 804, View, elems ); // ADD
4124 createPopupItem( 805, View, elems ); // REMOVE
4126 popupMgr()->insert( separator(), -1, 0 );
4127 createPopupItem( 214, View, mesh_part ); // UPDATE
4128 createPopupItem( 900, View, mesh_part ); // ADV_INFO
4129 createPopupItem( 904, View, mesh ); // FIND_ELEM
4130 popupMgr()->insert( separator(), -1, 0 );
4132 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
4133 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
4134 popupMgr()->insert( separator(), -1, 0 );
4136 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4137 QString aType = QString( "%1type in {%2}" ).arg( lc );
4138 aType = aType.arg( mesh_part );
4139 QString aMeshInVTK = aClient + "&&" + aType;
4141 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4142 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4143 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4145 //-------------------------------------------------
4147 //-------------------------------------------------
4148 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4150 popupMgr()->insert( action( 9010 ), anId, -1 );
4151 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4152 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4154 popupMgr()->insert( action( 9011 ), anId, -1 );
4155 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4156 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4158 popupMgr()->insert( separator(), -1, -1 );
4160 //-------------------------------------------------
4162 //-------------------------------------------------
4163 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4165 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4166 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4167 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4169 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4170 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4171 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4173 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4174 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4175 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4177 popupMgr()->insert( separator(), anId, -1 );
4179 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4180 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4181 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4183 //-------------------------------------------------
4185 //-------------------------------------------------
4186 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4188 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4190 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4191 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4192 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4194 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4195 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4196 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4198 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4199 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4200 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4202 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4203 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4204 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4206 popupMgr()->insert( action( 222 ), anId, -1 ); // BALLS
4207 popupMgr()->setRule( action( 222 ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4208 popupMgr()->setRule( action( 222 ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4210 popupMgr()->insert( separator(), anId, -1 );
4212 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4213 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4216 //-------------------------------------------------
4217 // Representation of the 2D Quadratic elements
4218 //-------------------------------------------------
4219 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4220 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4221 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4222 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4224 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4225 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4226 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4228 //-------------------------------------------------
4229 // Orientation of faces
4230 //-------------------------------------------------
4231 popupMgr()->insert( action( 221 ), -1, -1 );
4232 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4233 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4235 //-------------------------------------------------
4237 //-------------------------------------------------
4238 popupMgr()->insert( action( 1132 ), -1, -1 );
4239 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4241 //-------------------------------------------------
4243 //-------------------------------------------------
4244 popupMgr()->insert( action( 1133 ), -1, -1 );
4245 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4247 //-------------------------------------------------
4249 //-------------------------------------------------
4251 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4252 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4253 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4254 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4256 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4258 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4259 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4261 popupMgr()->insert( separator(), anId, -1 );
4263 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4265 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4266 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4267 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4269 popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4270 popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4271 popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4273 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4275 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4276 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4277 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4279 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4280 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4281 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4283 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4284 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4285 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4287 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4288 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4289 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4290 popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4291 popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4292 popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4294 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4296 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4297 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4298 QtxPopupMgr::VisibleRule );
4299 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4301 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4302 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4303 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4305 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4306 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4307 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4309 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4310 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4311 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4313 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4314 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4315 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4317 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4318 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4319 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4321 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4322 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4323 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4325 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4326 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4327 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4329 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4330 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4331 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4333 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4334 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4335 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4337 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4338 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4339 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4341 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4342 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4343 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4344 popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4345 popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4346 popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4348 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4350 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4351 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4352 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4354 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4355 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4356 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4358 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4359 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4360 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4362 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4363 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4364 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4366 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4367 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4368 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4370 popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4371 popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4372 popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4374 popupMgr()->insert( separator(), anId, -1 );
4376 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4377 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4379 popupMgr()->insert( separator(), anId, -1 );
4381 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4383 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4384 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4386 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4387 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4388 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4390 #ifndef DISABLE_PLOT2DVIEWER
4391 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4392 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4395 //-------------------------------------------------
4397 //-------------------------------------------------
4398 popupMgr()->insert( separator(), -1, -1 );
4399 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4400 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4401 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4402 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4404 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4405 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4407 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4408 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4410 popupMgr()->insert( separator(), -1, -1 );
4412 //-------------------------------------------------
4414 //-------------------------------------------------
4415 popupMgr()->insert( action( 1134 ), -1, -1 );
4416 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4418 popupMgr()->insert( separator(), -1, -1 );
4420 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4421 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4423 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4424 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4427 //================================================================================
4429 * \brief Return true if SMESH or GEOM objects are selected.
4430 * Is called form LightApp_Module::activateModule() which clear selection if
4431 * not isSelectionCompatible()
4433 //================================================================================
4435 bool SMESHGUI::isSelectionCompatible()
4437 bool isCompatible = true;
4438 SALOME_ListIO selected;
4439 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4440 Sel->selectedObjects( selected );
4442 SALOME_ListIteratorOfListIO It( selected );
4443 for ( ; isCompatible && It.More(); It.Next())
4445 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4446 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4448 return isCompatible;
4452 bool SMESHGUI::reusableOperation( const int id )
4454 // compute, evaluate and precompute are not reusable operations
4455 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4458 bool SMESHGUI::activateModule( SUIT_Study* study )
4460 bool res = SalomeApp_Module::activateModule( study );
4462 setMenuShown( true );
4463 setToolShown( true );
4465 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4466 PyGILState_STATE gstate = PyGILState_Ensure();
4467 PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4468 if(pluginsmanager==NULL)
4472 PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4477 PyGILState_Release(gstate);
4478 // end of GEOM plugins loading
4480 // Reset actions accelerator keys
4481 //action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4482 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4483 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4485 action( 33)->setEnabled(true); // Delete: Key_Delete
4487 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4488 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4489 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4490 if ( _PTR(Study) aStudy = s->studyDS()) {
4491 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4492 updateObjBrowser(); // objects can be removed
4495 // get all view currently opened in the study and connect their signals to
4496 // the corresponding slots of the class.
4497 SUIT_Desktop* aDesk = study->application()->desktop();
4499 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4500 SUIT_ViewWindow* wnd;
4501 foreach ( wnd, wndList )
4508 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4510 setMenuShown( false );
4511 setToolShown( false );
4513 EmitSignalCloseAllDialogs();
4515 // Unset actions accelerator keys
4516 //action(111)->setShortcut(QKeySequence()); // Import DAT
4517 action(112)->setShortcut(QKeySequence()); // Import UNV
4518 action(113)->setShortcut(QKeySequence()); // Import MED
4520 action( 33)->setEnabled(false); // Delete: Key_Delete
4522 return SalomeApp_Module::deactivateModule( study );
4525 void SMESHGUI::studyClosed( SUIT_Study* s )
4527 SMESH::RemoveVisuData( s->id() );
4528 SalomeApp_Module::studyClosed( s );
4531 void SMESHGUI::OnGUIEvent()
4533 const QObject* obj = sender();
4534 if ( !obj || !obj->inherits( "QAction" ) )
4536 int id = actionId((QAction*)obj);
4541 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4543 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4544 if ( CORBA::is_nil( myComponentSMESH ) )
4546 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4548 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4549 return aGUI.myComponentSMESH;
4552 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4553 return myComponentSMESH;
4556 QString SMESHGUI::engineIOR() const
4558 CORBA::ORB_var anORB = getApp()->orb();
4559 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4560 return QString( anIOR.in() );
4563 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4565 SalomeApp_Module::contextMenuPopup( client, menu, title );
4567 selectionMgr()->selectedObjects( lst );
4568 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4569 Handle(SALOME_InteractiveObject) io = lst.First();
4570 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4571 _PTR(Study) study = appStudy->studyDS();
4572 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4574 QString aName = QString( obj->GetName().c_str() );
4575 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4576 aName.remove( (aName.length() - 1), 1 );
4582 LightApp_Selection* SMESHGUI::createSelection() const
4584 return new SMESHGUI_Selection();
4587 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4589 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4590 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4593 void SMESHGUI::viewManagers( QStringList& list ) const
4595 list.append( SVTK_Viewer::Type() );
4598 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4600 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4601 SMESH::UpdateSelectionProp( this );
4603 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4604 for(int i = 0; i < aViews.count() ; i++){
4605 SUIT_ViewWindow *sf = aViews[i];
4611 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4613 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4614 myClippingPlaneInfoMap.erase( theViewManager );
4617 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4619 theActor->AddObserver( SMESH::DeleteActorEvent,
4620 myEventCallbackCommand.GetPointer(),
4624 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4625 unsigned long theEvent,
4626 void* theClientData,
4629 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4630 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4631 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4632 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4633 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4634 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4635 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4636 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4637 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4638 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4639 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4640 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4641 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4642 if( anActor == *anIter3 ) {
4643 anActorList.erase( anIter3 );
4654 void SMESHGUI::createPreferences()
4656 // General tab ------------------------------------------------------------------------
4657 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4659 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4660 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4661 setPreferenceProperty( lim, "min", 0 );
4662 setPreferenceProperty( lim, "max", 100000000 );
4663 setPreferenceProperty( lim, "step", 1000 );
4664 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4666 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4667 setPreferenceProperty( qaGroup, "columns", 2 );
4668 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4669 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4670 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4671 setPreferenceProperty( prec, "min", 0 );
4672 setPreferenceProperty( prec, "max", 16 );
4673 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4674 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4675 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4676 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4677 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4679 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4680 setPreferenceProperty( dispgroup, "columns", 2 );
4681 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4683 modes.append( tr("MEN_WIRE") );
4684 modes.append( tr("MEN_SHADE") );
4685 modes.append( tr("MEN_NODES") );
4686 modes.append( tr("MEN_SHRINK") );
4687 QList<QVariant> indices;
4688 indices.append( 0 );
4689 indices.append( 1 );
4690 indices.append( 2 );
4691 indices.append( 3 );
4692 setPreferenceProperty( dispmode, "strings", modes );
4693 setPreferenceProperty( dispmode, "indexes", indices );
4695 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4696 setPreferenceProperty( arcgroup, "columns", 2 );
4697 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4698 QStringList quadraticModes;
4699 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4700 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4702 indices.append( 0 );
4703 indices.append( 1 );
4704 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4705 setPreferenceProperty( quadraticmode, "indexes", indices );
4707 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4708 "SMESH", "max_angle" );
4709 setPreferenceProperty( maxAngle, "min", 1 );
4710 setPreferenceProperty( maxAngle, "max", 90 );
4714 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4715 setPreferenceProperty( exportgroup, "columns", 2 );
4716 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4717 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4719 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4720 setPreferenceProperty( computeGroup, "columns", 2 );
4721 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4723 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4724 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4725 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4727 indices.append( 0 );
4728 indices.append( 1 );
4729 indices.append( 2 );
4730 setPreferenceProperty( notifyMode, "strings", modes );
4731 setPreferenceProperty( notifyMode, "indexes", indices );
4733 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4734 setPreferenceProperty( infoGroup, "columns", 2 );
4735 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4737 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4738 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4740 indices.append( 0 );
4741 indices.append( 1 );
4742 setPreferenceProperty( elemInfo, "strings", modes );
4743 setPreferenceProperty( elemInfo, "indexes", indices );
4744 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4745 setPreferenceProperty( nodesLim, "min", 0 );
4746 setPreferenceProperty( nodesLim, "max", 10000000 );
4747 setPreferenceProperty( nodesLim, "step", 10000 );
4748 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4749 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
4750 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
4751 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
4752 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
4754 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4755 setPreferenceProperty( segGroup, "columns", 2 );
4756 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4757 "SMESH", "segmentation" );
4758 setPreferenceProperty( segLen, "min", 1 );
4759 setPreferenceProperty( segLen, "max", 10000000 );
4760 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4761 "SMESH", "nb_segments_per_edge" );
4762 setPreferenceProperty( nbSeg, "min", 1 );
4763 setPreferenceProperty( nbSeg, "max", 10000000 );
4765 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4766 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4767 "SMESH", "forget_mesh_on_hyp_modif" );
4770 // Quantities with individual precision settings
4771 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4772 setPreferenceProperty( precGroup, "columns", 2 );
4774 const int nbQuantities = 6;
4775 int precs[nbQuantities], ii = 0;
4776 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4777 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4778 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4779 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4780 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4781 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4782 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4783 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4784 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4785 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4786 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4787 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4789 // Set property for precision value for spinboxes
4790 for ( ii = 0; ii < nbQuantities; ii++ ){
4791 setPreferenceProperty( precs[ii], "min", -14 );
4792 setPreferenceProperty( precs[ii], "max", 14 );
4793 setPreferenceProperty( precs[ii], "precision", 2 );
4796 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4797 setPreferenceProperty( previewGroup, "columns", 2 );
4798 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4799 setPreferenceProperty( chunkSize, "min", 1 );
4800 setPreferenceProperty( chunkSize, "max", 1000 );
4801 setPreferenceProperty( chunkSize, "step", 50 );
4803 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4804 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4806 // Mesh tab ------------------------------------------------------------------------
4807 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4808 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4809 setPreferenceProperty( nodeGroup, "columns", 3 );
4811 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4813 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4815 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4816 QList<QVariant> aMarkerTypeIndicesList;
4817 QList<QVariant> aMarkerTypeIconsList;
4818 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4819 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4820 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4821 aMarkerTypeIndicesList << i;
4822 aMarkerTypeIconsList << pixmap;
4824 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4825 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4827 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4829 QList<QVariant> aMarkerScaleIndicesList;
4830 QStringList aMarkerScaleValuesList;
4831 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4832 aMarkerScaleIndicesList << i;
4833 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4835 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4836 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4838 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4839 //setPreferenceProperty( elemGroup, "columns", 2 );
4841 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4842 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4843 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
4844 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
4845 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4846 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
4847 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4848 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4851 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4852 setPreferenceProperty( grpGroup, "columns", 2 );
4854 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4855 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
4857 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4858 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4859 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
4860 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
4861 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4862 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4863 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
4864 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
4865 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4866 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4868 setPreferenceProperty( size0d, "min", 1 );
4869 setPreferenceProperty( size0d, "max", 10 );
4871 setPreferenceProperty( ballSize, "min", 1 );
4872 setPreferenceProperty( ballSize, "max", 10 );
4874 setPreferenceProperty( elemW, "min", 1 );
4875 setPreferenceProperty( elemW, "max", 5 );
4877 setPreferenceProperty( outW, "min", 1 );
4878 setPreferenceProperty( outW, "max", 5 );
4880 setPreferenceProperty( shrink, "min", 0 );
4881 setPreferenceProperty( shrink, "max", 100 );
4883 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
4884 setPreferenceProperty( numGroup, "columns", 2 );
4886 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
4887 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
4889 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
4890 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
4892 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4893 setPreferenceProperty( orientGroup, "columns", 1 );
4895 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4896 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4898 setPreferenceProperty( orientScale, "min", 0.05 );
4899 setPreferenceProperty( orientScale, "max", 0.5 );
4900 setPreferenceProperty( orientScale, "step", 0.05 );
4902 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4904 // Selection tab ------------------------------------------------------------------------
4905 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4907 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4908 setPreferenceProperty( selGroup, "columns", 2 );
4910 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4911 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4913 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4914 setPreferenceProperty( preGroup, "columns", 2 );
4916 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4918 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4919 setPreferenceProperty( precSelGroup, "columns", 2 );
4921 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4922 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4923 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4925 // Scalar Bar tab ------------------------------------------------------------------------
4926 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4927 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4928 setPreferenceProperty( fontGr, "columns", 2 );
4930 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4931 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4933 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4934 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4936 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4937 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4939 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4940 setPreferenceProperty( numcol, "min", 2 );
4941 setPreferenceProperty( numcol, "max", 256 );
4943 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4944 setPreferenceProperty( numlab, "min", 2 );
4945 setPreferenceProperty( numlab, "max", 65 );
4947 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4948 setPreferenceProperty( orientGr, "columns", 2 );
4949 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4950 QStringList orients;
4951 orients.append( tr( "SMESH_VERTICAL" ) );
4952 orients.append( tr( "SMESH_HORIZONTAL" ) );
4953 indices.clear(); indices.append( 0 ); indices.append( 1 );
4954 setPreferenceProperty( orient, "strings", orients );
4955 setPreferenceProperty( orient, "indexes", indices );
4957 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4958 setPreferenceProperty( posVSizeGr, "columns", 2 );
4959 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4960 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4961 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4962 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4963 setPreferenceProperty( xv, "step", 0.1 );
4964 setPreferenceProperty( xv, "min", 0.0 );
4965 setPreferenceProperty( xv, "max", 1.0 );
4966 setPreferenceProperty( yv, "step", 0.1 );
4967 setPreferenceProperty( yv, "min", 0.0 );
4968 setPreferenceProperty( yv, "max", 1.0 );
4969 setPreferenceProperty( wv, "step", 0.1 );
4970 setPreferenceProperty( wv, "min", 0.0 );
4971 setPreferenceProperty( wv, "max", 1.0 );
4972 setPreferenceProperty( hv, "min", 0.0 );
4973 setPreferenceProperty( hv, "max", 1.0 );
4974 setPreferenceProperty( hv, "step", 0.1 );
4976 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
4977 setPreferenceProperty( posHSizeGr, "columns", 2 );
4978 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
4979 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
4980 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
4981 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
4982 setPreferenceProperty( xv, "min", 0.0 );
4983 setPreferenceProperty( xv, "max", 1.0 );
4984 setPreferenceProperty( xv, "step", 0.1 );
4985 setPreferenceProperty( xh, "min", 0.0 );
4986 setPreferenceProperty( xh, "max", 1.0 );
4987 setPreferenceProperty( xh, "step", 0.1 );
4988 setPreferenceProperty( yh, "min", 0.0 );
4989 setPreferenceProperty( yh, "max", 1.0 );
4990 setPreferenceProperty( yh, "step", 0.1 );
4991 setPreferenceProperty( wh, "min", 0.0 );
4992 setPreferenceProperty( wh, "max", 1.0 );
4993 setPreferenceProperty( wh, "step", 0.1 );
4994 setPreferenceProperty( hh, "min", 0.0 );
4995 setPreferenceProperty( hh, "max", 1.0 );
4996 setPreferenceProperty( hh, "step", 0.1 );
4998 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
4999 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5000 setPreferenceProperty( distributionGr, "columns", 3 );
5002 types.append( tr( "SMESH_MONOCOLOR" ) );
5003 types.append( tr( "SMESH_MULTICOLOR" ) );
5004 indices.clear(); indices.append( 0 ); indices.append( 1 );
5005 setPreferenceProperty( coloringType, "strings", types );
5006 setPreferenceProperty( coloringType, "indexes", indices );
5007 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5011 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5013 if( sect=="SMESH" ) {
5014 float sbX1,sbY1,sbW,sbH;
5015 float aTol = 1.00000009999999;
5016 std::string aWarning;
5017 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5018 if( name=="selection_object_color" || name=="selection_element_color" ||
5019 name=="highlight_color" ||
5020 name=="selection_precision_node" || name=="selection_precision_element" ||
5021 name=="selection_precision_object")
5022 SMESH::UpdateSelectionProp( this );
5023 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5024 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5025 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5026 if(sbX1+sbW > aTol){
5027 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5030 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5031 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5034 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5035 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5036 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5037 if(sbY1+sbH > aTol){
5038 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5039 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5040 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5043 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5044 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5045 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5046 if(sbX1+sbW > aTol){
5047 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5050 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5051 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5054 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5055 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5056 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5057 if(sbY1+sbH > aTol){
5058 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5061 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5062 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5065 else if ( name == "segmentation" ) {
5066 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5067 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5069 else if ( name == "nb_segments_per_edge" ) {
5070 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5071 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5073 else if ( name == "historical_python_dump" ||
5074 name == "forget_mesh_on_hyp_modif") {
5075 QString val = aResourceMgr->stringValue( "SMESH", name );
5076 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5078 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5079 SMESH::UpdateFontProp( this );
5081 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5082 SMESH::UpdateFontProp( this );
5085 if(aWarning.size() != 0){
5086 aWarning += "The default values are applied instead.";
5087 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5088 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5089 QObject::tr(aWarning.c_str()));
5094 //================================================================================
5096 * \brief Update something in accordance with update flags
5097 * \param theFlags - update flags
5099 * Update viewer or/and object browser etc. in accordance with update flags ( see
5100 * LightApp_UpdateFlags enumeration ).
5102 //================================================================================
5103 void SMESHGUI::update( const int flags )
5105 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5106 SMESH::UpdateView();
5108 SalomeApp_Module::update( flags );
5111 //================================================================================
5113 * \brief Set default selection mode
5115 * SLOT called when operation commited. Sets default selection mode
5117 //================================================================================
5118 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5120 SVTK_ViewWindow* vtkWnd =
5121 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5123 vtkWnd->SetSelectionMode( ActorSelection );
5126 //================================================================================
5128 * \brief Set default selection mode
5130 * SLOT called when operation aborted. Sets default selection mode
5132 //================================================================================
5133 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5135 SVTK_ViewWindow* vtkWnd =
5136 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5138 vtkWnd->SetSelectionMode( ActorSelection );
5141 //================================================================================
5143 * \brief Creates operation with given identifier
5144 * \param id - identifier of operation to be started
5145 * \return Pointer on created operation or NULL if operation is not created
5147 * Virtual method redefined from the base class creates operation with given id.
5148 * It is called called automatically from startOperation method of base class.
5150 //================================================================================
5151 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5153 LightApp_Operation* op = 0;
5154 // to do : create operation here
5157 case 417: //convert to quadratic
5158 op = new SMESHGUI_ConvToQuadOp();
5160 case 418: // create 2D mesh as boundary on 3D
5161 op = new SMESHGUI_Make2DFrom3DOp();
5163 case 420: // Reorient faces
5164 op = new SMESHGUI_ReorientFacesOp();
5166 case 701: // Compute mesh
5167 op = new SMESHGUI_ComputeOp();
5169 case 702: // Create mesh
5170 op = new SMESHGUI_MeshOp( true, true );
5172 case 703: // Create sub-mesh
5173 op = new SMESHGUI_MeshOp( true, false );
5175 case 704: // Edit mesh/sub-mesh
5176 op = new SMESHGUI_MeshOp( false );
5178 case 711: // Precompute mesh
5179 op = new SMESHGUI_PrecomputeOp();
5181 case 712: // Evaluate mesh
5182 op = new SMESHGUI_EvaluateOp();
5184 case 713: // Evaluate mesh
5185 op = new SMESHGUI_MeshOrderOp();
5187 case 806: // Create group on geom
5188 op = new SMESHGUI_GroupOnShapeOp();
5190 case 904: // Find element
5191 op = new SMESHGUI_FindElemByPointOp();
5193 case 4067: // Make mesh pass through point
5194 op = new SMESHGUI_MakeNodeAtPointOp();
5196 case 4070: // Create 0D elements on all nodes
5197 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5204 op = SalomeApp_Module::createOperation( id );
5208 //================================================================================
5210 * \brief Stops current operations and starts a given one
5211 * \param id - The id of the operation to start
5213 //================================================================================
5215 void SMESHGUI::switchToOperation(int id)
5217 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5218 activeStudy()->abortAllOperations();
5219 startOperation( id );
5222 LightApp_Displayer* SMESHGUI::displayer()
5225 myDisplayer = new SMESHGUI_Displayer( getApp() );
5229 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5232 int aTolerance = 64;
5233 int anIterations = 0;
5239 if( anIterations % aPeriod == 0 )
5242 if( aTolerance < 1 )
5246 aHue = (int)( 360.0 * rand() / RAND_MAX );
5249 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5250 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5251 for( ; it != itEnd; ++it )
5253 SALOMEDS::Color anAutoColor = *it;
5254 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5257 aQColor.getHsv( &h, &s, &v );
5258 if( abs( h - aHue ) < aTolerance )
5270 aColor.setHsv( aHue, 255, 255 );
5272 SALOMEDS::Color aSColor;
5273 aSColor.R = aColor.redF();
5274 aSColor.G = aColor.greenF();
5275 aSColor.B = aColor.blueF();
5280 const char* gSeparator = "_"; // character used to separate parameter names
5281 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5282 const char* gPathSep = "|"; // character used to separate paths
5285 * \brief Store visual parameters
5287 * This method is called just before the study document is saved.
5288 * Store visual parameters in AttributeParameter attribue(s)
5290 void SMESHGUI::storeVisualParameters (int savePoint)
5293 Kernel_Utils::Localizer loc;
5295 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5296 if (!appStudy || !appStudy->studyDS())
5298 _PTR(Study) studyDS = appStudy->studyDS();
5300 // componentName is used for encoding of entries when storing them in IParameters
5301 std::string componentName = myComponentSMESH->ComponentDataType();
5302 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5303 //if (!aSComponent) return;
5306 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5307 componentName.c_str(),
5309 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5311 // store map of custom markers
5312 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5313 if( !aMarkerMap.empty() )
5315 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5316 for( ; anIter != aMarkerMap.end(); anIter++ )
5318 int anId = anIter->first;
5319 VTK::MarkerData aMarkerData = anIter->second;
5320 std::string aMarkerFileName = aMarkerData.first;
5321 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5322 if( aMarkerTexture.size() < 3 )
5323 continue; // should contain at least width, height and the first value
5325 QString aPropertyName( "texture" );
5326 aPropertyName += gSeparator;
5327 aPropertyName += QString::number( anId );
5329 QString aPropertyValue = aMarkerFileName.c_str();
5330 aPropertyValue += gPathSep;
5332 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5333 ushort aWidth = *aTextureIter++;
5334 ushort aHeight = *aTextureIter++;
5335 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5336 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5337 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5338 aPropertyValue += QString::number( *aTextureIter );
5340 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5344 // viewers counters are used for storing view_numbers in IParameters
5347 // main cycle to store parameters of displayed objects
5348 QList<SUIT_ViewManager*> lst;
5349 QList<SUIT_ViewManager*>::Iterator it;
5350 getApp()->viewManagers(lst);
5351 for (it = lst.begin(); it != lst.end(); it++)
5353 SUIT_ViewManager* vman = *it;
5354 QString vType = vman->getType();
5356 // saving VTK actors properties
5357 if (vType == SVTK_Viewer::Type())
5359 // store the clipping planes attached to the view manager
5360 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5361 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5362 if( anIter != myClippingPlaneInfoMap.end() )
5363 aClippingPlaneInfoList = anIter->second;
5365 if( !aClippingPlaneInfoList.empty() ) {
5366 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5367 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5369 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5370 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5372 QString aPropertyName( "ClippingPlane" );
5373 aPropertyName += gSeparator;
5374 aPropertyName += QString::number( vtkViewers );
5375 aPropertyName += gSeparator;
5376 aPropertyName += QString::number( anId );
5378 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5379 aPropertyValue += gDigitsSep;
5380 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5381 aPropertyValue += gDigitsSep;
5382 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5383 aPropertyValue += gDigitsSep;
5384 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5386 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5390 QVector<SUIT_ViewWindow*> views = vman->getViews();
5391 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5393 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5395 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5396 vtkActorCollection* allActors = aCopy.GetActors();
5397 allActors->InitTraversal();
5398 while (vtkActor* actor = allActors->GetNextActor())
5400 if (actor->GetVisibility()) // store only visible actors
5402 SMESH_Actor* aSmeshActor = 0;
5403 if (actor->IsA("SMESH_Actor"))
5404 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5405 if (aSmeshActor && aSmeshActor->hasIO())
5407 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5410 // entry is "encoded" = it does NOT contain component adress,
5411 // since it is a subject to change on next component loading
5412 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5414 std::string param, vtkParam = vType.toLatin1().data();
5415 vtkParam += gSeparator;
5416 vtkParam += QString::number(vtkViewers).toLatin1().data();
5417 vtkParam += gSeparator;
5420 param = vtkParam + "Visibility";
5421 ip->setParameter(entry, param, "On");
5424 param = vtkParam + "Representation";
5425 ip->setParameter(entry, param, QString::number
5426 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5429 param = vtkParam + "IsShrunk";
5430 ip->setParameter(entry, param, QString::number
5431 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5433 // Displayed entities
5434 unsigned int aMode = aSmeshActor->GetEntityMode();
5435 bool isE = aMode & SMESH_Actor::eEdges;
5436 bool isF = aMode & SMESH_Actor::eFaces;
5437 bool isV = aMode & SMESH_Actor::eVolumes;
5438 bool is0d = aMode & SMESH_Actor::e0DElements;
5439 bool isB = aMode & SMESH_Actor::eBallElem;
5441 QString modeStr ("e");
5442 modeStr += gDigitsSep; modeStr += QString::number(isE);
5443 modeStr += gDigitsSep; modeStr += "f";
5444 modeStr += gDigitsSep; modeStr += QString::number(isF);
5445 modeStr += gDigitsSep; modeStr += "v";
5446 modeStr += gDigitsSep; modeStr += QString::number(isV);
5447 modeStr += gDigitsSep; modeStr += "0d";
5448 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5449 modeStr += gDigitsSep; modeStr += "b";
5450 modeStr += gDigitsSep; modeStr += QString::number(isB);
5452 param = vtkParam + "Entities";
5453 ip->setParameter(entry, param, modeStr.toLatin1().data());
5459 aSmeshActor->GetSufaceColor(r, g, b, delta);
5460 QStringList colorStr;
5461 colorStr << "surface";
5462 colorStr << QString::number(r);
5463 colorStr << QString::number(g);
5464 colorStr << QString::number(b);
5466 colorStr << "backsurface";
5467 colorStr << QString::number(delta);
5469 aSmeshActor->GetVolumeColor(r, g, b, delta);
5470 colorStr << "volume";
5471 colorStr << QString::number(r);
5472 colorStr << QString::number(g);
5473 colorStr << QString::number(b);
5474 colorStr << QString::number(delta);
5476 aSmeshActor->GetEdgeColor(r, g, b);
5478 colorStr << QString::number(r);
5479 colorStr << QString::number(g);
5480 colorStr << QString::number(b);
5482 aSmeshActor->GetNodeColor(r, g, b);
5484 colorStr << QString::number(r);
5485 colorStr << QString::number(g);
5486 colorStr << QString::number(b);
5488 aSmeshActor->GetOutlineColor(r, g, b);
5489 colorStr << "outline";
5490 colorStr << QString::number(r);
5491 colorStr << QString::number(g);
5492 colorStr << QString::number(b);
5494 aSmeshActor->Get0DColor(r, g, b);
5495 colorStr << "elem0d";
5496 colorStr << QString::number(r);
5497 colorStr << QString::number(g);
5498 colorStr << QString::number(b);
5500 aSmeshActor->GetBallColor(r, g, b);
5502 colorStr << QString::number(r);
5503 colorStr << QString::number(g);
5504 colorStr << QString::number(b);
5506 aSmeshActor->GetFacesOrientationColor(r, g, b);
5507 colorStr << "orientation";
5508 colorStr << QString::number(r);
5509 colorStr << QString::number(g);
5510 colorStr << QString::number(b);
5512 param = vtkParam + "Colors";
5513 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5516 QStringList sizeStr;
5518 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5519 sizeStr << "outline";
5520 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5521 sizeStr << "elem0d";
5522 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5524 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5525 sizeStr << "shrink";
5526 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5527 sizeStr << "orientation";
5528 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5529 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5531 param = vtkParam + "Sizes";
5532 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5537 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5538 if( aMarkerType == VTK::MT_USER ) {
5539 markerStr += "custom";
5540 markerStr += gDigitsSep;
5541 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5545 markerStr += gDigitsSep;
5546 markerStr += QString::number( (int)aMarkerType );
5547 markerStr += gDigitsSep;
5548 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5551 param = vtkParam + "PointMarker";
5552 ip->setParameter(entry, param, markerStr.toLatin1().data());
5555 param = vtkParam + "Opacity";
5556 ip->setParameter(entry, param,
5557 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5560 param = vtkParam + "ClippingPlane";
5562 if( !aClippingPlaneInfoList.empty() ) {
5563 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5564 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5566 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5567 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5568 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5569 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5570 if( aSmeshActor == *anIter2 ) {
5571 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5572 QString::number( anId ).toLatin1().constData() );
5579 ip->setParameter( entry, param, "Off" );
5580 } // if (io->hasEntry())
5581 } // SMESH_Actor && hasIO
5583 } // while.. actors traversal
5587 } // if (SVTK view model)
5588 } // for (viewManagers)
5591 // data structures for clipping planes processing
5594 vtkIdType Orientation;
5598 typedef std::list<TPlaneData> TPlaneDataList;
5599 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5601 typedef std::list<vtkActor*> TActorList;
5604 TActorList ActorList;
5605 SUIT_ViewManager* ViewManager;
5607 typedef std::list<TPlaneInfo> TPlaneInfoList;
5608 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5611 * \brief Restore visual parameters
5613 * This method is called after the study document is opened.
5614 * Restore visual parameters from AttributeParameter attribue(s)
5616 void SMESHGUI::restoreVisualParameters (int savePoint)
5619 Kernel_Utils::Localizer loc;
5621 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5622 if (!appStudy || !appStudy->studyDS())
5624 _PTR(Study) studyDS = appStudy->studyDS();
5626 // componentName is used for encoding of entries when storing them in IParameters
5627 std::string componentName = myComponentSMESH->ComponentDataType();
5628 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5629 //if (!aSComponent) return;
5632 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5633 componentName.c_str(),
5635 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5637 // restore map of custom markers and map of clipping planes
5638 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5639 TPlaneDataMap aPlaneDataMap;
5641 std::vector<std::string> properties = ip->getProperties();
5642 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5644 std::string property = *propIt;
5645 QString aPropertyName( property.c_str() );
5646 QString aPropertyValue( ip->getProperty( property ).c_str() );
5648 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5649 if( aPropertyNameList.isEmpty() )
5652 QString aPropertyType = aPropertyNameList[0];
5653 if( aPropertyType == "texture" )
5655 if( aPropertyNameList.size() != 2 )
5659 int anId = aPropertyNameList[1].toInt( &ok );
5660 if( !ok || anId < 1 )
5663 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5664 if( aPropertyValueList.size() != 2 )
5667 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5668 QString aMarkerTextureString = aPropertyValueList[1];
5669 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5670 if( aMarkerTextureStringList.size() != 3 )
5674 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5679 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5683 VTK::MarkerTexture aMarkerTexture;
5684 aMarkerTexture.push_back( aWidth );
5685 aMarkerTexture.push_back( aHeight );
5687 QString aMarkerTextureData = aMarkerTextureStringList[2];
5688 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5690 QChar aChar = aMarkerTextureData.at( i );
5691 if( aChar.isDigit() )
5692 aMarkerTexture.push_back( aChar.digitValue() );
5695 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5697 else if( aPropertyType == "ClippingPlane" )
5699 if( aPropertyNameList.size() != 3 )
5703 int aViewId = aPropertyNameList[1].toInt( &ok );
5704 if( !ok || aViewId < 0 )
5708 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5709 if( !ok || aClippingPlaneId < 0 )
5712 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5713 if( aPropertyValueList.size() != 4 )
5716 TPlaneData aPlaneData;
5717 aPlaneData.Id = aClippingPlaneId;
5720 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5725 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5730 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5735 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5739 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5740 aPlaneDataList.push_back( aPlaneData );
5744 TPlaneInfoMap aPlaneInfoMap;
5746 std::vector<std::string> entries = ip->getEntries();
5748 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5750 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5751 QString entry (ip->decodeEntry(*entIt).c_str());
5753 // Check that the entry corresponds to a real object in the Study
5754 // as the object may be deleted or modified after the visual state is saved.
5755 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5756 if (!so) continue; //Skip the not existent entry
5758 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5759 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5761 std::vector<std::string>::iterator namesIt = paramNames.begin();
5762 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5764 // actors are stored in a map after displaying of them for
5765 // quicker access in the future: map < viewID to actor >
5766 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5768 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5770 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5771 // '_' is used as separator and should not be used in viewer type or parameter names.
5772 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5773 if (lst.size() != 3)
5776 QString viewerTypStr = lst[0];
5777 QString viewIndexStr = lst[1];
5778 QString paramNameStr = lst[2];
5781 int viewIndex = viewIndexStr.toUInt(&ok);
5782 if (!ok) // bad conversion of view index to integer
5786 if (viewerTypStr == SVTK_Viewer::Type())
5788 SMESH_Actor* aSmeshActor = 0;
5789 if (vtkActors.IsBound(viewIndex))
5790 aSmeshActor = vtkActors.Find(viewIndex);
5792 QList<SUIT_ViewManager*> lst;
5793 getApp()->viewManagers(viewerTypStr, lst);
5795 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5796 SUIT_ViewManager* vman = NULL;
5797 if (viewIndex >= 0 && viewIndex < lst.count())
5798 vman = lst.at(viewIndex);
5800 if (paramNameStr == "Visibility")
5802 if (!aSmeshActor && displayer() && vman)
5804 SUIT_ViewModel* vmodel = vman->getViewModel();
5805 // SVTK view model can be casted to SALOME_View
5806 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5808 // store displayed actor in a temporary map for quicker
5809 // access later when restoring other parameters
5810 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5811 vtkRenderer* Renderer = vtkView->getRenderer();
5812 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5813 vtkActorCollection* theActors = aCopy.GetActors();
5814 theActors->InitTraversal();
5815 bool isFound = false;
5816 vtkActor *ac = theActors->GetNextActor();
5817 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5818 if (ac->IsA("SMESH_Actor")) {
5819 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5820 if (aGeomAc->hasIO()) {
5821 Handle(SALOME_InteractiveObject) io =
5822 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5823 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5825 vtkActors.Bind(viewIndex, aGeomAc);
5831 } // if (paramNameStr == "Visibility")
5834 // the rest properties "work" with SMESH_Actor
5837 QString val ((*valuesIt).c_str());
5840 if (paramNameStr == "Representation") {
5841 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5844 else if (paramNameStr == "IsShrunk") {
5846 if (!aSmeshActor->IsShrunk())
5847 aSmeshActor->SetShrink();
5850 if (aSmeshActor->IsShrunk())
5851 aSmeshActor->UnShrink();
5854 // Displayed entities
5855 else if (paramNameStr == "Entities") {
5856 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5857 int aEntityMode = SMESH_Actor::eAllEntity;
5858 for ( int i = 0; i < mode.count(); i+=2 ) {
5859 if ( i < mode.count()-1 ) {
5860 QString type = mode[i];
5861 bool val = mode[i+1].toInt();
5862 if ( type == "e" && !val )
5863 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
5864 else if ( type == "f" && !val )
5865 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
5866 else if ( type == "v" && !val )
5867 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
5868 else if ( type == "0d" && !val )
5869 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
5870 else if ( type == "b" && !val )
5871 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
5874 aSmeshActor->SetEntityMode( aEntityMode );
5877 else if (paramNameStr == "Colors") {
5878 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5885 QColor outlineColor;
5886 QColor orientationColor;
5892 // below lines are required to get default values for delta coefficients
5893 // of backface color for faces and color of reversed volumes
5894 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
5895 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
5896 for ( int i = 0; i < colors.count(); i++ ) {
5897 QString type = colors[i];
5898 if ( type == "surface" ) {
5899 // face color is set by 3 values r:g:b, where
5900 // - r,g,b - is rgb color components
5901 if ( i+1 >= colors.count() ) break; // format error
5902 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5903 if ( i+2 >= colors.count() ) break; // format error
5904 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5905 if ( i+3 >= colors.count() ) break; // format error
5906 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5907 faceColor.setRgbF( r, g, b );
5910 else if ( type == "backsurface" ) {
5911 // backface color can be defined in several ways
5912 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
5913 // - in latest versions, it is set as delta coefficient
5914 bool rgbOk = false, deltaOk;
5915 if ( i+1 >= colors.count() ) break; // format error
5916 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5917 int delta = colors[i+1].toInt( &deltaOk );
5919 if ( i+1 < colors.count() ) // index is shifted to 1
5920 g = colors[i+1].toDouble( &rgbOk );
5921 if ( rgbOk ) i++; // shift index
5922 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
5923 b = colors[i+1].toDouble( &rgbOk );
5925 // - as currently there's no way to set directly backsurface color as it was before,
5926 // we ignore old dump where r,g,b triple was set
5927 // - also we check that delta parameter is set properly
5928 if ( !rgbOk && deltaOk )
5931 else if ( type == "volume" ) {
5932 // volume color is set by 4 values r:g:b:delta, where
5933 // - r,g,b - is a normal volume rgb color components
5934 // - delta - is a reversed volume color delta coefficient
5935 if ( i+1 >= colors.count() ) break; // format error
5936 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5937 if ( i+2 >= colors.count() ) break; // format error
5938 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5939 if ( i+3 >= colors.count() ) break; // format error
5940 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5941 if ( i+4 >= colors.count() ) break; // format error
5942 int delta = colors[i+4].toInt( &bOk );
5943 if ( !bOk ) break; // format error
5944 volumeColor.setRgbF( r, g, b );
5948 else if ( type == "edge" ) {
5949 // edge color is set by 3 values r:g:b, where
5950 // - r,g,b - is rgb color components
5951 if ( i+1 >= colors.count() ) break; // format error
5952 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5953 if ( i+2 >= colors.count() ) break; // format error
5954 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5955 if ( i+3 >= colors.count() ) break; // format error
5956 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5957 edgeColor.setRgbF( r, g, b );
5960 else if ( type == "node" ) {
5961 // node color is set by 3 values r:g:b, where
5962 // - r,g,b - is rgb color components
5963 if ( i+1 >= colors.count() ) break; // format error
5964 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5965 if ( i+2 >= colors.count() ) break; // format error
5966 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5967 if ( i+3 >= colors.count() ) break; // format error
5968 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5969 nodeColor.setRgbF( r, g, b );
5972 else if ( type == "elem0d" ) {
5973 // 0d element color is set by 3 values r:g:b, where
5974 // - r,g,b - is rgb color components
5975 if ( i+1 >= colors.count() ) break; // format error
5976 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5977 if ( i+2 >= colors.count() ) break; // format error
5978 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5979 if ( i+3 >= colors.count() ) break; // format error
5980 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5981 elem0dColor.setRgbF( r, g, b );
5984 else if ( type == "ball" ) {
5985 // ball color is set by 3 values r:g:b, where
5986 // - r,g,b - is rgb color components
5987 if ( i+1 >= colors.count() ) break; // format error
5988 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5989 if ( i+2 >= colors.count() ) break; // format error
5990 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5991 if ( i+3 >= colors.count() ) break; // format error
5992 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5993 ballColor.setRgbF( r, g, b );
5996 else if ( type == "outline" ) {
5997 // outline color is set by 3 values r:g:b, where
5998 // - r,g,b - is rgb color components
5999 if ( i+1 >= colors.count() ) break; // format error
6000 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6001 if ( i+2 >= colors.count() ) break; // format error
6002 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6003 if ( i+3 >= colors.count() ) break; // format error
6004 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6005 outlineColor.setRgbF( r, g, b );
6008 else if ( type == "orientation" ) {
6009 // orientation color is set by 3 values r:g:b, where
6010 // - r,g,b - is rgb color components
6011 if ( i+1 >= colors.count() ) break; // format error
6012 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6013 if ( i+2 >= colors.count() ) break; // format error
6014 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6015 if ( i+3 >= colors.count() ) break; // format error
6016 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6017 orientationColor.setRgbF( r, g, b );
6022 if ( nodeColor.isValid() )
6023 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6025 if ( edgeColor.isValid() )
6026 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6028 if ( faceColor.isValid() )
6029 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6031 if ( volumeColor.isValid() )
6032 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6033 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6034 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6036 if ( elem0dColor.isValid() )
6037 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6039 if ( ballColor.isValid() )
6040 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6042 if ( outlineColor.isValid() )
6043 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6044 // orientation color
6045 if ( orientationColor.isValid() )
6046 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6049 else if (paramNameStr == "Sizes") {
6050 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6053 int outlineWidth = -1;
6054 int elem0dSize = -1;
6056 double shrinkSize = -1;
6057 double orientationSize = -1;
6058 bool orientation3d = false;
6059 for ( int i = 0; i < sizes.count(); i++ ) {
6060 QString type = sizes[i];
6061 if ( type == "line" ) {
6062 // line (wireframe) width is given as single integer value
6063 if ( i+1 >= sizes.count() ) break; // format error
6064 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6068 if ( type == "outline" ) {
6069 // outline width is given as single integer value
6070 if ( i+1 >= sizes.count() ) break; // format error
6071 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6075 else if ( type == "elem0d" ) {
6076 // 0d element size is given as single integer value
6077 if ( i+1 >= sizes.count() ) break; // format error
6078 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6082 else if ( type == "ball" ) {
6083 // ball size is given as single integer value
6084 if ( i+1 >= sizes.count() ) break; // format error
6085 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6089 else if ( type == "shrink" ) {
6090 // shrink factor is given as single floating point value
6091 if ( i+1 >= sizes.count() ) break; // format error
6092 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6096 else if ( type == "orientation" ) {
6097 // orientation vectors are specified by two values size:3d, where
6098 // - size - is a floating point value specifying scale factor
6099 // - 3d - is a boolean
6100 if ( i+1 >= sizes.count() ) break; // format error
6101 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6102 if ( i+2 >= sizes.count() ) break; // format error
6103 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6104 orientationSize = v1;
6105 orientation3d = (bool)v2;
6109 // line (wireframe) width
6110 if ( lineWidth > 0 )
6111 aSmeshActor->SetLineWidth( lineWidth );
6113 if ( outlineWidth > 0 )
6114 aSmeshActor->SetOutlineWidth( outlineWidth );
6115 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6116 aSmeshActor->SetOutlineWidth( lineWidth );
6118 if ( elem0dSize > 0 )
6119 aSmeshActor->Set0DSize( elem0dSize );
6122 aSmeshActor->SetBallSize( ballSize );
6124 if ( shrinkSize > 0 )
6125 aSmeshActor->SetShrinkFactor( shrinkSize );
6126 // orientation vectors
6127 if ( orientationSize > 0 ) {
6128 aSmeshActor->SetFacesOrientationScale( orientationSize );
6129 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6133 else if (paramNameStr == "PointMarker") {
6134 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6135 if( data.count() >= 2 ) {
6137 int aParam1 = data[1].toInt( &ok );
6139 if( data[0] == "std" && data.count() == 3 ) {
6140 int aParam2 = data[2].toInt( &ok );
6141 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6143 else if( data[0] == "custom" ) {
6144 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6145 if( markerIt != aMarkerMap.end() ) {
6146 VTK::MarkerData aMarkerData = markerIt->second;
6147 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6154 else if (paramNameStr == "Opacity") {
6155 aSmeshActor->SetOpacity(val.toFloat());
6158 else if (paramNameStr.startsWith("ClippingPlane")) {
6159 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6160 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
6161 // new format - val looks like "Off" or "0" (plane id)
6162 // (note: in new format "Off" value is used only for consistency,
6163 // so it is processed together with values in old format)
6164 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
6165 if( anIsOldFormat ) {
6166 if (paramNameStr == "ClippingPlane1" || val == "Off")
6167 aSmeshActor->RemoveAllClippingPlanes();
6169 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
6170 double aDistance = vals[1].toFloat();
6172 anAngle[0] = vals[2].toFloat();
6173 anAngle[1] = vals[3].toFloat();
6175 QList<SUIT_ViewManager*> lst;
6176 getApp()->viewManagers(viewerTypStr, lst);
6177 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6178 if (viewIndex >= 0 && viewIndex < lst.count()) {
6179 SUIT_ViewManager* vman = lst.at(viewIndex);
6180 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6182 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6184 SMESH::TActorList anActorList;
6185 anActorList.push_back( aSmeshActor );
6186 SMESH::OrientedPlane* aPlane =
6187 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
6189 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6190 aClippingPlaneInfo.Plane = aPlane;
6191 aClippingPlaneInfo.ActorList = anActorList;
6192 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6199 int aPlaneId = val.toInt( &ok );
6200 if( ok && aPlaneId >= 0 ) {
6201 bool anIsDefinedPlane = false;
6202 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6203 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6204 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6205 TPlaneInfo& aPlaneInfo = *anIter;
6206 if( aPlaneInfo.PlaneId == aPlaneId ) {
6207 aPlaneInfo.ActorList.push_back( aSmeshActor );
6208 anIsDefinedPlane = true;
6212 if( !anIsDefinedPlane ) {
6213 TPlaneInfo aPlaneInfo;
6214 aPlaneInfo.PlaneId = aPlaneId;
6215 aPlaneInfo.ActorList.push_back( aSmeshActor );
6216 aPlaneInfo.ViewManager = vman;
6218 // to make the list sorted by plane id
6219 anIter = aPlaneInfoList.begin();
6220 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6221 const TPlaneInfo& aPlaneInfoRef = *anIter;
6222 if( aPlaneInfoRef.PlaneId > aPlaneId )
6225 aPlaneInfoList.insert( anIter, aPlaneInfo );
6230 } // if (aSmeshActor)
6231 } // other parameters than Visibility
6233 } // for names/parameters iterator
6234 } // for entries iterator
6236 // take into account planes with empty list of actors referred to them
6237 QList<SUIT_ViewManager*> aVMList;
6238 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6240 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6241 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6242 int aViewId = aPlaneDataIter->first;
6243 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6244 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6246 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6248 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6249 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6250 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6251 const TPlaneData& aPlaneData = *anIter2;
6252 int aPlaneId = aPlaneData.Id;
6254 bool anIsFound = false;
6255 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6256 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6257 const TPlaneInfo& aPlaneInfo = *anIter3;
6258 if( aPlaneInfo.PlaneId == aPlaneId ) {
6265 TPlaneInfo aPlaneInfo; // ActorList field is empty
6266 aPlaneInfo.PlaneId = aPlaneId;
6267 aPlaneInfo.ViewManager = aViewManager;
6269 // to make the list sorted by plane id
6270 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6271 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6272 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6273 if( aPlaneInfoRef.PlaneId > aPlaneId )
6276 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6282 // add clipping planes to actors according to the restored parameters
6283 // and update the clipping plane map
6284 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6285 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6286 int aViewId = anIter1->first;
6287 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6289 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6290 if( anIter2 == aPlaneDataMap.end() )
6292 const TPlaneDataList& aPlaneDataList = anIter2->second;
6294 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6295 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6296 const TPlaneInfo& aPlaneInfo = *anIter3;
6297 int aPlaneId = aPlaneInfo.PlaneId;
6298 const TActorList& anActorList = aPlaneInfo.ActorList;
6299 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6303 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6307 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6309 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6310 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6311 const TPlaneData& aPlaneData = *anIter4;
6312 if( aPlaneData.Id == aPlaneId ) {
6313 SMESH::OrientedPlane* aPlane =
6314 SMESHGUI_ClippingDlg::AddPlane( anActorList,
6316 (SMESH::Orientation)aPlaneData.Orientation,
6317 aPlaneData.Distance,
6320 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6321 aClippingPlaneInfo.Plane = aPlane;
6322 aClippingPlaneInfo.ActorList = anActorList;
6323 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6331 // update all VTK views
6332 QList<SUIT_ViewManager*> lst;
6333 getApp()->viewManagers(lst);
6334 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6335 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6336 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6337 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6338 vtkView->getRenderer()->ResetCameraClippingRange();
6345 \brief Adds preferences for dfont of VTK viewer
6347 \param pIf group identifier
6348 \param param parameter
6349 \return identifier of preferences
6351 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6353 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6355 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6358 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6359 fam.append( tr( "SMESH_FONT_COURIER" ) );
6360 fam.append( tr( "SMESH_FONT_TIMES" ) );
6362 setPreferenceProperty( tfont, "fonts", fam );
6364 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6365 if ( needSize ) f = f | QtxFontEdit::Size;
6366 setPreferenceProperty( tfont, "features", f );
6372 \brief Actions after hypothesis edition
6373 Updates object browser after hypothesis edition
6375 void SMESHGUI::onHypothesisEdit( int result )
6378 SMESHGUI::Modified();
6379 updateObjBrowser( true );
6384 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6385 \param pview view being closed
6387 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6388 #ifndef DISABLE_PLOT2DVIEWER
6389 //Crear all Plot2d Viewers if need.
6390 SMESH::ClearPlot2Viewers(pview);
6394 void SMESHGUI::message( const QString& msg )
6397 QStringList data = msg.split("/");
6398 if ( data.count() > 0 ) {
6399 if ( data.first() == "mesh_loading" ) {
6401 QString entry = data.count() > 1 ? data[1] : QString();
6402 if ( entry.isEmpty() )
6405 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6407 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6410 name = obj->GetName().c_str();
6411 if ( name.isEmpty() )
6414 if ( data.last() == "stop" )
6415 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6417 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6418 QApplication::processEvents();
6424 \brief Connects or disconnects signals about activating and cloning view on the module slots
6425 \param pview view which is connected/disconnected
6427 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6431 SUIT_ViewManager* viewMgr = pview->getViewManager();
6433 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6434 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6436 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6437 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6442 \brief Return \c true if object can be renamed
6444 bool SMESHGUI::renameAllowed( const QString& entry) const {
6445 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6449 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6453 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6458 if(appStudy->isComponent(entry) || obj->isReference())
6461 // check type to prevent renaming of inappropriate objects
6462 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6463 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6464 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6465 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6466 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6467 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6474 Rename object by entry.
6475 \param entry entry of the object
6476 \param name new name of the object
6477 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6479 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6481 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6485 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6490 _PTR(Study) aStudy = appStudy->studyDS();
6495 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6497 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6502 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6503 _PTR(GenericAttribute) anAttr;
6504 _PTR(AttributeName) aName;
6506 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6508 // check type to prevent renaming of inappropriate objects
6509 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6510 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6511 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6512 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6513 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6514 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6515 if ( !name.isEmpty() ) {
6516 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6518 // update name of group object and its actor
6519 Handle(SALOME_InteractiveObject) IObject =
6520 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6522 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6523 if( !aGroupObject->_is_nil() ) {
6524 aGroupObject->SetName( qPrintable(name) );
6525 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6526 anActor->setName( qPrintable(name) );
6537 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6539 static QList<QColor> colors;
6541 if ( colors.isEmpty() ) {
6543 for (int s = 0; s < 2 ; s++)
6545 for (int v = 100; v >= 40; v = v - 20)
6547 for (int h = 0; h < 359 ; h = h + 60)
6549 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
6554 static int currentColor = 0;
6556 SALOMEDS::Color color;
6557 color.R = (double)colors[currentColor].red() / 255.0;
6558 color.G = (double)colors[currentColor].green() / 255.0;
6559 color.B = (double)colors[currentColor].blue() / 255.0;
6561 currentColor = (currentColor+1) % colors.count();