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 void OverallMeshQuality() {
1000 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1001 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1002 SALOME_ListIO selected;
1004 aSel->selectedObjects( selected );
1006 if ( selected.IsEmpty() ) return;
1007 SALOME_ListIteratorOfListIO It( selected );
1008 for ( ; It.More(); It.Next() ) {
1009 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1010 ctrlDlg->showInfo( It.Value() );
1015 QString functorToString( SMESH::Controls::FunctorPtr f )
1017 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1018 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1019 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1020 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1021 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1022 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1023 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1024 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1025 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1026 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1027 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1028 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1029 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1030 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1031 type = QObject::tr( "WARP_ELEMENTS" );
1032 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1033 type = QObject::tr( "TAPER_ELEMENTS" );
1034 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1035 type = QObject::tr( "SKEW_ELEMENTS" );
1036 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1037 type = QObject::tr( "AREA_ELEMENTS" );
1038 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1039 type = QObject::tr( "LENGTH_EDGES" );
1040 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1041 type = QObject::tr( "LENGTH2D_EDGES" );
1042 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1043 type = QObject::tr( "MULTI_BORDERS" );
1044 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1045 type = QObject::tr( "MULTI2D_BORDERS" );
1046 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1047 type = QObject::tr( "FREE_NODES" );
1048 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1049 type = QObject::tr( "FREE_EDGES" );
1050 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1051 type = QObject::tr( "FREE_BORDERS" );
1052 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1053 type = QObject::tr( "FREE_FACES" );
1054 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1055 type = QObject::tr( "BARE_BORDER_VOLUME" );
1056 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1057 type = QObject::tr( "BARE_BORDER_FACE" );
1058 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1059 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1060 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1061 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1062 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1063 type = QObject::tr( "EQUAL_NODE" );
1064 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1065 type = QObject::tr( "EQUAL_EDGE" );
1066 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1067 type = QObject::tr( "EQUAL_FACE" );
1068 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1069 type = QObject::tr( "EQUAL_VOLUME" );
1073 void SaveDistribution()
1075 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1076 SALOME_ListIO selected;
1078 aSel->selectedObjects( selected );
1080 if ( selected.Extent() == 1 ) {
1081 Handle(SALOME_InteractiveObject) anIO = selected.First();
1082 if ( anIO->hasEntry() ) {
1083 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1084 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1085 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1086 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1087 if ( aScalarBarActor && aFunctor ) {
1088 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1090 std::vector<int> elements;
1091 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1092 if ( mesh->_is_nil() ) {
1093 SMESH::SMESH_IDSource_var idSource =
1094 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1095 if ( !idSource->_is_nil() )
1097 SMESH::long_array_var ids = idSource->GetIDs();
1098 elements.resize( ids->length() );
1099 for ( unsigned i = 0; i < elements.size(); ++i )
1100 elements[i] = ids[i];
1103 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1104 vtkLookupTable* lookupTable =
1105 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1106 double * minmax = lookupTable->GetRange();
1107 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1108 std::vector<int> nbEvents;
1109 std::vector<double> funValues;
1110 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
1111 QString anInitialPath = "";
1112 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1113 anInitialPath = QDir::currentPath();
1114 QString aMeshName = anIO->getName();
1116 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1117 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1118 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1119 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1120 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1123 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1125 if ( !aFilename.isEmpty() ) {
1126 QFile f( aFilename );
1127 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1128 QTextStream out( &f );
1129 out << "# Mesh: " << aMeshName << endl;
1130 out << "# Control: " << functorToString( aFunctor ) << endl;
1132 out.setFieldWidth( 10 );
1133 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1134 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1145 void ShowDistribution() {
1146 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1147 SALOME_ListIO selected;
1149 aSel->selectedObjects( selected );
1151 if ( selected.Extent() == 1 ) {
1152 Handle(SALOME_InteractiveObject) anIO = selected.First();
1153 if ( anIO->hasEntry() ) {
1154 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1155 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1156 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1157 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1163 #ifndef DISABLE_PLOT2DVIEWER
1164 void PlotDistribution() {
1165 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1169 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1170 SALOME_ListIO selected;
1172 aSel->selectedObjects( selected );
1174 if ( selected.Extent() == 1 ) {
1175 Handle(SALOME_InteractiveObject) anIO = selected.First();
1176 if ( anIO->hasEntry() ) {
1177 //Find Actor by entry before getting Plot2d viewer,
1178 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1179 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1181 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1186 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1190 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1194 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1195 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1196 QString functorName = functorToString( anActor->GetFunctor());
1197 QString aHistogramName("%1 : %2");
1198 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1199 aHistogram->setName(aHistogramName);
1200 aHistogram->setHorTitle(functorName);
1201 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1202 aPlot->displayObject(aHistogram, true);
1207 #endif //DISABLE_PLOT2DVIEWER
1209 void DisableAutoColor(){
1210 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1211 SALOME_ListIO selected;
1213 aSel->selectedObjects( selected );
1215 if(selected.Extent()){
1216 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1217 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1218 if ( !aMesh->_is_nil() ) {
1219 aMesh->SetAutoColor( false );
1224 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1226 SALOME_ListIO selected;
1227 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1231 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1232 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1233 if( !aSel || !appStudy )
1236 if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection
1237 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1238 aModule->EmitSignalDeactivateDialog();
1239 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1240 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1245 _PTR(Study) aStudy = appStudy->studyDS();
1247 aSel->selectedObjects( selected );
1249 if(selected.Extent() >= 1){
1250 switch(theCommandID){
1252 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1253 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1258 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1259 QColor orientationColor, outlineColor, volumeColor;
1260 int deltaF = 0, deltaV = 0;
1264 int outlineWidth = 1;
1265 double shrinkCoef = 0.0;
1266 double orientationScale = 0.0;
1267 bool orientation3d = false;
1268 VTK::MarkerType markerType = VTK::MT_NONE;
1269 VTK::MarkerScale markerScale = VTK::MS_NONE;
1271 bool hasNodes = false;
1272 int presentEntities = 0;
1273 bool firstTime = true;
1275 SALOME_ListIteratorOfListIO It( selected );
1276 for ( ; It.More(); It.Next() ) {
1277 Handle(SALOME_InteractiveObject) IObject = It.Value();
1278 if ( !IObject->hasEntry() ) continue;
1279 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1280 if ( !anActor || !anActor->GetObject() ) continue;
1283 // nodes: color, marker
1284 anActor->GetNodeColor( color[0], color[1], color[2] );
1285 nodeColor.setRgbF( color[0], color[1], color[2] );
1286 markerType = anActor->GetMarkerType();
1287 markerScale = anActor->GetMarkerScale();
1288 markerId = anActor->GetMarkerTexture();
1289 // edges: color, width
1290 anActor->GetEdgeColor( color[0], color[1], color[2] );
1291 edgeColor.setRgbF( color[0], color[1], color[2] );
1292 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1293 // faces: front color, back color (delta)
1294 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1295 faceColor.setRgbF( color[0], color[1], color[2] );
1296 // faces: front color, back color (delta)
1297 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1298 volumeColor.setRgbF( color[0], color[1], color[2] );
1299 // 0d elements: color, size
1300 anActor->Get0DColor( color[0], color[1], color[2] );
1301 elem0dColor.setRgbF( color[0], color[1], color[2] );
1302 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1303 // balls: color, size
1304 anActor->GetBallColor( color[0], color[1], color[2] );
1305 ballColor.setRgbF( color[0], color[1], color[2] );
1306 ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1308 anActor->GetOutlineColor( color[0], color[1], color[2] );
1309 outlineColor.setRgbF( color[0], color[1], color[2] );
1310 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1311 // orientation vectors: color, scale, 3d flag
1312 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1313 orientationColor.setRgbF( color[0], color[1], color[2] );
1314 orientationScale = anActor->GetFacesOrientationScale();
1315 orientation3d = anActor->GetFacesOrientation3DVectors();
1317 shrinkCoef = anActor->GetShrinkFactor();
1320 firstTime = false; // we only take properties from first object (for performance reasons)
1323 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1324 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1325 presentEntities = presentEntities | SMESH_Actor::eEdges;
1326 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1327 presentEntities = presentEntities | SMESH_Actor::eFaces;
1328 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1329 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1330 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1331 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1332 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1333 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1335 // as we know that all types of elements are present, we can exit the loop
1336 if ( presentEntities == SMESH_Actor::eAllEntity )
1340 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1341 // nodes: color, marker
1342 dlg.setNodeColor( nodeColor );
1343 if( markerType != VTK::MT_USER )
1344 dlg.setNodeMarker( markerType, markerScale );
1346 dlg.setNodeCustomMarker( markerId );
1347 // edges: color, line width
1348 dlg.setEdgeColor( edgeColor );
1349 dlg.setEdgeWidth( edgeWidth );
1350 // faces: front color, back color
1351 dlg.setFaceColor( faceColor, deltaF );
1352 // volumes: normal color, reversed color
1353 dlg.setVolumeColor( volumeColor, deltaV );
1354 // outlines: color, line width
1355 dlg.setOutlineColor( outlineColor );
1356 dlg.setOutlineWidth( outlineWidth );
1357 // 0d elements: color, size
1358 dlg.setElem0dColor( elem0dColor );
1359 dlg.setElem0dSize( elem0dSize );
1360 // balls: color, size
1361 dlg.setBallColor( ballColor );
1362 dlg.setBallSize( ballSize );
1363 // orientation: color, scale, 3d flag
1364 dlg.setOrientationColor( orientationColor );
1365 dlg.setOrientationSize( int( orientationScale * 100. ) );
1366 dlg.setOrientation3d( orientation3d );
1367 // shrink: scale factor
1368 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1369 // hide unused controls
1370 dlg.showControls( presentEntities, hasNodes );
1373 nodeColor = dlg.nodeColor();
1374 markerType = dlg.nodeMarkerType();
1375 markerScale = dlg.nodeMarkerScale();
1376 markerId = dlg.nodeMarkerId();
1377 edgeColor = dlg.edgeColor();
1378 edgeWidth = dlg.edgeWidth();
1379 faceColor = dlg.faceColor();
1380 deltaF = dlg.faceColorDelta();
1381 volumeColor = dlg.volumeColor();
1382 deltaV = dlg.volumeColorDelta();
1383 outlineColor = dlg.outlineColor();
1384 outlineWidth = dlg.outlineWidth();
1385 elem0dColor = dlg.elem0dColor();
1386 elem0dSize = dlg.elem0dSize();
1387 ballColor = dlg.ballColor();
1388 ballSize = dlg.ballSize();
1389 orientationColor = dlg.orientationColor();
1390 orientationScale = dlg.orientationSize() / 100.;
1391 orientation3d = dlg.orientation3d();
1392 shrinkCoef = dlg.shrinkCoef() / 100.;
1394 // store point markers map that might be changed by the user
1395 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1397 // set properties from dialog box to the presentations
1398 SALOME_ListIteratorOfListIO It( selected );
1399 for ( ; It.More(); It.Next() ) {
1400 Handle(SALOME_InteractiveObject) IObject = It.Value();
1401 if ( !IObject->hasEntry() ) continue;
1402 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1403 if ( !anActor ) continue;
1405 // nodes: color, marker
1406 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1407 if ( markerType != VTK::MT_USER ) {
1408 anActor->SetMarkerStd( markerType, markerScale );
1411 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1412 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1413 if ( iter != markerMap.end() )
1414 anActor->SetMarkerTexture( markerId, iter->second.second );
1416 // volumes: normal color, reversed color (delta)
1417 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1418 // faces: front color, back color (delta)
1419 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1420 // edges: color, width
1421 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1422 anActor->SetLineWidth( edgeWidth );
1424 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1425 anActor->SetOutlineWidth( outlineWidth );
1426 // 0D elements: color, size
1427 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1428 anActor->Set0DSize( elem0dSize );
1429 // balls: color, size
1430 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1431 anActor->SetBallSize( ballSize );
1432 // orientation: color, scale, 3d flag
1433 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1434 anActor->SetFacesOrientationScale( orientationScale );
1435 anActor->SetFacesOrientation3DVectors( orientation3d );
1437 anActor->SetShrinkFactor( shrinkCoef );
1439 // for groups, set also proper color
1440 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1441 if ( !aGroupObject->_is_nil() ) {
1442 SMESH::ElementType anElementType = aGroupObject->GetType();
1444 switch( anElementType ) {
1446 aColor = nodeColor; break;
1448 aColor = edgeColor; break;
1450 aColor = faceColor; break;
1452 aColor = volumeColor; break;
1454 aColor = elem0dColor; break;
1456 aColor = ballColor; break;
1460 if ( aColor.isValid() ) {
1461 SALOMEDS::Color aGroupColor;
1462 aGroupColor.R = aColor.redF();
1463 aGroupColor.G = aColor.greenF();
1464 aGroupColor.B = aColor.blueF();
1465 aGroupObject->SetColor( aGroupColor );
1467 } // if ( !aGroupObject->_is_nil() )
1468 } // for ( ; It.More(); It.Next() )
1469 SMESH::RepaintCurrentView();
1470 } // if ( dlg.exec() )
1473 } // switch(theCommandID)
1474 SALOME_ListIteratorOfListIO It( selected );
1475 for( ; It.More(); It.Next()){
1476 Handle(SALOME_InteractiveObject) IObject = It.Value();
1477 if(IObject->hasEntry()){
1478 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1479 switch(theCommandID){
1481 anActor->SetRepresentation(SMESH_Actor::eEdge);
1484 anActor->SetRepresentation(SMESH_Actor::eSurface);
1487 if(anActor->IsShrunk())
1488 anActor->UnShrink();
1490 anActor->SetShrink();
1493 anActor->SetRepresentation(SMESH_Actor::ePoint);
1496 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1497 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1500 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1501 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1507 SMESH::RepaintCurrentView();
1511 void Control( int theCommandID )
1513 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1514 SALOME_ListIO selected;
1516 aSel->selectedObjects( selected );
1518 if( !selected.IsEmpty() ){
1519 Handle(SALOME_InteractiveObject) anIO = selected.First();
1521 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1522 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1523 switch ( theCommandID ){
1525 aControl = SMESH_Actor::eLength;
1528 aControl = SMESH_Actor::eLength2D;
1531 aControl = SMESH_Actor::eFreeEdges;
1534 aControl = SMESH_Actor::eFreeBorders;
1537 aControl = SMESH_Actor::eMultiConnection;
1540 aControl = SMESH_Actor::eFreeNodes;
1543 aControl = SMESH_Actor::eMultiConnection2D;
1546 aControl = SMESH_Actor::eArea;
1549 aControl = SMESH_Actor::eTaper;
1552 aControl = SMESH_Actor::eAspectRatio;
1555 aControl = SMESH_Actor::eAspectRatio3D;
1558 aControl = SMESH_Actor::eMinimumAngle;
1561 aControl = SMESH_Actor::eWarping;
1564 aControl = SMESH_Actor::eSkew;
1567 aControl = SMESH_Actor::eVolume3D;
1570 aControl = SMESH_Actor::eFreeFaces;
1573 aControl = SMESH_Actor::eMaxElementLength2D;
1576 aControl = SMESH_Actor::eMaxElementLength3D;
1579 aControl = SMESH_Actor::eBareBorderVolume;
1582 aControl = SMESH_Actor::eBareBorderFace;
1585 aControl = SMESH_Actor::eOverConstrainedVolume;
1588 aControl = SMESH_Actor::eOverConstrainedFace;
1591 aControl = SMESH_Actor::eCoincidentNodes;
1594 aControl = SMESH_Actor::eCoincidentElems1D;
1597 aControl = SMESH_Actor:: eCoincidentElems2D;
1600 aControl = SMESH_Actor::eCoincidentElems3D;
1604 anActor->SetControlMode(aControl);
1605 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1606 SMESH::RepaintCurrentView();
1607 #ifndef DISABLE_PLOT2DVIEWER
1608 if(anActor->GetPlot2Histogram()) {
1609 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1610 QString functorName = functorToString( anActor->GetFunctor());
1611 QString aHistogramName("%1 : %2");
1612 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1613 aHistogram->setName(aHistogramName);
1614 aHistogram->setHorTitle(functorName);
1615 SMESH::ProcessIn2DViewers(anActor);
1624 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1625 SMESH::MeshObjectType theType,
1626 const QString theInTypeName,
1627 QString & theOutTypeName)
1629 SMESH_TypeFilter aTypeFilter( theType );
1631 if( !theIO.IsNull() )
1633 entry = theIO->getEntry();
1634 LightApp_DataOwner owner( entry );
1635 if ( aTypeFilter.isOk( &owner )) {
1636 theOutTypeName = theInTypeName;
1644 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1646 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1647 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1649 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1650 CORBA::String_var anID = aSComp->GetID().c_str();
1651 if (!strcmp(anID.in(),theIO->getEntry()))
1657 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1658 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1659 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1660 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1661 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1669 QString CheckHomogeneousSelection()
1671 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1672 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1673 SALOME_ListIO selected;
1675 aSel->selectedObjects( selected );
1677 QString RefType = CheckTypeObject(selected.First());
1678 SALOME_ListIteratorOfListIO It(selected);
1679 for ( ; It.More(); It.Next())
1681 Handle(SALOME_InteractiveObject) IObject = It.Value();
1682 QString Type = CheckTypeObject(IObject);
1683 if (Type.compare(RefType) != 0)
1684 return "Heterogeneous Selection";
1691 void SMESHGUI::OnEditDelete()
1693 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1694 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1695 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1697 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1698 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1699 _PTR(GenericAttribute) anAttr;
1700 _PTR(AttributeIOR) anIOR;
1702 int objectCount = 0;
1704 QString aParentComponent = QString::null;
1705 Handle(SALOME_InteractiveObject) anIO;
1706 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1708 anIO = anIt.Value();
1709 QString cur = anIO->getComponentDataType();
1710 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1712 // check if object is reference
1713 _PTR(SObject) aRefSObj;
1714 aNameList.append("\n - ");
1715 if ( aSO->ReferencedObject( aRefSObj ) ) {
1716 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1717 aNameList.append( aRefName );
1718 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1721 aNameList.append(anIO->getName());
1725 if( aParentComponent.isNull() )
1726 aParentComponent = cur;
1727 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1728 aParentComponent = "";
1731 if ( objectCount == 0 )
1732 return; // No Valid Objects Selected
1734 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1735 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1736 QObject::tr("ERR_ERROR"),
1737 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1740 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1741 if (SUIT_MessageBox::warning
1742 (SMESHGUI::desktop(),
1743 QObject::tr("SMESH_WRN_WARNING"),
1744 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1745 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1746 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1749 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1751 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1752 // then treat them all starting from the deepest objects (at list back)
1753 std::list< _PTR(SObject) > listSO;
1754 SALOME_ListIteratorOfListIO It(selected);
1755 for( ; It.More(); It.Next()) // loop on selected IO's
1757 Handle(SALOME_InteractiveObject) IObject = It.Value();
1758 if(IObject->hasEntry()) {
1759 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1761 // disable removal of "SMESH" component object
1762 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1764 if ( engineIOR() == anIOR->Value().c_str() )
1767 //Check the referenced object
1768 _PTR(SObject) aRefSObject;
1769 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1770 aSO = aRefSObject; // Delete main Object instead of reference
1772 listSO.push_back( aSO );
1773 std::list< _PTR(SObject) >::iterator itSO = listSO.begin();
1774 for ( ; itSO != listSO.end(); ++itSO ) {
1775 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1776 for (it->InitEx(false); it->More(); it->Next())
1777 listSO.push_back( it->Value() );
1781 // Check if none of objects to delete is referred from outside
1782 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1783 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1785 _PTR(SObject) SO = *ritSO;
1786 if ( !SO ) continue;
1787 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1788 for (size_t i = 0; i < aReferences.size(); i++) {
1789 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1790 std::string type = aComponent->ComponentDataType();
1791 if ( type != "SMESH" )
1793 SUIT_MessageBox::warning( anApp->desktop(),
1794 QObject::tr("WRN_WARNING"),
1795 QObject::tr("DEP_OBJECT") );
1796 return; // outside SMESH, there is an object depending on a SMESH object
1801 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1802 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1804 Handle(SALOME_InteractiveObject) IObject = It.Value();
1805 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1806 if ( !mesh->_is_nil() )
1810 // Treat SO's in the list starting from the back
1811 aStudyBuilder->NewCommand(); // There is a transaction
1812 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1814 _PTR(SObject) SO = *ritSO;
1815 if ( !SO ) continue;
1816 std::string anEntry = SO->GetID();
1818 /** Erase graphical object **/
1819 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1820 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1821 // ViewManagerList aViewMenegers = anApp->viewManagers();
1822 // ViewManagerList::const_iterator it = aViewMenegers.begin();
1823 // for( ; it != aViewMenegers.end(); it++) {
1824 // SUIT_ViewManager* vm = *it;
1825 // int nbSf = vm ? vm->getViewsCount() : 0;
1827 // QVector<SUIT_ViewWindow*> aViews = vm->getViews();
1828 // for(int i = 0; i < nbSf; i++){
1829 // SUIT_ViewWindow *sf = aViews[i];
1830 // if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
1831 // SMESH::RemoveActor(sf,anActor);
1837 /** Remove an object from data structures **/
1838 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1839 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1840 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1841 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1842 aMesh->RemoveGroup( aGroup );
1844 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1845 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1846 aMesh->RemoveSubMesh( aSubMesh );
1848 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1850 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1853 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1854 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1855 QString objType = CheckTypeObject(IObject);
1856 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1857 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1858 aStudyBuilder->RemoveObjectWithChildren( SO );
1860 else {// default action: remove SObject from the study
1861 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1862 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1864 aStudyBuilder->RemoveObjectWithChildren( SO );
1868 } /* listSO back loop */
1870 aStudyBuilder->CommitCommand();
1872 /* Clear any previous selection */
1874 aSel->setSelectedObjects( l1 );
1876 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1881 SMESHGUI_EXPORT CAM_Module* createModule()
1883 return new SMESHGUI();
1886 SMESHGUI_EXPORT char* getModuleVersion() {
1887 return (char*)SMESH_VERSION_STR;
1891 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1893 //=============================================================================
1897 //=============================================================================
1898 SMESHGUI::SMESHGUI() :
1899 SalomeApp_Module( "SMESH" )
1901 if ( CORBA::is_nil( myComponentSMESH ) )
1903 CORBA::Boolean anIsEmbeddedMode;
1904 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1905 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1907 // 0019923: EDF 765 SMESH : default values of hypothesis
1908 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1909 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1910 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1911 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1912 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1914 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1915 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1916 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1918 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1919 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1923 myActiveDialogBox = 0;
1924 myFilterLibraryDlg = 0;
1928 myEventCallbackCommand = vtkCallbackCommand::New();
1929 myEventCallbackCommand->Delete();
1930 myEventCallbackCommand->SetClientData( this );
1931 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1934 /* load resources for all available meshers */
1935 SMESH::InitAvailableHypotheses();
1938 //=============================================================================
1942 //=============================================================================
1943 SMESHGUI::~SMESHGUI()
1947 //=============================================================================
1951 //=============================================================================
1952 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1954 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1956 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1961 //=============================================================================
1965 //=============================================================================
1966 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1968 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1972 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
1973 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1974 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
1975 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
1976 return autoUpdate && !exceeded;
1979 //=============================================================================
1983 //=============================================================================
1984 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
1986 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
1989 //=============================================================================
1993 //=============================================================================
1994 SMESHGUI* SMESHGUI::GetSMESHGUI()
1996 SMESHGUI* smeshMod = 0;
1997 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2000 CAM_Module* module = app->module( "Mesh" );
2001 smeshMod = dynamic_cast<SMESHGUI*>( module );
2004 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2006 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2009 _PTR(Study) aStudy = study->studyDS();
2011 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2020 Standard_EXPORT SMESHGUI* GetComponentGUI()
2022 return SMESHGUI::GetSMESHGUI();
2026 //=============================================================================
2030 //=============================================================================
2031 void SMESHGUI::SetState(int aState)
2036 //=============================================================================
2040 //=============================================================================
2041 void SMESHGUI::ResetState()
2046 //=============================================================================
2050 //=============================================================================
2051 void SMESHGUI::EmitSignalDeactivateDialog()
2053 emit SignalDeactivateActiveDialog();
2056 //=============================================================================
2060 //=============================================================================
2061 void SMESHGUI::EmitSignalStudyFrameChanged()
2063 emit SignalStudyFrameChanged();
2066 //=============================================================================
2070 //=============================================================================
2071 void SMESHGUI::EmitSignalCloseAllDialogs()
2073 emit SignalCloseAllDialogs();
2076 //=============================================================================
2080 //=============================================================================
2081 void SMESHGUI::EmitSignalVisibilityChanged()
2083 emit SignalVisibilityChanged();
2086 //=============================================================================
2090 //=============================================================================
2091 QDialog *SMESHGUI::GetActiveDialogBox()
2093 return myActiveDialogBox;
2096 //=============================================================================
2100 //=============================================================================
2101 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2103 myActiveDialogBox = (QDialog *) aDlg;
2107 //=============================================================================
2111 //=============================================================================
2112 SUIT_Desktop* SMESHGUI::desktop()
2114 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2116 return app->desktop();
2121 //=============================================================================
2125 //=============================================================================
2126 SalomeApp_Study* SMESHGUI::activeStudy()
2128 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2130 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2135 //=============================================================================
2139 //=============================================================================
2140 void SMESHGUI::Modified( bool theIsUpdateActions )
2142 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2143 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2144 appStudy->Modified();
2145 if( theIsUpdateActions )
2146 app->updateActions();
2151 //=============================================================================
2155 //=============================================================================
2156 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2158 /* Here the position is on the bottom right corner - 10 */
2159 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2161 SUIT_Desktop *PP = desktop();
2162 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2163 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2167 //=============================================================================
2171 //=============================================================================
2172 static int isStudyLocked(_PTR(Study) theStudy){
2173 return theStudy->GetProperties()->IsLocked();
2176 static bool checkLock(_PTR(Study) theStudy) {
2177 if (isStudyLocked(theStudy)) {
2178 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2179 QObject::tr("WRN_WARNING"),
2180 QObject::tr("WRN_STUDY_LOCKED") );
2186 //=======================================================================
2187 //function : CheckActiveStudyLocked
2189 //=======================================================================
2191 bool SMESHGUI::isActiveStudyLocked()
2193 _PTR(Study) aStudy = activeStudy()->studyDS();
2194 return checkLock( aStudy );
2197 //=============================================================================
2201 //=============================================================================
2202 bool SMESHGUI::OnGUIEvent( int theCommandID )
2204 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2208 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2209 SUIT_ResourceMgr* mgr = resourceMgr();
2213 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2214 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2217 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2218 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2220 //QAction* act = action( theCommandID );
2222 switch (theCommandID) {
2224 if(checkLock(aStudy)) break;
2236 if(checkLock(aStudy)) break;
2237 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2241 case 150: //MED FILE INFORMATION
2243 SALOME_ListIO selected;
2244 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2246 aSel->selectedObjects( selected );
2247 if( selected.Extent() )
2249 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2250 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2251 if ( !aMesh->_is_nil() )
2253 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2260 case 122: // EXPORT MED
2275 ::ExportMeshToFile(theCommandID);
2279 case 200: // SCALAR BAR
2281 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2282 SALOME_ListIO selected;
2284 aSel->selectedObjects( selected );
2286 if( selected.Extent() ) {
2287 Handle(SALOME_InteractiveObject) anIO = selected.First();
2288 if( anIO->hasEntry() ) {
2289 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2290 anActor->SetControlMode( SMESH_Actor::eNone );
2291 #ifndef DISABLE_PLOT2DVIEWER
2292 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2301 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2306 // dump control distribution data to the text file
2307 ::SaveDistribution();
2313 // show/ distribution
2314 ::ShowDistribution();
2318 #ifndef DISABLE_PLOT2DVIEWER
2321 // plot distribution
2322 ::PlotDistribution();
2333 ::DisableAutoColor();
2336 case 1134: // Clipping
2337 case 1133: // Tranparency
2338 case 1132: // Display preferences (colors, shrink size, line width, ...)
2345 ::SetDisplayMode(theCommandID, myMarkerMap);
2348 //2D quadratic representation
2351 ::SetDisplayMode(theCommandID, myMarkerMap);
2355 case 216: // 0D elements
2358 case 219: // Volumes
2359 case 220: // All Entity
2361 ::SetDisplayEntity(theCommandID);
2364 case 221: // Orientation of faces
2366 LightApp_SelectionMgr* mgr = selectionMgr();
2367 SALOME_ListIO selected; mgr->selectedObjects( selected );
2369 SALOME_ListIteratorOfListIO it(selected);
2370 for( ; it.More(); it.Next()) {
2371 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2372 if(anIObject->hasEntry()) {
2373 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2374 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2383 if(checkLock(aStudy)) break;
2384 SUIT_OverrideCursor wc;
2386 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2389 SMESH::UpdateView();
2391 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2392 SMESH::OnVisuException();
2394 catch (...) { // PAL16774 (Crash after display of many groups)
2395 SMESH::OnVisuException();
2399 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2400 aSel->selectedObjects( l );
2401 aSel->setSelectedObjects( l );
2406 case 301: // DISPLAY
2407 case 302: // DISPLAY ONLY
2409 SMESH::EDisplaing anAction;
2410 switch (theCommandID) {
2411 case 300: anAction = SMESH::eErase; break;
2412 case 301: anAction = SMESH::eDisplay; break;
2413 case 302: anAction = SMESH::eDisplayOnly; break;
2416 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2417 SALOME_ListIO sel_objects, to_process;
2419 aSel->selectedObjects( sel_objects );
2421 if( theCommandID==302 )
2423 MESSAGE("anAction = SMESH::eDisplayOnly");
2424 startOperation( myEraseAll );
2427 extractContainers( sel_objects, to_process );
2430 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2434 SALOME_ListIteratorOfListIO It( to_process );
2435 for ( ; It.More(); It.Next()) {
2437 Handle(SALOME_InteractiveObject) IOS = It.Value();
2438 if (IOS->hasEntry()) {
2440 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2441 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2442 break; // PAL16774 (Crash after display of many groups)
2444 if (anAction == SMESH::eDisplayOnly)
2446 MESSAGE("anAction = SMESH::eDisplayOnly");
2447 anAction = SMESH::eDisplay;
2453 // PAL13338 + PAL15161 -->
2454 if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2455 MESSAGE("anAction = SMESH::eDisplayOnly");
2456 SMESH::UpdateView();
2457 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2459 // PAL13338 + PAL15161 <--
2461 catch (...) { // PAL16774 (Crash after display of many groups)
2462 SMESH::OnVisuException();
2465 if (anAction == SMESH::eErase) {
2466 MESSAGE("anAction == SMESH::eErase");
2468 aSel->setSelectedObjects( l1 );
2471 aSel->setSelectedObjects( to_process );
2478 if(checkLock(aStudy)) break;
2481 EmitSignalDeactivateDialog();
2483 ( new SMESHGUI_NodesDlg( this ) )->show();
2486 SUIT_MessageBox::warning(desktop(),
2487 tr("SMESH_WRN_WARNING"),
2488 tr("SMESH_WRN_VIEWER_VTK"));
2493 case 2151: // FILTER
2497 EmitSignalDeactivateDialog();
2498 ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2503 case 701: // COMPUTE MESH
2504 case 711: // PRECOMPUTE MESH
2505 case 712: // EVALUATE MESH
2506 case 713: // MESH ORDER
2507 case 702: // Create mesh
2508 case 703: // Create sub-mesh
2509 case 704: // Edit mesh/sub-mesh
2510 startOperation( theCommandID );
2512 case 705: // copy mesh
2514 if (checkLock(aStudy)) break;
2515 EmitSignalDeactivateDialog();
2516 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2519 case 710: // Build compound mesh
2521 if (checkLock(aStudy)) break;
2522 EmitSignalDeactivateDialog();
2523 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2527 case 407: // DIAGONAL INVERSION
2528 case 408: // Delete diagonal
2532 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2533 tr( "NOT_A_VTK_VIEWER" ) );
2537 if ( checkLock( aStudy ) )
2540 /*Standard_Boolean aRes;
2541 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2542 if ( aMesh->_is_nil() )
2544 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2545 tr( "SMESH_BAD_SELECTION" ) );
2549 EmitSignalDeactivateDialog();
2550 if ( theCommandID == 407 )
2551 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2553 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2556 case 409: // Change orientation
2557 case 410: // Union of triangles
2558 case 411: // Cutting of quadrangles
2559 case 419: // Splitting volumes into tetrahedra
2563 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2564 tr( "NOT_A_VTK_VIEWER" ) );
2568 if ( checkLock( aStudy ) )
2571 EmitSignalDeactivateDialog();
2572 SMESHGUI_MultiEditDlg* aDlg = NULL;
2573 if ( theCommandID == 409 )
2574 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2575 else if ( theCommandID == 410 )
2576 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2577 else if ( theCommandID == 419 )
2578 aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2580 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2585 case 412: // Smoothing
2587 if(checkLock(aStudy)) break;
2589 EmitSignalDeactivateDialog();
2590 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2593 SUIT_MessageBox::warning(desktop(),
2594 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2598 case 413: // Extrusion
2600 if (checkLock(aStudy)) break;
2602 EmitSignalDeactivateDialog();
2603 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2605 SUIT_MessageBox::warning(desktop(),
2606 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2610 case 414: // Revolution
2612 if(checkLock(aStudy)) break;
2614 EmitSignalDeactivateDialog();
2615 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2618 SUIT_MessageBox::warning(desktop(),
2619 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2623 case 415: // Pattern mapping
2625 if ( checkLock( aStudy ) )
2629 EmitSignalDeactivateDialog();
2630 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2633 SUIT_MessageBox::warning(desktop(),
2634 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2638 case 416: // Extrusion along a path
2640 if (checkLock(aStudy)) break;
2642 EmitSignalDeactivateDialog();
2643 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2645 SUIT_MessageBox::warning(desktop(),
2646 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2650 case 417: // Convert mesh to quadratic
2651 case 418: // create 2D mesh from 3D
2652 case 420: // Reorient faces
2653 case 806: // CREATE GEO GROUP
2655 startOperation( theCommandID );
2658 case 801: // CREATE GROUP
2662 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2663 tr( "NOT_A_VTK_VIEWER" ) );
2667 if(checkLock(aStudy)) break;
2668 EmitSignalDeactivateDialog();
2669 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2671 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2672 SALOME_ListIO selected;
2674 aSel->selectedObjects( selected );
2676 int nbSel = selected.Extent();
2678 // check if mesh is selected
2679 aMesh = SMESH::GetMeshByIO( selected.First() );
2681 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2686 case 802: // CONSTRUCT GROUP
2690 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2691 tr( "NOT_A_VTK_VIEWER" ) );
2695 if(checkLock(aStudy)) break;
2696 EmitSignalDeactivateDialog();
2698 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2699 SALOME_ListIO selected;
2701 aSel->selectedObjects( selected );
2703 int nbSel = selected.Extent();
2705 // check if submesh is selected
2706 Handle(SALOME_InteractiveObject) IObject = selected.First();
2707 if (IObject->hasEntry()) {
2708 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2710 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2711 if (!aSubMesh->_is_nil()) {
2713 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2714 // get submesh elements list by types
2715 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2716 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2717 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2718 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2719 // create group for each type o elements
2720 QString aName = IObject->getName();
2721 QStringList anEntryList;
2722 if (aNodes->length() > 0) {
2723 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2724 aGroup->Add(aNodes.inout());
2725 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2726 anEntryList.append( aSObject->GetID().c_str() );
2728 if (aEdges->length() > 0) {
2729 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2730 aGroup->Add(aEdges.inout());
2731 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2732 anEntryList.append( aSObject->GetID().c_str() );
2734 if (aFaces->length() > 0) {
2735 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2736 aGroup->Add(aFaces.inout());
2737 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2738 anEntryList.append( aSObject->GetID().c_str() );
2740 if (aVolumes->length() > 0) {
2741 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2742 aGroup->Add(aVolumes.inout());
2743 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2744 anEntryList.append( aSObject->GetID().c_str() );
2747 anApp->browseObjects( anEntryList );
2749 catch(const SALOME::SALOME_Exception & S_ex){
2750 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2757 SUIT_MessageBox::warning(desktop(),
2758 tr("SMESH_WRN_WARNING"),
2759 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2764 case 803: // EDIT GROUP
2768 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2769 tr( "NOT_A_VTK_VIEWER" ) );
2773 if(checkLock(aStudy)) break;
2774 EmitSignalDeactivateDialog();
2776 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2777 SALOME_ListIO selected;
2779 aSel->selectedObjects( selected );
2781 SALOME_ListIteratorOfListIO It (selected);
2782 int nbSelectedGroups = 0;
2783 for ( ; It.More(); It.Next() )
2785 SMESH::SMESH_GroupBase_var aGroup =
2786 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2787 if (!aGroup->_is_nil()) {
2789 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2793 if (nbSelectedGroups == 0)
2795 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2801 case 804: // Add elements to group
2803 if(checkLock(aStudy)) break;
2804 if (myState == 800) {
2805 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2806 if (aDlg) aDlg->onAdd();
2811 case 805: // Remove elements from group
2813 if(checkLock(aStudy)) break;
2814 if (myState == 800) {
2815 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2816 if (aDlg) aDlg->onRemove();
2821 case 815: // Edit GEOM GROUP as standalone
2825 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2826 tr( "NOT_A_VTK_VIEWER" ) );
2830 if(checkLock(aStudy)) break;
2831 EmitSignalDeactivateDialog();
2833 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2834 SALOME_ListIO selected;
2836 aSel->selectedObjects( selected );
2838 SALOME_ListIteratorOfListIO It (selected);
2839 for ( ; It.More(); It.Next() )
2841 SMESH::SMESH_GroupOnGeom_var aGroup =
2842 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2843 if (!aGroup->_is_nil()) {
2844 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2849 SMESH::SMESH_GroupOnFilter_var aGroup =
2850 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2851 if (!aGroup->_is_nil()) {
2852 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2860 case 810: // Union Groups
2861 case 811: // Intersect groups
2862 case 812: // Cut groups
2866 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2867 tr( "NOT_A_VTK_VIEWER" ) );
2871 if ( checkLock( aStudy ) )
2874 EmitSignalDeactivateDialog();
2876 SMESHGUI_GroupOpDlg* aDlg = 0;
2877 if ( theCommandID == 810 )
2878 aDlg = new SMESHGUI_UnionGroupsDlg( this );
2879 else if ( theCommandID == 811 )
2880 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2882 aDlg = new SMESHGUI_CutGroupsDlg( this );
2889 case 814: // Create groups of entities from existing groups of superior dimensions
2891 if ( checkLock( aStudy ) )
2894 EmitSignalDeactivateDialog();
2895 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2901 case 813: // Delete groups with their contents
2905 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2906 tr( "NOT_A_VTK_VIEWER" ) );
2910 if ( checkLock( aStudy ) )
2913 EmitSignalDeactivateDialog();
2915 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2919 case 900: // MESH INFOS
2920 case 903: // WHAT IS
2922 int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2923 EmitSignalDeactivateDialog();
2924 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2925 SALOME_ListIO selected;
2927 aSel->selectedObjects( selected );
2929 if ( selected.Extent() > 1 ) { // a dlg for each IO
2930 SALOME_ListIteratorOfListIO It( selected );
2931 for ( ; It.More(); It.Next() ) {
2932 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2933 dlg->showInfo( It.Value() );
2938 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2944 case 904: // FIND ELEM
2946 startOperation( theCommandID );
2950 case 1100: // EDIT HYPOTHESIS
2952 if(checkLock(aStudy)) break;
2954 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2955 SALOME_ListIO selected;
2957 aSel->selectedObjects( selected );
2959 int nbSel = selected.Extent();
2962 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2963 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
2965 /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
2966 /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects */
2967 /* Warning : however by internal mechanism all subMeshes icons are changed ! */
2968 if ( !aHypothesis->_is_nil() )
2971 //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2972 SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2974 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
2984 case 1102: // REMOVE HYPOTHESIS / ALGORITHMS
2986 if(checkLock(aStudy)) break;
2987 SUIT_OverrideCursor wc;
2989 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2990 SALOME_ListIO selected;
2992 aSel->selectedObjects( selected, QString::null, false );
2994 SALOME_ListIteratorOfListIO It(selected);
2995 for (int i = 0; It.More(); It.Next(), i++) {
2996 Handle(SALOME_InteractiveObject) IObject = It.Value();
2997 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3000 aSel->setSelectedObjects( l1 );
3006 case 4009: // ELEM0D
3008 case 4021: // TRIANGLE
3010 case 4023: // POLYGON
3014 case 4134: // PYRAMID
3015 case 4135: // OCTA12
3017 if(checkLock(aStudy)) break;
3019 EmitSignalDeactivateDialog();
3020 SMDSAbs_EntityType type = SMDSEntity_Edge;
3021 switch (theCommandID) {
3022 case 4008: type = SMDSEntity_Ball; break;
3023 case 4009: type = SMDSEntity_0D; break;
3024 case 4021: type = SMDSEntity_Triangle; break;
3025 case 4022: type = SMDSEntity_Quadrangle; break;
3026 case 4031: type = SMDSEntity_Tetra; break;
3027 case 4023: type = SMDSEntity_Polygon; break;
3028 case 4032: type = SMDSEntity_Hexa; break;
3029 case 4133: type = SMDSEntity_Penta; break;
3030 case 4134: type = SMDSEntity_Pyramid; break;
3031 case 4135: type = SMDSEntity_Hexagonal_Prism; break;
3034 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3037 SUIT_MessageBox::warning(desktop(),
3038 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3042 case 4033: // POLYHEDRON
3044 if(checkLock(aStudy)) break;
3046 EmitSignalDeactivateDialog();
3047 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3050 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3051 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3055 case 4034: // QUADRATIC EDGE
3056 case 4035: // QUADRATIC TRIANGLE
3057 case 4036: // QUADRATIC QUADRANGLE
3058 case 4136: // BIQUADRATIC QUADRANGLE
3059 case 4137: // BIQUADRATIC TRIANGLE
3060 case 4037: // QUADRATIC TETRAHEDRON
3061 case 4038: // QUADRATIC PYRAMID
3062 case 4039: // QUADRATIC PENTAHEDRON
3063 case 4040: // QUADRATIC HEXAHEDRON
3064 case 4140: // TRIQUADRATIC HEXAHEDRON
3066 if(checkLock(aStudy)) break;
3068 EmitSignalDeactivateDialog();
3069 SMDSAbs_EntityType type = SMDSEntity_Last;
3071 switch (theCommandID) {
3072 case 4034: type = SMDSEntity_Quad_Edge; break;
3073 case 4035: type = SMDSEntity_Quad_Triangle; break;
3074 case 4036: type = SMDSEntity_Quad_Quadrangle; break;
3075 case 4136: type = SMDSEntity_BiQuad_Quadrangle; break;
3076 case 4137: type = SMDSEntity_BiQuad_Triangle; break;
3077 case 4037: type = SMDSEntity_Quad_Tetra; break;
3078 case 4038: type = SMDSEntity_Quad_Pyramid; break;
3079 case 4039: type = SMDSEntity_Quad_Penta; break;
3080 case 4040: type = SMDSEntity_Quad_Hexa; break;
3081 case 4140: type = SMDSEntity_TriQuad_Hexa; break;
3084 if ( type != SMDSEntity_Last )
3085 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3088 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3089 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3093 case 4041: // REMOVES NODES
3095 if(checkLock(aStudy)) break;
3097 EmitSignalDeactivateDialog();
3098 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3101 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3102 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3106 case 4042: // REMOVES ELEMENTS
3108 if(checkLock(aStudy)) break;
3110 EmitSignalDeactivateDialog();
3111 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3115 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3116 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3120 case 4043: { // CLEAR_MESH
3122 if(checkLock(aStudy)) break;
3124 SALOME_ListIO selected;
3125 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3126 aSel->selectedObjects( selected );
3128 SUIT_OverrideCursor wc;
3129 SALOME_ListIteratorOfListIO It (selected);
3130 for ( ; It.More(); It.Next() )
3132 Handle(SALOME_InteractiveObject) IOS = It.Value();
3133 SMESH::SMESH_Mesh_var aMesh =
3134 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3135 if ( aMesh->_is_nil()) continue;
3137 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3139 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3140 SMESH::ModifiedMesh( aMeshSObj, false, true);
3141 // hide groups and submeshes
3142 _PTR(ChildIterator) anIter =
3143 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3144 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3146 _PTR(SObject) so = anIter->Value();
3147 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3150 catch (const SALOME::SALOME_Exception& S_ex){
3152 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3156 SMESH::UpdateView();
3160 case 4044: // REMOVE ORPHAN NODES
3162 if(checkLock(aStudy)) break;
3163 SALOME_ListIO selected;
3164 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3165 aSel->selectedObjects( selected );
3166 if ( selected.Extent() == 1 ) {
3167 Handle(SALOME_InteractiveObject) anIO = selected.First();
3168 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3169 if ( !aMesh->_is_nil() ) {
3170 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3171 tr( "SMESH_WARNING" ),
3172 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3173 SUIT_MessageBox::Yes |
3174 SUIT_MessageBox::No,
3175 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3178 SUIT_OverrideCursor wc;
3179 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3180 int removed = aMeshEditor->RemoveOrphanNodes();
3181 SUIT_MessageBox::information(SMESHGUI::desktop(),
3182 tr("SMESH_INFORMATION"),
3183 tr("NB_NODES_REMOVED").arg(removed));
3184 if ( removed > 0 ) {
3185 SMESH::UpdateView();
3186 SMESHGUI::Modified();
3189 catch (const SALOME::SALOME_Exception& S_ex) {
3190 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3199 case 4051: // RENUMBERING NODES
3201 if(checkLock(aStudy)) break;
3203 EmitSignalDeactivateDialog();
3204 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3208 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3209 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3213 case 4052: // RENUMBERING ELEMENTS
3215 if(checkLock(aStudy)) break;
3217 EmitSignalDeactivateDialog();
3218 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3222 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3223 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3227 case 4061: // TRANSLATION
3229 if(checkLock(aStudy)) break;
3231 EmitSignalDeactivateDialog();
3232 ( new SMESHGUI_TranslationDlg( this ) )->show();
3235 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3236 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3240 case 4062: // ROTATION
3242 if(checkLock(aStudy)) break;
3244 EmitSignalDeactivateDialog();
3245 ( new SMESHGUI_RotationDlg( this ) )->show();
3248 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3249 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3253 case 4063: // SYMMETRY
3255 if(checkLock(aStudy)) break;
3257 EmitSignalDeactivateDialog();
3258 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3261 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3262 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3266 case 4064: // SEWING
3268 if(checkLock(aStudy)) break;
3270 EmitSignalDeactivateDialog();
3271 ( new SMESHGUI_SewingDlg( this ) )->show();
3274 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3275 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3279 case 4065: // MERGE NODES
3281 if(checkLock(aStudy)) break;
3283 EmitSignalDeactivateDialog();
3284 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3287 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3288 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3292 case 4066: // MERGE EQUAL ELEMENTS
3294 if (checkLock(aStudy)) break;
3296 EmitSignalDeactivateDialog();
3297 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3299 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3300 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3305 case 4067: // MAKE MESH PASS THROUGH POINT
3306 startOperation( 4067 );
3311 if(checkLock(aStudy)) break;
3313 EmitSignalDeactivateDialog();
3314 ( new SMESHGUI_ScaleDlg( this ) )->show();
3317 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3318 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3323 case 4069: // DUPLICATE NODES
3325 if(checkLock(aStudy)) break;
3327 EmitSignalDeactivateDialog();
3328 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3331 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3332 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3337 case 4070: // 0D_ON_ALL_NODES
3338 startOperation( 4070 );
3341 case 5105: // Library of selection filters
3343 static QList<int> aTypes;
3344 if ( aTypes.isEmpty() )
3346 aTypes.append( SMESH::NODE );
3347 aTypes.append( SMESH::EDGE );
3348 aTypes.append( SMESH::FACE );
3349 aTypes.append( SMESH::VOLUME );
3351 if (!myFilterLibraryDlg)
3352 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3353 else if (myFilterLibraryDlg->isHidden())
3354 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3355 myFilterLibraryDlg->raise();
3359 case 6017: // CONTROLS
3387 LightApp_SelectionMgr* mgr = selectionMgr();
3388 SALOME_ListIO selected; mgr->selectedObjects( selected );
3390 if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3391 _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3393 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3394 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
3395 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3396 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
3397 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3398 SUIT_OverrideCursor wc;
3399 ::Control( theCommandID );
3404 SUIT_MessageBox::warning(desktop(),
3405 tr( "SMESH_WRN_WARNING" ),
3406 tr( "SMESH_BAD_SELECTION" ) );
3410 SUIT_MessageBox::warning(desktop(),
3411 tr( "SMESH_WRN_WARNING" ),
3412 tr( "NOT_A_VTK_VIEWER" ) );
3416 OverallMeshQuality();
3420 SUIT_OverrideCursor wc;
3421 LightApp_SelectionMgr* mgr = selectionMgr();
3422 SALOME_ListIO selected; mgr->selectedObjects( selected );
3424 SALOME_ListIteratorOfListIO it(selected);
3425 for( ; it.More(); it.Next()) {
3426 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3427 if(anIObject->hasEntry()) {
3428 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3429 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3437 SUIT_OverrideCursor wc;
3438 LightApp_SelectionMgr* mgr = selectionMgr();
3439 SALOME_ListIO selected; mgr->selectedObjects( selected );
3441 SALOME_ListIteratorOfListIO it(selected);
3442 for( ; it.More(); it.Next()) {
3443 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3444 if(anIObject->hasEntry())
3445 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3446 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3454 int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3455 EmitSignalDeactivateDialog();
3456 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3462 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3463 //updateObjBrowser();
3467 //=============================================================================
3471 //=============================================================================
3472 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3477 //=============================================================================
3481 //=============================================================================
3482 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3487 //=============================================================================
3491 //=============================================================================
3492 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3497 //=============================================================================
3498 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3499 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3501 //=============================================================================
3502 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3503 SUIT_ViewWindow* wnd )
3505 if(theIO->hasEntry()){
3506 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3507 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3511 //=======================================================================
3512 // function : createSMESHAction
3514 //=======================================================================
3515 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3516 const int key, const bool toggle, const QString& shortcutAction )
3519 QWidget* parent = application()->desktop();
3520 SUIT_ResourceMgr* resMgr = resourceMgr();
3522 if ( !icon_id.isEmpty() )
3523 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3525 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3526 if ( !pix.isNull() )
3527 icon = QIcon( pix );
3529 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3530 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3531 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3533 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3534 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3537 //=======================================================================
3538 // function : createPopupItem
3540 //=======================================================================
3541 void SMESHGUI::createPopupItem( const int id,
3542 const QString& clients,
3543 const QString& types,
3544 const QString& theRule,
3547 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3548 popupMgr()->insert( action( id ), pId, 0 );
3550 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3551 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3552 QString rule = "(%1) and (%2) and (%3)";
3553 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3554 if( clients.isEmpty() )
3555 rule = rule.arg( QString( "true" ) );
3557 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3558 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3561 bool cont = myRules.contains( id );
3563 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3565 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3566 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3569 //=======================================================================
3570 // function : initialize
3572 //=======================================================================
3573 void SMESHGUI::initialize( CAM_Application* app )
3575 SalomeApp_Module::initialize( app );
3577 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3579 /* Automatic Update flag */
3580 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3582 // ----- create actions --------------
3584 //createSMESHAction( 111, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3585 createSMESHAction( 112, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3586 createSMESHAction( 113, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3587 createSMESHAction( 114, "NUM" );
3588 createSMESHAction( 115, "IMPORT_STL" );
3589 createSMESHAction( 116, "IMPORT_CGNS" );
3590 createSMESHAction( 117, "IMPORT_SAUV" );
3591 createSMESHAction( 118, "IMPORT_GMF" );
3592 createSMESHAction( 121, "DAT" );
3593 createSMESHAction( 122, "MED" );
3594 createSMESHAction( 123, "UNV" );
3595 createSMESHAction( 140, "STL" );
3596 createSMESHAction( 142, "CGNS");
3597 createSMESHAction( 144, "SAUV");
3598 createSMESHAction( 146, "GMF" );
3599 createSMESHAction( 124, "DAT" );
3600 createSMESHAction( 125, "MED" );
3601 createSMESHAction( 126, "UNV" );
3602 createSMESHAction( 141, "STL" );
3603 createSMESHAction( 143, "CGNS");
3604 createSMESHAction( 145, "SAUV");
3605 createSMESHAction( 147, "GMF" );
3606 createSMESHAction( 150, "FILE_INFO" );
3607 createSMESHAction( 33, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3608 createSMESHAction( 5105, "SEL_FILTER_LIB" );
3609 createSMESHAction( 701, "COMPUTE", "ICON_COMPUTE" );
3610 createSMESHAction( 702, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3611 createSMESHAction( 703, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3612 createSMESHAction( 704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3613 createSMESHAction( 705, "COPY_MESH", "ICON_COPY_MESH" );
3614 createSMESHAction( 710, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3615 createSMESHAction( 711, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3616 createSMESHAction( 712, "EVALUATE", "ICON_COMPUTE" );
3617 createSMESHAction( 713, "MESH_ORDER", "ICON_COMPUTE" );
3618 createSMESHAction( 806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3619 createSMESHAction( 801, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3620 createSMESHAction( 802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3621 createSMESHAction( 803, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3622 createSMESHAction( 815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3623 createSMESHAction( 804, "ADD" );
3624 createSMESHAction( 805, "REMOVE" );
3625 createSMESHAction( 810, "UN_GROUP", "ICON_UNION" );
3626 createSMESHAction( 811, "INT_GROUP", "ICON_INTERSECT" );
3627 createSMESHAction( 812, "CUT_GROUP", "ICON_CUT" );
3628 createSMESHAction( 814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3629 createSMESHAction( 813, "DEL_GROUP", "ICON_DEL_GROUP" );
3630 createSMESHAction( 900, "ADV_INFO", "ICON_ADV_INFO" );
3631 //createSMESHAction( 902, "STD_INFO", "ICON_STD_INFO" );
3632 //createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3633 createSMESHAction( 904, "FIND_ELEM", "ICON_FIND_ELEM" );
3634 createSMESHAction( 6001, "LENGTH", "ICON_LENGTH", 0, true );
3635 createSMESHAction( 6002, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3636 createSMESHAction( 6021, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3637 createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3638 createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3639 createSMESHAction( 6024, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3640 createSMESHAction( 6025, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3641 createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3642 createSMESHAction( 6027, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3643 createSMESHAction( 6028, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3644 createSMESHAction( 6029, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3645 createSMESHAction( 6030, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3646 createSMESHAction( 6031, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3647 createSMESHAction( 6032, "OVERALL_MESH_QUALITY" );
3648 createSMESHAction( 6003, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3649 createSMESHAction( 6004, "CONNECTION", "ICON_CONNECTION", 0, true );
3650 createSMESHAction( 6005, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3651 createSMESHAction( 6011, "AREA", "ICON_AREA", 0, true );
3652 createSMESHAction( 6012, "TAPER", "ICON_TAPER", 0, true );
3653 createSMESHAction( 6013, "ASPECT", "ICON_ASPECT", 0, true );
3654 createSMESHAction( 6014, "MIN_ANG", "ICON_ANGLE", 0, true );
3655 createSMESHAction( 6015, "WARP", "ICON_WARP", 0, true );
3656 createSMESHAction( 6016, "SKEW", "ICON_SKEW", 0, true );
3657 createSMESHAction( 6017, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3658 createSMESHAction( 6018, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3659 createSMESHAction( 6019, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3660 createSMESHAction( 6009, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3661 createSMESHAction( 4000, "NODE", "ICON_DLG_NODE" );
3662 createSMESHAction( 4009, "ELEM0D", "ICON_DLG_ELEM0D" );
3663 createSMESHAction( 4008, "BALL", "ICON_DLG_BALL" );
3664 createSMESHAction( 4010, "EDGE", "ICON_DLG_EDGE" );
3665 createSMESHAction( 4021, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3666 createSMESHAction( 4022, "QUAD", "ICON_DLG_QUADRANGLE" );
3667 createSMESHAction( 4023, "POLYGON", "ICON_DLG_POLYGON" );
3668 createSMESHAction( 4031, "TETRA", "ICON_DLG_TETRAS" );
3669 createSMESHAction( 4032, "HEXA", "ICON_DLG_HEXAS" );
3670 createSMESHAction( 4133, "PENTA", "ICON_DLG_PENTA" );
3671 createSMESHAction( 4134, "PYRAMID", "ICON_DLG_PYRAMID" );
3672 createSMESHAction( 4135, "OCTA", "ICON_DLG_OCTA" );
3673 createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3674 createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3675 createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3676 createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3677 createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3678 createSMESHAction( 4137, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3679 createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3680 createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3681 createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3682 createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3683 createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3684 createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3685 createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3686 createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3687 createSMESHAction( 4043, "CLEAR_MESH" , "ICON_CLEAR_MESH" );
3688 createSMESHAction( 4051, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3689 createSMESHAction( 4052, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3690 createSMESHAction( 4061, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3691 createSMESHAction( 4062, "ROT", "ICON_DLG_MESH_ROTATION" );
3692 createSMESHAction( 4063, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3693 createSMESHAction( 4064, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3694 createSMESHAction( 4065, "MERGE", "ICON_SMESH_MERGE_NODES" );
3695 createSMESHAction( 4066, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3696 createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3697 createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" );
3698 createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3699 createSMESHAction( 4070, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3700 createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" );
3701 createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" );
3702 createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3703 createSMESHAction( 410, "UNION", "ICON_UNIONTRI" );
3704 createSMESHAction( 411, "CUT", "ICON_CUTQUAD" );
3705 createSMESHAction( 412, "SMOOTH", "ICON_DLG_SMOOTHING" );
3706 createSMESHAction( 413, "EXTRUSION", "ICON_EXTRUSION" );
3707 createSMESHAction( 414, "REVOLUTION", "ICON_REVOLUTION" );
3708 createSMESHAction( 415, "MAP", "ICON_MAP" );
3709 createSMESHAction( 416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3710 createSMESHAction( 417, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3711 createSMESHAction( 418, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3712 createSMESHAction( 419, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3713 createSMESHAction( 420, "REORIENT_2D", "ICON_REORIENT_2D" );
3714 createSMESHAction( 200, "RESET" );
3715 createSMESHAction( 201, "SCALAR_BAR_PROP" );
3716 createSMESHAction( 2021, "SAVE_DISTRIBUTION" );
3717 createSMESHAction( 2022, "SHOW_DISTRIBUTION","",0, true );
3718 #ifndef DISABLE_PLOT2DVIEWER
3719 createSMESHAction( 2023, "PLOT_DISTRIBUTION" );
3721 createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true );
3722 createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true );
3723 createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true );
3724 createSMESHAction( 214, "UPDATE", "ICON_UPDATE" );
3725 createSMESHAction( 215, "NODES", "ICON_POINTS", 0, true );
3726 createSMESHAction( 222, "BALLS", "ICON_DLG_BALL", 0, true );
3727 createSMESHAction( 216, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3728 createSMESHAction( 217, "EDGES", "ICON_DLG_EDGE", 0, true );
3729 createSMESHAction( 218, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3730 createSMESHAction( 219, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3731 createSMESHAction( 220, "ALL" );
3732 createSMESHAction( 221, "FACE_ORIENTATION", "", 0, true );
3734 createSMESHAction( 231, "LINE_REPRESENTATION", "", 0, true );
3735 createSMESHAction( 232, "ARC_REPRESENTATION", "", 0, true );
3737 createSMESHAction( 1100, "EDIT_HYPO" );
3738 createSMESHAction( 1102, "UNASSIGN" );
3739 createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3740 createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3741 createSMESHAction( 1131, "DISPMODE" );
3742 createSMESHAction( 1132, "COLORS" );
3743 createSMESHAction( 1133, "TRANSP" );
3744 createSMESHAction( 1134, "CLIP" );
3745 createSMESHAction( 1135, "DISP_ENT" );
3746 createSMESHAction( 1136, "AUTO_COLOR" );
3747 createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3748 createSMESHAction( 2000, "CTRL" );
3750 createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3751 createSMESHAction( 502, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3753 createSMESHAction( 300, "HIDE" );
3754 createSMESHAction( 301, "SHOW" );
3755 createSMESHAction( 302, "DISPLAY_ONLY" );
3757 // ----- create menu --------------
3758 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3759 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3760 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3761 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3762 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3763 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3764 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3765 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3767 createMenu( separator(), fileId );
3769 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3770 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3771 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3772 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3773 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3774 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3775 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3776 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3777 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3778 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3780 //createMenu( 111, importId, -1 );
3781 createMenu( 112, importId, -1 );
3782 createMenu( 113, importId, -1 );
3783 createMenu( 115, importId, -1 );
3785 createMenu( 116, importId, -1 );
3787 createMenu( 117, importId, -1 );
3788 createMenu( 118, importId, -1 );
3789 createMenu( 121, exportId, -1 );
3790 createMenu( 122, exportId, -1 );
3791 createMenu( 123, exportId, -1 );
3792 createMenu( 140, exportId, -1 ); // export to STL
3794 createMenu( 142, exportId, -1 ); // export to CGNS
3796 createMenu( 144, exportId, -1 ); // export to SAUV
3797 createMenu( 146, exportId, -1 ); // export to GMF
3798 createMenu( separator(), fileId, 10 );
3800 createMenu( 33, editId, -1 );
3802 createMenu( 5105, toolsId, -1 );
3804 createMenu( 702, meshId, -1 ); // "Mesh" menu
3805 createMenu( 703, meshId, -1 );
3806 createMenu( 704, meshId, -1 );
3807 createMenu( 710, meshId, -1 );
3808 createMenu( 705, meshId, -1 );
3809 createMenu( separator(), meshId, -1 );
3810 createMenu( 701, meshId, -1 );
3811 createMenu( 711, meshId, -1 );
3812 createMenu( 712, meshId, -1 );
3813 createMenu( 713, meshId, -1 );
3814 createMenu( separator(), meshId, -1 );
3815 createMenu( 801, meshId, -1 );
3816 createMenu( 806, meshId, -1 );
3817 createMenu( 802, meshId, -1 );
3818 createMenu( 803, meshId, -1 );
3819 createMenu( 815, meshId, -1 );
3820 createMenu( separator(), meshId, -1 );
3821 createMenu( 810, meshId, -1 );
3822 createMenu( 811, meshId, -1 );
3823 createMenu( 812, meshId, -1 );
3824 createMenu( separator(), meshId, -1 );
3825 createMenu( 814, meshId, -1 );
3826 createMenu( separator(), meshId, -1 );
3827 createMenu( 900, meshId, -1 );
3828 //createMenu( 902, meshId, -1 );
3829 //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3830 createMenu( 904, meshId, -1 );
3831 createMenu( separator(), meshId, -1 );
3833 createMenu( 6005, nodeId, -1 );
3834 createMenu( 6028, nodeId, -1 );
3835 createMenu( 6002, edgeId, -1 );
3836 createMenu( 6003, edgeId, -1 );
3837 createMenu( 6001, edgeId, -1 );
3838 createMenu( 6004, edgeId, -1 );
3839 createMenu( 6029, edgeId, -1 );
3840 createMenu( 6021, faceId, -1 );
3841 createMenu( 6025, faceId, -1 );
3842 createMenu( 6027, faceId, -1 );
3843 createMenu( 6018, faceId, -1 );
3844 createMenu( 6019, faceId, -1 );
3845 createMenu( 6011, faceId, -1 );
3846 createMenu( 6012, faceId, -1 );
3847 createMenu( 6013, faceId, -1 );
3848 createMenu( 6014, faceId, -1 );
3849 createMenu( 6015, faceId, -1 );
3850 createMenu( 6016, faceId, -1 );
3851 createMenu( 6022, faceId, -1 );
3852 createMenu( 6030, faceId, -1 );
3853 createMenu( 6017, volumeId, -1 );
3854 createMenu( 6009, volumeId, -1 );
3855 createMenu( 6023, volumeId, -1 );
3856 createMenu( 6024, volumeId, -1 );
3857 createMenu( 6026, volumeId, -1 );
3858 createMenu( 6031, volumeId, -1 );
3859 createMenu( separator(), ctrlId, -1 );
3860 createMenu( 6032, ctrlId, -1 );
3862 createMenu( 4000, addId, -1 );
3863 createMenu( 4009, addId, -1 );
3864 createMenu( 4070, addId, -1 );
3865 createMenu( 4008, addId, -1 );
3866 createMenu( 4010, addId, -1 );
3867 createMenu( 4021, addId, -1 );
3868 createMenu( 4022, addId, -1 );
3869 createMenu( 4023, addId, -1 );
3870 createMenu( 4031, addId, -1 );
3871 createMenu( 4032, addId, -1 );
3872 createMenu( 4133, addId, -1 );
3873 createMenu( 4134, addId, -1 );
3874 createMenu( 4135, addId, -1 );
3875 createMenu( 4033, addId, -1 );
3876 createMenu( separator(), addId, -1 );
3877 createMenu( 4034, addId, -1 );
3878 createMenu( 4035, addId, -1 );
3879 createMenu( 4137, addId, -1 );
3880 createMenu( 4036, addId, -1 );
3881 createMenu( 4136, addId, -1 );
3882 createMenu( 4037, addId, -1 );
3883 createMenu( 4038, addId, -1 );
3884 createMenu( 4039, addId, -1 );
3885 createMenu( 4040, addId, -1 );
3886 createMenu( 4140, addId, -1 );
3888 createMenu( 4041, removeId, -1 );
3889 createMenu( 4042, removeId, -1 );
3890 createMenu( 4044, removeId, -1 );
3891 createMenu( separator(), removeId, -1 );
3892 createMenu( 813, removeId, -1 );
3893 createMenu( separator(), removeId, -1 );
3894 createMenu( 4043, removeId, -1 );
3896 createMenu( 4051, renumId, -1 );
3897 createMenu( 4052, renumId, -1 );
3899 createMenu( 4061, transfId, -1 );
3900 createMenu( 4062, transfId, -1 );
3901 createMenu( 4063, transfId, -1 );
3902 createMenu( 4068, transfId, -1 );
3903 createMenu( 4064, transfId, -1 );
3904 createMenu( 4065, transfId, -1 );
3905 createMenu( 4066, transfId, -1 );
3906 createMenu( 4069, transfId, -1 );
3908 createMenu( 4067,modifyId, -1 );
3909 createMenu( 407, modifyId, -1 );
3910 createMenu( 408, modifyId, -1 );
3911 createMenu( 409, modifyId, -1 );
3912 createMenu( 420, modifyId, -1 );
3913 createMenu( 410, modifyId, -1 );
3914 createMenu( 411, modifyId, -1 );
3915 createMenu( 419, modifyId, -1 );
3916 createMenu( 412, modifyId, -1 );
3917 createMenu( 413, modifyId, -1 );
3918 createMenu( 416, modifyId, -1 );
3919 createMenu( 414, modifyId, -1 );
3920 createMenu( 415, modifyId, -1 );
3921 createMenu( 417, modifyId, -1 );
3922 createMenu( 418, modifyId, -1 );
3924 createMenu( 501, measureId, -1 );
3925 createMenu( 502, measureId, -1 );
3926 createMenu( 214, viewId, -1 );
3928 // ----- create toolbars --------------
3929 int meshTb = createTool( tr( "TB_MESH" ) ),
3930 ctrlTb = createTool( tr( "TB_CTRL" ) ),
3931 addRemTb = createTool( tr( "TB_ADD_REMOVE" ) ),
3932 modifyTb = createTool( tr( "TB_MODIFY" ) ),
3933 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
3935 createTool( 702, meshTb );
3936 createTool( 703, meshTb );
3937 createTool( 704, meshTb );
3938 createTool( 710, meshTb );
3939 createTool( 705, meshTb );
3940 createTool( separator(), meshTb );
3941 createTool( 701, meshTb );
3942 createTool( 711, meshTb );
3943 createTool( 712, meshTb );
3944 createTool( 713, meshTb );
3945 createTool( separator(), meshTb );
3946 createTool( 801, meshTb );
3947 createTool( 806, meshTb );
3948 createTool( 802, meshTb );
3949 createTool( 803, meshTb );
3950 //createTool( 815, meshTb );
3951 createTool( separator(), meshTb );
3952 createTool( 900, meshTb );
3953 //createTool( 902, meshTb );
3954 //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3955 createTool( 904, meshTb );
3956 createTool( separator(), meshTb );
3958 createTool( 6005, ctrlTb );
3959 createTool( 6028, ctrlTb );
3960 createTool( separator(), ctrlTb );
3961 createTool( 6002, ctrlTb );
3962 createTool( 6003, ctrlTb );
3963 createTool( 6001, ctrlTb );
3964 createTool( 6004, ctrlTb );
3965 createTool( 6029, ctrlTb );
3966 createTool( separator(), ctrlTb );
3967 createTool( 6021, ctrlTb );
3968 createTool( 6025, ctrlTb );
3969 createTool( 6027, ctrlTb );
3970 createTool( 6018, ctrlTb );
3971 createTool( 6019, ctrlTb );
3972 createTool( 6011, ctrlTb );
3973 createTool( 6012, ctrlTb );
3974 createTool( 6013, ctrlTb );
3975 createTool( 6014, ctrlTb );
3976 createTool( 6015, ctrlTb );
3977 createTool( 6016, ctrlTb );
3978 createTool( 6022, ctrlTb );
3979 createTool( 6030, ctrlTb );
3980 createTool( separator(), ctrlTb );
3981 createTool( 6017, ctrlTb );
3982 createTool( 6009, ctrlTb );
3983 createTool( 6023, ctrlTb );
3984 createTool( 6024, ctrlTb );
3985 createTool( 6026, ctrlTb );
3986 createTool( 6031, ctrlTb );
3987 createTool( separator(), ctrlTb );
3989 createTool( 4000, addRemTb );
3990 createTool( 4009, addRemTb );
3991 createTool( 4070, addRemTb );
3992 createTool( 4008, addRemTb );
3993 createTool( 4010, addRemTb );
3994 createTool( 4021, addRemTb );
3995 createTool( 4022, addRemTb );
3996 createTool( 4023, addRemTb );
3997 createTool( 4031, addRemTb );
3998 createTool( 4032, addRemTb );
3999 createTool( 4133, addRemTb );
4000 createTool( 4134, addRemTb );
4001 createTool( 4135, addRemTb );
4002 createTool( 4033, addRemTb );
4003 createTool( separator(), addRemTb );
4004 createTool( 4034, addRemTb );
4005 createTool( 4035, addRemTb );
4006 createTool( 4137, addRemTb );
4007 createTool( 4036, addRemTb );
4008 createTool( 4136, addRemTb );
4009 createTool( 4037, addRemTb );
4010 createTool( 4038, addRemTb );
4011 createTool( 4039, addRemTb );
4012 createTool( 4040, addRemTb );
4013 createTool( 4140, addRemTb );
4014 createTool( separator(), addRemTb );
4015 createTool( 4041, addRemTb );
4016 createTool( 4042, addRemTb );
4017 createTool( 4044, addRemTb );
4018 createTool( 4043, addRemTb );
4019 createTool( separator(), addRemTb );
4020 createTool( 4051, addRemTb );
4021 createTool( 4052, addRemTb );
4022 createTool( separator(), addRemTb );
4023 createTool( 4061, addRemTb );
4024 createTool( 4062, addRemTb );
4025 createTool( 4063, addRemTb );
4026 createTool( 4068, addRemTb );
4027 createTool( 4064, addRemTb );
4028 createTool( 4065, addRemTb );
4029 createTool( 4066, addRemTb );
4030 createTool( 4069, addRemTb );
4031 createTool( separator(), addRemTb );
4033 createTool( 4067,modifyTb );
4034 createTool( 407, modifyTb );
4035 createTool( 408, modifyTb );
4036 createTool( 409, modifyTb );
4037 createTool( 420, modifyTb );
4038 createTool( 410, modifyTb );
4039 createTool( 411, modifyTb );
4040 createTool( 419, modifyTb );
4041 createTool( 412, modifyTb );
4042 createTool( 413, modifyTb );
4043 createTool( 416, modifyTb );
4044 createTool( 414, modifyTb );
4045 createTool( 415, modifyTb );
4046 createTool( 417, modifyTb );
4047 createTool( 418, modifyTb );
4049 createTool( 214, dispModeTb );
4051 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4052 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4055 QString OB = "'ObjectBrowser'",
4056 View = "'" + SVTK_Viewer::Type() + "'",
4058 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4059 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4060 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4061 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4062 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4063 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4064 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4065 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4066 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4067 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4068 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4070 mesh_part = mesh + " " + subMesh + " " + group,
4071 mesh_group = mesh + " " + group,
4072 hyp_alg = hypo + " " + algo;
4074 // popup for object browser
4076 isInvisible("not( isVisible )"),
4077 isEmpty("numberOfNodes = 0"),
4078 isNotEmpty("numberOfNodes <> 0"),
4080 // has nodes, edges, etc in VISIBLE! actor
4081 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4082 hasElems("(count( elemTypes ) > 0)"),
4083 hasDifferentElems("(count( elemTypes ) > 1)"),
4084 hasBalls("({'BallElem'} in elemTypes)"),
4085 hasElems0d("({'Elem0d'} in elemTypes)"),
4086 hasEdges("({'Edge'} in elemTypes)"),
4087 hasFaces("({'Face'} in elemTypes)"),
4088 hasVolumes("({'Volume'} in elemTypes)");
4090 createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
4091 createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
4092 createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
4093 createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
4094 createPopupItem( 803, OB, group ); // EDIT_GROUP
4095 createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
4097 popupMgr()->insert( separator(), -1, 0 );
4098 createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
4099 createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
4100 createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
4101 createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
4102 createPopupItem( 214, OB, mesh_part ); // UPDATE
4103 createPopupItem( 900, OB, mesh_part ); // ADV_INFO
4104 createPopupItem( 904, OB, mesh_group ); // FIND_ELEM
4105 createPopupItem( 6032, OB, mesh_part ); // CTRL_INFO
4106 popupMgr()->insert( separator(), -1, 0 );
4107 createPopupItem( 801, OB, mesh ); // CREATE_GROUP
4108 createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
4109 createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
4110 popupMgr()->insert( separator(), -1, 0 );
4111 createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
4112 createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4113 popupMgr()->insert( separator(), -1, 0 );
4114 createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
4115 popupMgr()->insert( separator(), -1, 0 );
4116 createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
4117 createPopupItem( 418, OB, mesh + " " + group, // create 2D mesh from 3D
4119 popupMgr()->insert( separator(), -1, 0 );
4121 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4122 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4123 QString only_one_2D = only_one_non_empty + " && dim>1";
4125 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4126 createPopupItem( 125, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_MED
4127 createPopupItem( 126, OB, mesh_group, only_one_non_empty, anId ); // EXPORT_UNV
4128 createPopupItem( 141, OB, mesh_group, only_one_2D, anId ); // EXPORT_STL
4130 createPopupItem( 143, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_CGNS
4132 createPopupItem( 145, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_SAUV
4133 createPopupItem( 147, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_GMF
4134 createPopupItem( 124, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_DAT
4135 createPopupItem( 33, OB, mesh_part + " " + hyp_alg ); // DELETE
4136 createPopupItem( 813, OB, group ); // DEL_GROUP with contents
4137 popupMgr()->insert( separator(), -1, 0 );
4140 createPopupItem( 803, View, group ); // EDIT_GROUP
4141 createPopupItem( 804, View, elems ); // ADD
4142 createPopupItem( 805, View, elems ); // REMOVE
4144 popupMgr()->insert( separator(), -1, 0 );
4145 createPopupItem( 214, View, mesh_part ); // UPDATE
4146 createPopupItem( 900, View, mesh_part ); // ADV_INFO
4147 createPopupItem( 904, View, mesh ); // FIND_ELEM
4148 popupMgr()->insert( separator(), -1, 0 );
4150 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
4151 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
4152 popupMgr()->insert( separator(), -1, 0 );
4154 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4155 QString aType = QString( "%1type in {%2}" ).arg( lc );
4156 aType = aType.arg( mesh_part );
4157 QString aMeshInVTK = aClient + "&&" + aType;
4159 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4160 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4161 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4163 //-------------------------------------------------
4165 //-------------------------------------------------
4166 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4168 popupMgr()->insert( action( 9010 ), anId, -1 );
4169 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4170 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4172 popupMgr()->insert( action( 9011 ), anId, -1 );
4173 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4174 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4176 popupMgr()->insert( separator(), -1, -1 );
4178 //-------------------------------------------------
4180 //-------------------------------------------------
4181 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4183 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4184 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4185 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4187 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4188 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4189 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4191 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4192 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4193 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4195 popupMgr()->insert( separator(), anId, -1 );
4197 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4198 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4199 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4201 //-------------------------------------------------
4203 //-------------------------------------------------
4204 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4206 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4208 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4209 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4210 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4212 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4213 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4214 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4216 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4217 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4218 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4220 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4221 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4222 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4224 popupMgr()->insert( action( 222 ), anId, -1 ); // BALLS
4225 popupMgr()->setRule( action( 222 ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4226 popupMgr()->setRule( action( 222 ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4228 popupMgr()->insert( separator(), anId, -1 );
4230 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4231 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4234 //-------------------------------------------------
4235 // Representation of the 2D Quadratic elements
4236 //-------------------------------------------------
4237 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4238 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4239 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4240 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4242 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4243 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4244 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4246 //-------------------------------------------------
4247 // Orientation of faces
4248 //-------------------------------------------------
4249 popupMgr()->insert( action( 221 ), -1, -1 );
4250 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4251 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4253 //-------------------------------------------------
4255 //-------------------------------------------------
4256 popupMgr()->insert( action( 1132 ), -1, -1 );
4257 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4259 //-------------------------------------------------
4261 //-------------------------------------------------
4262 popupMgr()->insert( action( 1133 ), -1, -1 );
4263 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4265 //-------------------------------------------------
4267 //-------------------------------------------------
4269 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4270 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4271 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4272 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4274 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4276 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4277 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4279 popupMgr()->insert( separator(), anId, -1 );
4281 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4283 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4284 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4285 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4287 popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4288 popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4289 popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4291 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4293 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4294 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4295 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4297 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4298 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4299 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4301 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4302 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4303 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4305 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4306 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4307 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4308 popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4309 popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4310 popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4312 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4314 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4315 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4316 QtxPopupMgr::VisibleRule );
4317 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4319 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4320 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4321 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4323 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4324 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4325 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4327 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4328 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4329 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4331 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4332 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4333 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4335 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4336 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4337 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4339 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4340 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4341 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4343 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4344 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4345 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4347 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4348 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4349 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4351 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4352 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4353 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4355 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4356 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4357 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4359 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4360 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4361 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4362 popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4363 popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4364 popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4366 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4368 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4369 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4370 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4372 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4373 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4374 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4376 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4377 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4378 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4380 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4381 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4382 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4384 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4385 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4386 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4388 popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4389 popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4390 popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4392 popupMgr()->insert( separator(), anId, -1 );
4394 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4395 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4397 popupMgr()->insert( separator(), anId, -1 );
4399 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4401 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4402 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4404 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4405 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4406 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4408 #ifndef DISABLE_PLOT2DVIEWER
4409 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4410 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4413 //-------------------------------------------------
4415 //-------------------------------------------------
4416 popupMgr()->insert( separator(), -1, -1 );
4417 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4418 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4419 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4420 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4422 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4423 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4425 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4426 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4428 popupMgr()->insert( separator(), -1, -1 );
4430 //-------------------------------------------------
4432 //-------------------------------------------------
4433 popupMgr()->insert( action( 1134 ), -1, -1 );
4434 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4436 popupMgr()->insert( separator(), -1, -1 );
4438 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4439 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4441 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4442 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4445 //================================================================================
4447 * \brief Return true if SMESH or GEOM objects are selected.
4448 * Is called form LightApp_Module::activateModule() which clear selection if
4449 * not isSelectionCompatible()
4451 //================================================================================
4453 bool SMESHGUI::isSelectionCompatible()
4455 bool isCompatible = true;
4456 SALOME_ListIO selected;
4457 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4458 Sel->selectedObjects( selected );
4460 SALOME_ListIteratorOfListIO It( selected );
4461 for ( ; isCompatible && It.More(); It.Next())
4463 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4464 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4466 return isCompatible;
4470 bool SMESHGUI::reusableOperation( const int id )
4472 // compute, evaluate and precompute are not reusable operations
4473 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4476 bool SMESHGUI::activateModule( SUIT_Study* study )
4478 bool res = SalomeApp_Module::activateModule( study );
4480 setMenuShown( true );
4481 setToolShown( true );
4483 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4484 PyGILState_STATE gstate = PyGILState_Ensure();
4485 PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4486 if(pluginsmanager==NULL)
4490 PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4495 PyGILState_Release(gstate);
4496 // end of GEOM plugins loading
4498 // Reset actions accelerator keys
4499 //action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4500 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4501 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4503 action( 33)->setEnabled(true); // Delete: Key_Delete
4505 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4506 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4507 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4508 if ( _PTR(Study) aStudy = s->studyDS()) {
4509 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4510 updateObjBrowser(); // objects can be removed
4513 // get all view currently opened in the study and connect their signals to
4514 // the corresponding slots of the class.
4515 SUIT_Desktop* aDesk = study->application()->desktop();
4517 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4518 SUIT_ViewWindow* wnd;
4519 foreach ( wnd, wndList )
4526 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4528 setMenuShown( false );
4529 setToolShown( false );
4531 EmitSignalCloseAllDialogs();
4533 // Unset actions accelerator keys
4534 //action(111)->setShortcut(QKeySequence()); // Import DAT
4535 action(112)->setShortcut(QKeySequence()); // Import UNV
4536 action(113)->setShortcut(QKeySequence()); // Import MED
4538 action( 33)->setEnabled(false); // Delete: Key_Delete
4540 return SalomeApp_Module::deactivateModule( study );
4543 void SMESHGUI::studyClosed( SUIT_Study* s )
4545 SMESH::RemoveVisuData( s->id() );
4546 SalomeApp_Module::studyClosed( s );
4549 void SMESHGUI::OnGUIEvent()
4551 const QObject* obj = sender();
4552 if ( !obj || !obj->inherits( "QAction" ) )
4554 int id = actionId((QAction*)obj);
4559 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4561 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4562 if ( CORBA::is_nil( myComponentSMESH ) )
4564 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4566 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4567 return aGUI.myComponentSMESH;
4570 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4571 return myComponentSMESH;
4574 QString SMESHGUI::engineIOR() const
4576 CORBA::ORB_var anORB = getApp()->orb();
4577 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4578 return QString( anIOR.in() );
4581 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4583 SalomeApp_Module::contextMenuPopup( client, menu, title );
4585 selectionMgr()->selectedObjects( lst );
4586 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4587 Handle(SALOME_InteractiveObject) io = lst.First();
4588 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4589 _PTR(Study) study = appStudy->studyDS();
4590 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4592 QString aName = QString( obj->GetName().c_str() );
4593 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4594 aName.remove( (aName.length() - 1), 1 );
4600 LightApp_Selection* SMESHGUI::createSelection() const
4602 return new SMESHGUI_Selection();
4605 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4607 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4608 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4611 void SMESHGUI::viewManagers( QStringList& list ) const
4613 list.append( SVTK_Viewer::Type() );
4616 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4618 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4619 SMESH::UpdateSelectionProp( this );
4621 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4622 for(int i = 0; i < aViews.count() ; i++){
4623 SUIT_ViewWindow *sf = aViews[i];
4629 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4631 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4632 myClippingPlaneInfoMap.erase( theViewManager );
4635 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4637 theActor->AddObserver( SMESH::DeleteActorEvent,
4638 myEventCallbackCommand.GetPointer(),
4642 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4643 unsigned long theEvent,
4644 void* theClientData,
4647 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4648 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4649 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4650 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4651 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4652 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4653 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4654 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4655 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4656 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4657 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4658 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4659 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4660 if( anActor == *anIter3 ) {
4661 anActorList.erase( anIter3 );
4672 void SMESHGUI::createPreferences()
4674 // General tab ------------------------------------------------------------------------
4675 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4677 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4678 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4679 setPreferenceProperty( lim, "min", 0 );
4680 setPreferenceProperty( lim, "max", 100000000 );
4681 setPreferenceProperty( lim, "step", 1000 );
4682 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4684 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4685 setPreferenceProperty( qaGroup, "columns", 2 );
4686 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4687 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4688 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4689 setPreferenceProperty( prec, "min", 0 );
4690 setPreferenceProperty( prec, "max", 16 );
4691 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4692 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4693 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4694 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4695 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4697 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4698 setPreferenceProperty( dispgroup, "columns", 2 );
4699 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4701 modes.append( tr("MEN_WIRE") );
4702 modes.append( tr("MEN_SHADE") );
4703 modes.append( tr("MEN_NODES") );
4704 modes.append( tr("MEN_SHRINK") );
4705 QList<QVariant> indices;
4706 indices.append( 0 );
4707 indices.append( 1 );
4708 indices.append( 2 );
4709 indices.append( 3 );
4710 setPreferenceProperty( dispmode, "strings", modes );
4711 setPreferenceProperty( dispmode, "indexes", indices );
4713 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4714 setPreferenceProperty( arcgroup, "columns", 2 );
4715 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4716 QStringList quadraticModes;
4717 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4718 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4720 indices.append( 0 );
4721 indices.append( 1 );
4722 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4723 setPreferenceProperty( quadraticmode, "indexes", indices );
4725 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4726 "SMESH", "max_angle" );
4727 setPreferenceProperty( maxAngle, "min", 1 );
4728 setPreferenceProperty( maxAngle, "max", 90 );
4732 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4733 setPreferenceProperty( exportgroup, "columns", 2 );
4734 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4735 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4737 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4738 setPreferenceProperty( computeGroup, "columns", 2 );
4739 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4741 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4742 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4743 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4745 indices.append( 0 );
4746 indices.append( 1 );
4747 indices.append( 2 );
4748 setPreferenceProperty( notifyMode, "strings", modes );
4749 setPreferenceProperty( notifyMode, "indexes", indices );
4751 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4752 setPreferenceProperty( infoGroup, "columns", 2 );
4753 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4755 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4756 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4758 indices.append( 0 );
4759 indices.append( 1 );
4760 setPreferenceProperty( elemInfo, "strings", modes );
4761 setPreferenceProperty( elemInfo, "indexes", indices );
4762 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4763 setPreferenceProperty( nodesLim, "min", 0 );
4764 setPreferenceProperty( nodesLim, "max", 10000000 );
4765 setPreferenceProperty( nodesLim, "step", 10000 );
4766 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4767 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
4768 setPreferenceProperty( ctrlLim, "min", 0 );
4769 setPreferenceProperty( ctrlLim, "max", 10000000 );
4770 setPreferenceProperty( ctrlLim, "step", 1000 );
4771 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
4772 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
4773 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
4774 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
4775 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
4777 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4778 setPreferenceProperty( segGroup, "columns", 2 );
4779 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4780 "SMESH", "segmentation" );
4781 setPreferenceProperty( segLen, "min", 1 );
4782 setPreferenceProperty( segLen, "max", 10000000 );
4783 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4784 "SMESH", "nb_segments_per_edge" );
4785 setPreferenceProperty( nbSeg, "min", 1 );
4786 setPreferenceProperty( nbSeg, "max", 10000000 );
4788 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4789 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4790 "SMESH", "forget_mesh_on_hyp_modif" );
4793 // Quantities with individual precision settings
4794 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4795 setPreferenceProperty( precGroup, "columns", 2 );
4797 const int nbQuantities = 6;
4798 int precs[nbQuantities], ii = 0;
4799 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4800 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4801 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4802 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4803 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4804 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4805 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4806 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4807 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4808 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4809 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4810 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4812 // Set property for precision value for spinboxes
4813 for ( ii = 0; ii < nbQuantities; ii++ ){
4814 setPreferenceProperty( precs[ii], "min", -14 );
4815 setPreferenceProperty( precs[ii], "max", 14 );
4816 setPreferenceProperty( precs[ii], "precision", 2 );
4819 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4820 setPreferenceProperty( previewGroup, "columns", 2 );
4821 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4822 setPreferenceProperty( chunkSize, "min", 1 );
4823 setPreferenceProperty( chunkSize, "max", 1000 );
4824 setPreferenceProperty( chunkSize, "step", 50 );
4826 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4827 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4829 // Mesh tab ------------------------------------------------------------------------
4830 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4831 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4832 setPreferenceProperty( nodeGroup, "columns", 3 );
4834 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4836 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4838 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4839 QList<QVariant> aMarkerTypeIndicesList;
4840 QList<QVariant> aMarkerTypeIconsList;
4841 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4842 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4843 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4844 aMarkerTypeIndicesList << i;
4845 aMarkerTypeIconsList << pixmap;
4847 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4848 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4850 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4852 QList<QVariant> aMarkerScaleIndicesList;
4853 QStringList aMarkerScaleValuesList;
4854 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4855 aMarkerScaleIndicesList << i;
4856 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4858 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4859 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4861 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4862 //setPreferenceProperty( elemGroup, "columns", 2 );
4864 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4865 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4866 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
4867 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
4868 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4869 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
4870 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4871 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4874 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4875 setPreferenceProperty( grpGroup, "columns", 2 );
4877 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4878 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
4880 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4881 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4882 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
4883 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
4884 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4885 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4886 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
4887 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
4888 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4889 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4891 setPreferenceProperty( size0d, "min", 1 );
4892 setPreferenceProperty( size0d, "max", 10 );
4894 setPreferenceProperty( ballSize, "min", 1 );
4895 setPreferenceProperty( ballSize, "max", 10 );
4897 setPreferenceProperty( elemW, "min", 1 );
4898 setPreferenceProperty( elemW, "max", 5 );
4900 setPreferenceProperty( outW, "min", 1 );
4901 setPreferenceProperty( outW, "max", 5 );
4903 setPreferenceProperty( shrink, "min", 0 );
4904 setPreferenceProperty( shrink, "max", 100 );
4906 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
4907 setPreferenceProperty( numGroup, "columns", 2 );
4909 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
4910 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
4912 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
4913 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
4915 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4916 setPreferenceProperty( orientGroup, "columns", 1 );
4918 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4919 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4921 setPreferenceProperty( orientScale, "min", 0.05 );
4922 setPreferenceProperty( orientScale, "max", 0.5 );
4923 setPreferenceProperty( orientScale, "step", 0.05 );
4925 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4927 // Selection tab ------------------------------------------------------------------------
4928 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4930 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4931 setPreferenceProperty( selGroup, "columns", 2 );
4933 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4934 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4936 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4937 setPreferenceProperty( preGroup, "columns", 2 );
4939 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4941 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4942 setPreferenceProperty( precSelGroup, "columns", 2 );
4944 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4945 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4946 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4948 // Scalar Bar tab ------------------------------------------------------------------------
4949 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4950 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4951 setPreferenceProperty( fontGr, "columns", 2 );
4953 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4954 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4956 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4957 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4959 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4960 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4962 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4963 setPreferenceProperty( numcol, "min", 2 );
4964 setPreferenceProperty( numcol, "max", 256 );
4966 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4967 setPreferenceProperty( numlab, "min", 2 );
4968 setPreferenceProperty( numlab, "max", 65 );
4970 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4971 setPreferenceProperty( orientGr, "columns", 2 );
4972 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4973 QStringList orients;
4974 orients.append( tr( "SMESH_VERTICAL" ) );
4975 orients.append( tr( "SMESH_HORIZONTAL" ) );
4976 indices.clear(); indices.append( 0 ); indices.append( 1 );
4977 setPreferenceProperty( orient, "strings", orients );
4978 setPreferenceProperty( orient, "indexes", indices );
4980 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4981 setPreferenceProperty( posVSizeGr, "columns", 2 );
4982 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4983 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4984 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4985 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4986 setPreferenceProperty( xv, "step", 0.1 );
4987 setPreferenceProperty( xv, "min", 0.0 );
4988 setPreferenceProperty( xv, "max", 1.0 );
4989 setPreferenceProperty( yv, "step", 0.1 );
4990 setPreferenceProperty( yv, "min", 0.0 );
4991 setPreferenceProperty( yv, "max", 1.0 );
4992 setPreferenceProperty( wv, "step", 0.1 );
4993 setPreferenceProperty( wv, "min", 0.0 );
4994 setPreferenceProperty( wv, "max", 1.0 );
4995 setPreferenceProperty( hv, "min", 0.0 );
4996 setPreferenceProperty( hv, "max", 1.0 );
4997 setPreferenceProperty( hv, "step", 0.1 );
4999 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5000 setPreferenceProperty( posHSizeGr, "columns", 2 );
5001 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5002 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5003 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5004 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5005 setPreferenceProperty( xv, "min", 0.0 );
5006 setPreferenceProperty( xv, "max", 1.0 );
5007 setPreferenceProperty( xv, "step", 0.1 );
5008 setPreferenceProperty( xh, "min", 0.0 );
5009 setPreferenceProperty( xh, "max", 1.0 );
5010 setPreferenceProperty( xh, "step", 0.1 );
5011 setPreferenceProperty( yh, "min", 0.0 );
5012 setPreferenceProperty( yh, "max", 1.0 );
5013 setPreferenceProperty( yh, "step", 0.1 );
5014 setPreferenceProperty( wh, "min", 0.0 );
5015 setPreferenceProperty( wh, "max", 1.0 );
5016 setPreferenceProperty( wh, "step", 0.1 );
5017 setPreferenceProperty( hh, "min", 0.0 );
5018 setPreferenceProperty( hh, "max", 1.0 );
5019 setPreferenceProperty( hh, "step", 0.1 );
5021 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5022 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5023 setPreferenceProperty( distributionGr, "columns", 3 );
5025 types.append( tr( "SMESH_MONOCOLOR" ) );
5026 types.append( tr( "SMESH_MULTICOLOR" ) );
5027 indices.clear(); indices.append( 0 ); indices.append( 1 );
5028 setPreferenceProperty( coloringType, "strings", types );
5029 setPreferenceProperty( coloringType, "indexes", indices );
5030 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5034 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5036 if( sect=="SMESH" ) {
5037 float sbX1,sbY1,sbW,sbH;
5038 float aTol = 1.00000009999999;
5039 std::string aWarning;
5040 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5041 if( name=="selection_object_color" || name=="selection_element_color" ||
5042 name=="highlight_color" ||
5043 name=="selection_precision_node" || name=="selection_precision_element" ||
5044 name=="selection_precision_object")
5045 SMESH::UpdateSelectionProp( this );
5046 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5047 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5048 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5049 if(sbX1+sbW > aTol){
5050 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5053 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5054 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5057 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5058 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5059 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5060 if(sbY1+sbH > aTol){
5061 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5062 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5063 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5066 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5067 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5068 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5069 if(sbX1+sbW > aTol){
5070 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5073 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5074 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5077 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5078 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5079 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5080 if(sbY1+sbH > aTol){
5081 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5084 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5085 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5088 else if ( name == "segmentation" ) {
5089 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5090 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5092 else if ( name == "nb_segments_per_edge" ) {
5093 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5094 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5096 else if ( name == "historical_python_dump" ||
5097 name == "forget_mesh_on_hyp_modif") {
5098 QString val = aResourceMgr->stringValue( "SMESH", name );
5099 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5101 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5102 SMESH::UpdateFontProp( this );
5104 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5105 SMESH::UpdateFontProp( this );
5108 if(aWarning.size() != 0){
5109 aWarning += "The default values are applied instead.";
5110 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5111 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5112 QObject::tr(aWarning.c_str()));
5117 //================================================================================
5119 * \brief Update something in accordance with update flags
5120 * \param theFlags - update flags
5122 * Update viewer or/and object browser etc. in accordance with update flags ( see
5123 * LightApp_UpdateFlags enumeration ).
5125 //================================================================================
5126 void SMESHGUI::update( const int flags )
5128 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5129 SMESH::UpdateView();
5131 SalomeApp_Module::update( flags );
5134 //================================================================================
5136 * \brief Set default selection mode
5138 * SLOT called when operation commited. Sets default selection mode
5140 //================================================================================
5141 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5143 SVTK_ViewWindow* vtkWnd =
5144 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5146 vtkWnd->SetSelectionMode( ActorSelection );
5149 //================================================================================
5151 * \brief Set default selection mode
5153 * SLOT called when operation aborted. Sets default selection mode
5155 //================================================================================
5156 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5158 SVTK_ViewWindow* vtkWnd =
5159 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5161 vtkWnd->SetSelectionMode( ActorSelection );
5164 //================================================================================
5166 * \brief Creates operation with given identifier
5167 * \param id - identifier of operation to be started
5168 * \return Pointer on created operation or NULL if operation is not created
5170 * Virtual method redefined from the base class creates operation with given id.
5171 * It is called called automatically from startOperation method of base class.
5173 //================================================================================
5174 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5176 LightApp_Operation* op = 0;
5177 // to do : create operation here
5180 case 417: //convert to quadratic
5181 op = new SMESHGUI_ConvToQuadOp();
5183 case 418: // create 2D mesh as boundary on 3D
5184 op = new SMESHGUI_Make2DFrom3DOp();
5186 case 420: // Reorient faces
5187 op = new SMESHGUI_ReorientFacesOp();
5189 case 701: // Compute mesh
5190 op = new SMESHGUI_ComputeOp();
5192 case 702: // Create mesh
5193 op = new SMESHGUI_MeshOp( true, true );
5195 case 703: // Create sub-mesh
5196 op = new SMESHGUI_MeshOp( true, false );
5198 case 704: // Edit mesh/sub-mesh
5199 op = new SMESHGUI_MeshOp( false );
5201 case 711: // Precompute mesh
5202 op = new SMESHGUI_PrecomputeOp();
5204 case 712: // Evaluate mesh
5205 op = new SMESHGUI_EvaluateOp();
5207 case 713: // Evaluate mesh
5208 op = new SMESHGUI_MeshOrderOp();
5210 case 806: // Create group on geom
5211 op = new SMESHGUI_GroupOnShapeOp();
5213 case 904: // Find element
5214 op = new SMESHGUI_FindElemByPointOp();
5216 case 4067: // Make mesh pass through point
5217 op = new SMESHGUI_MakeNodeAtPointOp();
5219 case 4070: // Create 0D elements on all nodes
5220 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5227 op = SalomeApp_Module::createOperation( id );
5231 //================================================================================
5233 * \brief Stops current operations and starts a given one
5234 * \param id - The id of the operation to start
5236 //================================================================================
5238 void SMESHGUI::switchToOperation(int id)
5240 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5241 activeStudy()->abortAllOperations();
5242 startOperation( id );
5245 LightApp_Displayer* SMESHGUI::displayer()
5248 myDisplayer = new SMESHGUI_Displayer( getApp() );
5252 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5255 int aTolerance = 64;
5256 int anIterations = 0;
5262 if( anIterations % aPeriod == 0 )
5265 if( aTolerance < 1 )
5269 aHue = (int)( 360.0 * rand() / RAND_MAX );
5272 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5273 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5274 for( ; it != itEnd; ++it )
5276 SALOMEDS::Color anAutoColor = *it;
5277 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5280 aQColor.getHsv( &h, &s, &v );
5281 if( abs( h - aHue ) < aTolerance )
5293 aColor.setHsv( aHue, 255, 255 );
5295 SALOMEDS::Color aSColor;
5296 aSColor.R = aColor.redF();
5297 aSColor.G = aColor.greenF();
5298 aSColor.B = aColor.blueF();
5303 const char* gSeparator = "_"; // character used to separate parameter names
5304 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5305 const char* gPathSep = "|"; // character used to separate paths
5308 * \brief Store visual parameters
5310 * This method is called just before the study document is saved.
5311 * Store visual parameters in AttributeParameter attribue(s)
5313 void SMESHGUI::storeVisualParameters (int savePoint)
5316 Kernel_Utils::Localizer loc;
5318 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5319 if (!appStudy || !appStudy->studyDS())
5321 _PTR(Study) studyDS = appStudy->studyDS();
5323 // componentName is used for encoding of entries when storing them in IParameters
5324 std::string componentName = myComponentSMESH->ComponentDataType();
5325 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5326 //if (!aSComponent) return;
5329 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5330 componentName.c_str(),
5332 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5334 // store map of custom markers
5335 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5336 if( !aMarkerMap.empty() )
5338 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5339 for( ; anIter != aMarkerMap.end(); anIter++ )
5341 int anId = anIter->first;
5342 VTK::MarkerData aMarkerData = anIter->second;
5343 std::string aMarkerFileName = aMarkerData.first;
5344 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5345 if( aMarkerTexture.size() < 3 )
5346 continue; // should contain at least width, height and the first value
5348 QString aPropertyName( "texture" );
5349 aPropertyName += gSeparator;
5350 aPropertyName += QString::number( anId );
5352 QString aPropertyValue = aMarkerFileName.c_str();
5353 aPropertyValue += gPathSep;
5355 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5356 ushort aWidth = *aTextureIter++;
5357 ushort aHeight = *aTextureIter++;
5358 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5359 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5360 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5361 aPropertyValue += QString::number( *aTextureIter );
5363 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5367 // viewers counters are used for storing view_numbers in IParameters
5370 // main cycle to store parameters of displayed objects
5371 QList<SUIT_ViewManager*> lst;
5372 QList<SUIT_ViewManager*>::Iterator it;
5373 getApp()->viewManagers(lst);
5374 for (it = lst.begin(); it != lst.end(); it++)
5376 SUIT_ViewManager* vman = *it;
5377 QString vType = vman->getType();
5379 // saving VTK actors properties
5380 if (vType == SVTK_Viewer::Type())
5382 // store the clipping planes attached to the view manager
5383 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5384 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5385 if( anIter != myClippingPlaneInfoMap.end() )
5386 aClippingPlaneInfoList = anIter->second;
5388 if( !aClippingPlaneInfoList.empty() ) {
5389 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5390 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5392 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5393 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5395 QString aPropertyName( "ClippingPlane" );
5396 aPropertyName += gSeparator;
5397 aPropertyName += QString::number( vtkViewers );
5398 aPropertyName += gSeparator;
5399 aPropertyName += QString::number( anId );
5401 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5402 aPropertyValue += gDigitsSep;
5403 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5404 aPropertyValue += gDigitsSep;
5405 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5406 aPropertyValue += gDigitsSep;
5407 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5409 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5413 QVector<SUIT_ViewWindow*> views = vman->getViews();
5414 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5416 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5418 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5419 vtkActorCollection* allActors = aCopy.GetActors();
5420 allActors->InitTraversal();
5421 while (vtkActor* actor = allActors->GetNextActor())
5423 if (actor->GetVisibility()) // store only visible actors
5425 SMESH_Actor* aSmeshActor = 0;
5426 if (actor->IsA("SMESH_Actor"))
5427 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5428 if (aSmeshActor && aSmeshActor->hasIO())
5430 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5433 // entry is "encoded" = it does NOT contain component adress,
5434 // since it is a subject to change on next component loading
5435 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5437 std::string param, vtkParam = vType.toLatin1().data();
5438 vtkParam += gSeparator;
5439 vtkParam += QString::number(vtkViewers).toLatin1().data();
5440 vtkParam += gSeparator;
5443 param = vtkParam + "Visibility";
5444 ip->setParameter(entry, param, "On");
5447 param = vtkParam + "Representation";
5448 ip->setParameter(entry, param, QString::number
5449 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5452 param = vtkParam + "IsShrunk";
5453 ip->setParameter(entry, param, QString::number
5454 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5456 // Displayed entities
5457 unsigned int aMode = aSmeshActor->GetEntityMode();
5458 bool isE = aMode & SMESH_Actor::eEdges;
5459 bool isF = aMode & SMESH_Actor::eFaces;
5460 bool isV = aMode & SMESH_Actor::eVolumes;
5461 bool is0d = aMode & SMESH_Actor::e0DElements;
5462 bool isB = aMode & SMESH_Actor::eBallElem;
5464 QString modeStr ("e");
5465 modeStr += gDigitsSep; modeStr += QString::number(isE);
5466 modeStr += gDigitsSep; modeStr += "f";
5467 modeStr += gDigitsSep; modeStr += QString::number(isF);
5468 modeStr += gDigitsSep; modeStr += "v";
5469 modeStr += gDigitsSep; modeStr += QString::number(isV);
5470 modeStr += gDigitsSep; modeStr += "0d";
5471 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5472 modeStr += gDigitsSep; modeStr += "b";
5473 modeStr += gDigitsSep; modeStr += QString::number(isB);
5475 param = vtkParam + "Entities";
5476 ip->setParameter(entry, param, modeStr.toLatin1().data());
5482 aSmeshActor->GetSufaceColor(r, g, b, delta);
5483 QStringList colorStr;
5484 colorStr << "surface";
5485 colorStr << QString::number(r);
5486 colorStr << QString::number(g);
5487 colorStr << QString::number(b);
5489 colorStr << "backsurface";
5490 colorStr << QString::number(delta);
5492 aSmeshActor->GetVolumeColor(r, g, b, delta);
5493 colorStr << "volume";
5494 colorStr << QString::number(r);
5495 colorStr << QString::number(g);
5496 colorStr << QString::number(b);
5497 colorStr << QString::number(delta);
5499 aSmeshActor->GetEdgeColor(r, g, b);
5501 colorStr << QString::number(r);
5502 colorStr << QString::number(g);
5503 colorStr << QString::number(b);
5505 aSmeshActor->GetNodeColor(r, g, b);
5507 colorStr << QString::number(r);
5508 colorStr << QString::number(g);
5509 colorStr << QString::number(b);
5511 aSmeshActor->GetOutlineColor(r, g, b);
5512 colorStr << "outline";
5513 colorStr << QString::number(r);
5514 colorStr << QString::number(g);
5515 colorStr << QString::number(b);
5517 aSmeshActor->Get0DColor(r, g, b);
5518 colorStr << "elem0d";
5519 colorStr << QString::number(r);
5520 colorStr << QString::number(g);
5521 colorStr << QString::number(b);
5523 aSmeshActor->GetBallColor(r, g, b);
5525 colorStr << QString::number(r);
5526 colorStr << QString::number(g);
5527 colorStr << QString::number(b);
5529 aSmeshActor->GetFacesOrientationColor(r, g, b);
5530 colorStr << "orientation";
5531 colorStr << QString::number(r);
5532 colorStr << QString::number(g);
5533 colorStr << QString::number(b);
5535 param = vtkParam + "Colors";
5536 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5539 QStringList sizeStr;
5541 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5542 sizeStr << "outline";
5543 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5544 sizeStr << "elem0d";
5545 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5547 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5548 sizeStr << "shrink";
5549 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5550 sizeStr << "orientation";
5551 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5552 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5554 param = vtkParam + "Sizes";
5555 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5560 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5561 if( aMarkerType == VTK::MT_USER ) {
5562 markerStr += "custom";
5563 markerStr += gDigitsSep;
5564 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5568 markerStr += gDigitsSep;
5569 markerStr += QString::number( (int)aMarkerType );
5570 markerStr += gDigitsSep;
5571 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5574 param = vtkParam + "PointMarker";
5575 ip->setParameter(entry, param, markerStr.toLatin1().data());
5578 param = vtkParam + "Opacity";
5579 ip->setParameter(entry, param,
5580 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5583 param = vtkParam + "ClippingPlane";
5585 if( !aClippingPlaneInfoList.empty() ) {
5586 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5587 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5589 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5590 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5591 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5592 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5593 if( aSmeshActor == *anIter2 ) {
5594 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5595 QString::number( anId ).toLatin1().constData() );
5602 ip->setParameter( entry, param, "Off" );
5603 } // if (io->hasEntry())
5604 } // SMESH_Actor && hasIO
5606 } // while.. actors traversal
5610 } // if (SVTK view model)
5611 } // for (viewManagers)
5614 // data structures for clipping planes processing
5617 vtkIdType Orientation;
5621 typedef std::list<TPlaneData> TPlaneDataList;
5622 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5624 typedef std::list<vtkActor*> TActorList;
5627 TActorList ActorList;
5628 SUIT_ViewManager* ViewManager;
5630 typedef std::list<TPlaneInfo> TPlaneInfoList;
5631 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5634 * \brief Restore visual parameters
5636 * This method is called after the study document is opened.
5637 * Restore visual parameters from AttributeParameter attribue(s)
5639 void SMESHGUI::restoreVisualParameters (int savePoint)
5642 Kernel_Utils::Localizer loc;
5644 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5645 if (!appStudy || !appStudy->studyDS())
5647 _PTR(Study) studyDS = appStudy->studyDS();
5649 // componentName is used for encoding of entries when storing them in IParameters
5650 std::string componentName = myComponentSMESH->ComponentDataType();
5651 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5652 //if (!aSComponent) return;
5655 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5656 componentName.c_str(),
5658 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5660 // restore map of custom markers and map of clipping planes
5661 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5662 TPlaneDataMap aPlaneDataMap;
5664 std::vector<std::string> properties = ip->getProperties();
5665 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5667 std::string property = *propIt;
5668 QString aPropertyName( property.c_str() );
5669 QString aPropertyValue( ip->getProperty( property ).c_str() );
5671 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5672 if( aPropertyNameList.isEmpty() )
5675 QString aPropertyType = aPropertyNameList[0];
5676 if( aPropertyType == "texture" )
5678 if( aPropertyNameList.size() != 2 )
5682 int anId = aPropertyNameList[1].toInt( &ok );
5683 if( !ok || anId < 1 )
5686 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5687 if( aPropertyValueList.size() != 2 )
5690 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5691 QString aMarkerTextureString = aPropertyValueList[1];
5692 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5693 if( aMarkerTextureStringList.size() != 3 )
5697 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5702 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5706 VTK::MarkerTexture aMarkerTexture;
5707 aMarkerTexture.push_back( aWidth );
5708 aMarkerTexture.push_back( aHeight );
5710 QString aMarkerTextureData = aMarkerTextureStringList[2];
5711 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5713 QChar aChar = aMarkerTextureData.at( i );
5714 if( aChar.isDigit() )
5715 aMarkerTexture.push_back( aChar.digitValue() );
5718 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5720 else if( aPropertyType == "ClippingPlane" )
5722 if( aPropertyNameList.size() != 3 )
5726 int aViewId = aPropertyNameList[1].toInt( &ok );
5727 if( !ok || aViewId < 0 )
5731 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5732 if( !ok || aClippingPlaneId < 0 )
5735 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5736 if( aPropertyValueList.size() != 4 )
5739 TPlaneData aPlaneData;
5740 aPlaneData.Id = aClippingPlaneId;
5743 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5748 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5753 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5758 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5762 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5763 aPlaneDataList.push_back( aPlaneData );
5767 TPlaneInfoMap aPlaneInfoMap;
5769 std::vector<std::string> entries = ip->getEntries();
5771 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5773 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5774 QString entry (ip->decodeEntry(*entIt).c_str());
5776 // Check that the entry corresponds to a real object in the Study
5777 // as the object may be deleted or modified after the visual state is saved.
5778 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5779 if (!so) continue; //Skip the not existent entry
5781 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5782 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5784 std::vector<std::string>::iterator namesIt = paramNames.begin();
5785 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5787 // actors are stored in a map after displaying of them for
5788 // quicker access in the future: map < viewID to actor >
5789 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5791 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5793 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5794 // '_' is used as separator and should not be used in viewer type or parameter names.
5795 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5796 if (lst.size() != 3)
5799 QString viewerTypStr = lst[0];
5800 QString viewIndexStr = lst[1];
5801 QString paramNameStr = lst[2];
5804 int viewIndex = viewIndexStr.toUInt(&ok);
5805 if (!ok) // bad conversion of view index to integer
5809 if (viewerTypStr == SVTK_Viewer::Type())
5811 SMESH_Actor* aSmeshActor = 0;
5812 if (vtkActors.IsBound(viewIndex))
5813 aSmeshActor = vtkActors.Find(viewIndex);
5815 QList<SUIT_ViewManager*> lst;
5816 getApp()->viewManagers(viewerTypStr, lst);
5818 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5819 SUIT_ViewManager* vman = NULL;
5820 if (viewIndex >= 0 && viewIndex < lst.count())
5821 vman = lst.at(viewIndex);
5823 if (paramNameStr == "Visibility")
5825 if (!aSmeshActor && displayer() && vman)
5827 SUIT_ViewModel* vmodel = vman->getViewModel();
5828 // SVTK view model can be casted to SALOME_View
5829 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5831 // store displayed actor in a temporary map for quicker
5832 // access later when restoring other parameters
5833 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5834 vtkRenderer* Renderer = vtkView->getRenderer();
5835 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5836 vtkActorCollection* theActors = aCopy.GetActors();
5837 theActors->InitTraversal();
5838 bool isFound = false;
5839 vtkActor *ac = theActors->GetNextActor();
5840 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5841 if (ac->IsA("SMESH_Actor")) {
5842 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5843 if (aGeomAc->hasIO()) {
5844 Handle(SALOME_InteractiveObject) io =
5845 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5846 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5848 vtkActors.Bind(viewIndex, aGeomAc);
5854 } // if (paramNameStr == "Visibility")
5857 // the rest properties "work" with SMESH_Actor
5860 QString val ((*valuesIt).c_str());
5863 if (paramNameStr == "Representation") {
5864 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5867 else if (paramNameStr == "IsShrunk") {
5869 if (!aSmeshActor->IsShrunk())
5870 aSmeshActor->SetShrink();
5873 if (aSmeshActor->IsShrunk())
5874 aSmeshActor->UnShrink();
5877 // Displayed entities
5878 else if (paramNameStr == "Entities") {
5879 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5880 int aEntityMode = SMESH_Actor::eAllEntity;
5881 for ( int i = 0; i < mode.count(); i+=2 ) {
5882 if ( i < mode.count()-1 ) {
5883 QString type = mode[i];
5884 bool val = mode[i+1].toInt();
5885 if ( type == "e" && !val )
5886 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
5887 else if ( type == "f" && !val )
5888 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
5889 else if ( type == "v" && !val )
5890 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
5891 else if ( type == "0d" && !val )
5892 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
5893 else if ( type == "b" && !val )
5894 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
5897 aSmeshActor->SetEntityMode( aEntityMode );
5900 else if (paramNameStr == "Colors") {
5901 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5908 QColor outlineColor;
5909 QColor orientationColor;
5915 // below lines are required to get default values for delta coefficients
5916 // of backface color for faces and color of reversed volumes
5917 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
5918 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
5919 for ( int i = 0; i < colors.count(); i++ ) {
5920 QString type = colors[i];
5921 if ( type == "surface" ) {
5922 // face color is set by 3 values r:g:b, where
5923 // - r,g,b - is rgb color components
5924 if ( i+1 >= colors.count() ) break; // format error
5925 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5926 if ( i+2 >= colors.count() ) break; // format error
5927 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5928 if ( i+3 >= colors.count() ) break; // format error
5929 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5930 faceColor.setRgbF( r, g, b );
5933 else if ( type == "backsurface" ) {
5934 // backface color can be defined in several ways
5935 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
5936 // - in latest versions, it is set as delta coefficient
5937 bool rgbOk = false, deltaOk;
5938 if ( i+1 >= colors.count() ) break; // format error
5939 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5940 int delta = colors[i+1].toInt( &deltaOk );
5942 if ( i+1 < colors.count() ) // index is shifted to 1
5943 g = colors[i+1].toDouble( &rgbOk );
5944 if ( rgbOk ) i++; // shift index
5945 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
5946 b = colors[i+1].toDouble( &rgbOk );
5948 // - as currently there's no way to set directly backsurface color as it was before,
5949 // we ignore old dump where r,g,b triple was set
5950 // - also we check that delta parameter is set properly
5951 if ( !rgbOk && deltaOk )
5954 else if ( type == "volume" ) {
5955 // volume color is set by 4 values r:g:b:delta, where
5956 // - r,g,b - is a normal volume rgb color components
5957 // - delta - is a reversed volume color delta coefficient
5958 if ( i+1 >= colors.count() ) break; // format error
5959 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5960 if ( i+2 >= colors.count() ) break; // format error
5961 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5962 if ( i+3 >= colors.count() ) break; // format error
5963 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5964 if ( i+4 >= colors.count() ) break; // format error
5965 int delta = colors[i+4].toInt( &bOk );
5966 if ( !bOk ) break; // format error
5967 volumeColor.setRgbF( r, g, b );
5971 else if ( type == "edge" ) {
5972 // edge color is set by 3 values r:g:b, where
5973 // - r,g,b - is rgb color components
5974 if ( i+1 >= colors.count() ) break; // format error
5975 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5976 if ( i+2 >= colors.count() ) break; // format error
5977 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5978 if ( i+3 >= colors.count() ) break; // format error
5979 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5980 edgeColor.setRgbF( r, g, b );
5983 else if ( type == "node" ) {
5984 // node color is set by 3 values r:g:b, where
5985 // - r,g,b - is rgb color components
5986 if ( i+1 >= colors.count() ) break; // format error
5987 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
5988 if ( i+2 >= colors.count() ) break; // format error
5989 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
5990 if ( i+3 >= colors.count() ) break; // format error
5991 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
5992 nodeColor.setRgbF( r, g, b );
5995 else if ( type == "elem0d" ) {
5996 // 0d element color is set by 3 values r:g:b, where
5997 // - r,g,b - is rgb color components
5998 if ( i+1 >= colors.count() ) break; // format error
5999 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6000 if ( i+2 >= colors.count() ) break; // format error
6001 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6002 if ( i+3 >= colors.count() ) break; // format error
6003 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6004 elem0dColor.setRgbF( r, g, b );
6007 else if ( type == "ball" ) {
6008 // ball color is set by 3 values r:g:b, where
6009 // - r,g,b - is rgb color components
6010 if ( i+1 >= colors.count() ) break; // format error
6011 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6012 if ( i+2 >= colors.count() ) break; // format error
6013 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6014 if ( i+3 >= colors.count() ) break; // format error
6015 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6016 ballColor.setRgbF( r, g, b );
6019 else if ( type == "outline" ) {
6020 // outline color is set by 3 values r:g:b, where
6021 // - r,g,b - is rgb color components
6022 if ( i+1 >= colors.count() ) break; // format error
6023 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6024 if ( i+2 >= colors.count() ) break; // format error
6025 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6026 if ( i+3 >= colors.count() ) break; // format error
6027 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6028 outlineColor.setRgbF( r, g, b );
6031 else if ( type == "orientation" ) {
6032 // orientation color is set by 3 values r:g:b, where
6033 // - r,g,b - is rgb color components
6034 if ( i+1 >= colors.count() ) break; // format error
6035 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6036 if ( i+2 >= colors.count() ) break; // format error
6037 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6038 if ( i+3 >= colors.count() ) break; // format error
6039 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6040 orientationColor.setRgbF( r, g, b );
6045 if ( nodeColor.isValid() )
6046 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6048 if ( edgeColor.isValid() )
6049 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6051 if ( faceColor.isValid() )
6052 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6054 if ( volumeColor.isValid() )
6055 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6056 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6057 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6059 if ( elem0dColor.isValid() )
6060 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6062 if ( ballColor.isValid() )
6063 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6065 if ( outlineColor.isValid() )
6066 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6067 // orientation color
6068 if ( orientationColor.isValid() )
6069 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6072 else if (paramNameStr == "Sizes") {
6073 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6076 int outlineWidth = -1;
6077 int elem0dSize = -1;
6079 double shrinkSize = -1;
6080 double orientationSize = -1;
6081 bool orientation3d = false;
6082 for ( int i = 0; i < sizes.count(); i++ ) {
6083 QString type = sizes[i];
6084 if ( type == "line" ) {
6085 // line (wireframe) width is given as single integer value
6086 if ( i+1 >= sizes.count() ) break; // format error
6087 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6091 if ( type == "outline" ) {
6092 // outline width is given as single integer value
6093 if ( i+1 >= sizes.count() ) break; // format error
6094 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6098 else if ( type == "elem0d" ) {
6099 // 0d element size is given as single integer value
6100 if ( i+1 >= sizes.count() ) break; // format error
6101 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6105 else if ( type == "ball" ) {
6106 // ball size is given as single integer value
6107 if ( i+1 >= sizes.count() ) break; // format error
6108 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6112 else if ( type == "shrink" ) {
6113 // shrink factor is given as single floating point value
6114 if ( i+1 >= sizes.count() ) break; // format error
6115 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6119 else if ( type == "orientation" ) {
6120 // orientation vectors are specified by two values size:3d, where
6121 // - size - is a floating point value specifying scale factor
6122 // - 3d - is a boolean
6123 if ( i+1 >= sizes.count() ) break; // format error
6124 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6125 if ( i+2 >= sizes.count() ) break; // format error
6126 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6127 orientationSize = v1;
6128 orientation3d = (bool)v2;
6132 // line (wireframe) width
6133 if ( lineWidth > 0 )
6134 aSmeshActor->SetLineWidth( lineWidth );
6136 if ( outlineWidth > 0 )
6137 aSmeshActor->SetOutlineWidth( outlineWidth );
6138 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6139 aSmeshActor->SetOutlineWidth( lineWidth );
6141 if ( elem0dSize > 0 )
6142 aSmeshActor->Set0DSize( elem0dSize );
6145 aSmeshActor->SetBallSize( ballSize );
6147 if ( shrinkSize > 0 )
6148 aSmeshActor->SetShrinkFactor( shrinkSize );
6149 // orientation vectors
6150 if ( orientationSize > 0 ) {
6151 aSmeshActor->SetFacesOrientationScale( orientationSize );
6152 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6156 else if (paramNameStr == "PointMarker") {
6157 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6158 if( data.count() >= 2 ) {
6160 int aParam1 = data[1].toInt( &ok );
6162 if( data[0] == "std" && data.count() == 3 ) {
6163 int aParam2 = data[2].toInt( &ok );
6164 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6166 else if( data[0] == "custom" ) {
6167 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6168 if( markerIt != aMarkerMap.end() ) {
6169 VTK::MarkerData aMarkerData = markerIt->second;
6170 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6177 else if (paramNameStr == "Opacity") {
6178 aSmeshActor->SetOpacity(val.toFloat());
6181 else if (paramNameStr.startsWith("ClippingPlane")) {
6182 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6183 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
6184 // new format - val looks like "Off" or "0" (plane id)
6185 // (note: in new format "Off" value is used only for consistency,
6186 // so it is processed together with values in old format)
6187 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
6188 if( anIsOldFormat ) {
6189 if (paramNameStr == "ClippingPlane1" || val == "Off")
6190 aSmeshActor->RemoveAllClippingPlanes();
6192 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
6193 double aDistance = vals[1].toFloat();
6195 anAngle[0] = vals[2].toFloat();
6196 anAngle[1] = vals[3].toFloat();
6198 QList<SUIT_ViewManager*> lst;
6199 getApp()->viewManagers(viewerTypStr, lst);
6200 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6201 if (viewIndex >= 0 && viewIndex < lst.count()) {
6202 SUIT_ViewManager* vman = lst.at(viewIndex);
6203 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6205 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6207 SMESH::TActorList anActorList;
6208 anActorList.push_back( aSmeshActor );
6209 SMESH::OrientedPlane* aPlane =
6210 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
6212 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6213 aClippingPlaneInfo.Plane = aPlane;
6214 aClippingPlaneInfo.ActorList = anActorList;
6215 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6222 int aPlaneId = val.toInt( &ok );
6223 if( ok && aPlaneId >= 0 ) {
6224 bool anIsDefinedPlane = false;
6225 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6226 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6227 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6228 TPlaneInfo& aPlaneInfo = *anIter;
6229 if( aPlaneInfo.PlaneId == aPlaneId ) {
6230 aPlaneInfo.ActorList.push_back( aSmeshActor );
6231 anIsDefinedPlane = true;
6235 if( !anIsDefinedPlane ) {
6236 TPlaneInfo aPlaneInfo;
6237 aPlaneInfo.PlaneId = aPlaneId;
6238 aPlaneInfo.ActorList.push_back( aSmeshActor );
6239 aPlaneInfo.ViewManager = vman;
6241 // to make the list sorted by plane id
6242 anIter = aPlaneInfoList.begin();
6243 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6244 const TPlaneInfo& aPlaneInfoRef = *anIter;
6245 if( aPlaneInfoRef.PlaneId > aPlaneId )
6248 aPlaneInfoList.insert( anIter, aPlaneInfo );
6253 } // if (aSmeshActor)
6254 } // other parameters than Visibility
6256 } // for names/parameters iterator
6257 } // for entries iterator
6259 // take into account planes with empty list of actors referred to them
6260 QList<SUIT_ViewManager*> aVMList;
6261 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6263 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6264 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6265 int aViewId = aPlaneDataIter->first;
6266 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6267 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6269 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6271 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6272 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6273 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6274 const TPlaneData& aPlaneData = *anIter2;
6275 int aPlaneId = aPlaneData.Id;
6277 bool anIsFound = false;
6278 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6279 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6280 const TPlaneInfo& aPlaneInfo = *anIter3;
6281 if( aPlaneInfo.PlaneId == aPlaneId ) {
6288 TPlaneInfo aPlaneInfo; // ActorList field is empty
6289 aPlaneInfo.PlaneId = aPlaneId;
6290 aPlaneInfo.ViewManager = aViewManager;
6292 // to make the list sorted by plane id
6293 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6294 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6295 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6296 if( aPlaneInfoRef.PlaneId > aPlaneId )
6299 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6305 // add clipping planes to actors according to the restored parameters
6306 // and update the clipping plane map
6307 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6308 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6309 int aViewId = anIter1->first;
6310 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6312 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6313 if( anIter2 == aPlaneDataMap.end() )
6315 const TPlaneDataList& aPlaneDataList = anIter2->second;
6317 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6318 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6319 const TPlaneInfo& aPlaneInfo = *anIter3;
6320 int aPlaneId = aPlaneInfo.PlaneId;
6321 const TActorList& anActorList = aPlaneInfo.ActorList;
6322 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6326 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6330 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6332 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6333 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6334 const TPlaneData& aPlaneData = *anIter4;
6335 if( aPlaneData.Id == aPlaneId ) {
6336 SMESH::OrientedPlane* aPlane =
6337 SMESHGUI_ClippingDlg::AddPlane( anActorList,
6339 (SMESH::Orientation)aPlaneData.Orientation,
6340 aPlaneData.Distance,
6343 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6344 aClippingPlaneInfo.Plane = aPlane;
6345 aClippingPlaneInfo.ActorList = anActorList;
6346 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6354 // update all VTK views
6355 QList<SUIT_ViewManager*> lst;
6356 getApp()->viewManagers(lst);
6357 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6358 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6359 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6360 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6361 vtkView->getRenderer()->ResetCameraClippingRange();
6368 \brief Adds preferences for dfont of VTK viewer
6370 \param pIf group identifier
6371 \param param parameter
6372 \return identifier of preferences
6374 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6376 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6378 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6381 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6382 fam.append( tr( "SMESH_FONT_COURIER" ) );
6383 fam.append( tr( "SMESH_FONT_TIMES" ) );
6385 setPreferenceProperty( tfont, "fonts", fam );
6387 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6388 if ( needSize ) f = f | QtxFontEdit::Size;
6389 setPreferenceProperty( tfont, "features", f );
6395 \brief Actions after hypothesis edition
6396 Updates object browser after hypothesis edition
6398 void SMESHGUI::onHypothesisEdit( int result )
6401 SMESHGUI::Modified();
6402 updateObjBrowser( true );
6407 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6408 \param pview view being closed
6410 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6411 #ifndef DISABLE_PLOT2DVIEWER
6412 //Crear all Plot2d Viewers if need.
6413 SMESH::ClearPlot2Viewers(pview);
6417 void SMESHGUI::message( const QString& msg )
6420 QStringList data = msg.split("/");
6421 if ( data.count() > 0 ) {
6422 if ( data.first() == "mesh_loading" ) {
6424 QString entry = data.count() > 1 ? data[1] : QString();
6425 if ( entry.isEmpty() )
6428 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6430 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6433 name = obj->GetName().c_str();
6434 if ( name.isEmpty() )
6437 if ( data.last() == "stop" )
6438 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6440 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6441 QApplication::processEvents();
6447 \brief Connects or disconnects signals about activating and cloning view on the module slots
6448 \param pview view which is connected/disconnected
6450 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6454 SUIT_ViewManager* viewMgr = pview->getViewManager();
6456 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6457 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6459 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6460 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6465 \brief Return \c true if object can be renamed
6467 bool SMESHGUI::renameAllowed( const QString& entry) const {
6468 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6472 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6476 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6481 if(appStudy->isComponent(entry) || obj->isReference())
6484 // check type to prevent renaming of inappropriate objects
6485 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6486 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6487 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6488 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6489 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6490 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6497 Rename object by entry.
6498 \param entry entry of the object
6499 \param name new name of the object
6500 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6502 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6504 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6508 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6513 _PTR(Study) aStudy = appStudy->studyDS();
6518 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6520 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6525 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6526 _PTR(GenericAttribute) anAttr;
6527 _PTR(AttributeName) aName;
6529 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6531 // check type to prevent renaming of inappropriate objects
6532 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6533 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6534 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6535 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6536 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6537 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6538 if ( !name.isEmpty() ) {
6539 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6541 // update name of group object and its actor
6542 Handle(SALOME_InteractiveObject) IObject =
6543 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6545 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6546 if( !aGroupObject->_is_nil() ) {
6547 aGroupObject->SetName( qPrintable(name) );
6548 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6549 anActor->setName( qPrintable(name) );
6560 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6562 static QList<QColor> colors;
6564 if ( colors.isEmpty() ) {
6566 for (int s = 0; s < 2 ; s++)
6568 for (int v = 100; v >= 40; v = v - 20)
6570 for (int h = 0; h < 359 ; h = h + 60)
6572 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
6577 static int currentColor = 0;
6579 SALOMEDS::Color color;
6580 color.R = (double)colors[currentColor].red() / 255.0;
6581 color.G = (double)colors[currentColor].green() / 255.0;
6582 color.B = (double)colors[currentColor].blue() / 255.0;
6584 currentColor = (currentColor+1) % colors.count();