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 bool SMESHGUI::automaticUpdate( SMESH::SMESH_Mesh_ptr theMesh,
1985 int* entities, bool* limitExceeded )
1987 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1991 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
1992 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1993 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
1995 long requestedSize = theMesh->NbElements();
1997 *entities = SMESH_Actor::eAllEntity;
1999 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2001 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2003 if ( incrementalLimit ) {
2004 long nbOdElems = theMesh->Nb0DElements();
2005 long nbEdges = theMesh->NbEdges();
2006 long nbFaces = theMesh->NbFaces();
2007 long nbVolumes = theMesh->NbVolumes();
2008 long nbBalls = theMesh->NbBalls();
2011 if ( nbOdElems > 0 ) {
2012 if ( total + nbOdElems > updateLimit )
2013 *entities = *entities & ~SMESH_Actor::e0DElements;
2019 if ( nbEdges > 0 ) {
2020 if ( total + nbEdges > updateLimit )
2021 *entities = *entities & ~SMESH_Actor::eEdges;
2027 if ( nbFaces > 0 ) {
2028 if ( total + nbFaces > updateLimit )
2029 *entities = *entities & ~SMESH_Actor::eFaces;
2035 if ( nbVolumes > 0 ) {
2036 if ( total + nbVolumes > updateLimit )
2037 *entities = *entities & ~SMESH_Actor::eVolumes;
2043 if ( nbBalls > 0 ) {
2044 if ( total + nbBalls > updateLimit )
2045 *entities = *entities & ~SMESH_Actor::eBallElem;
2052 return autoUpdate && !exceeded;
2055 //=============================================================================
2059 //=============================================================================
2060 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2062 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2065 //=============================================================================
2069 //=============================================================================
2070 SMESHGUI* SMESHGUI::GetSMESHGUI()
2072 SMESHGUI* smeshMod = 0;
2073 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2076 CAM_Module* module = app->module( "Mesh" );
2077 smeshMod = dynamic_cast<SMESHGUI*>( module );
2080 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2082 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2085 _PTR(Study) aStudy = study->studyDS();
2087 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2096 Standard_EXPORT SMESHGUI* GetComponentGUI()
2098 return SMESHGUI::GetSMESHGUI();
2102 //=============================================================================
2106 //=============================================================================
2107 void SMESHGUI::SetState(int aState)
2112 //=============================================================================
2116 //=============================================================================
2117 void SMESHGUI::ResetState()
2122 //=============================================================================
2126 //=============================================================================
2127 void SMESHGUI::EmitSignalDeactivateDialog()
2129 emit SignalDeactivateActiveDialog();
2132 //=============================================================================
2136 //=============================================================================
2137 void SMESHGUI::EmitSignalStudyFrameChanged()
2139 emit SignalStudyFrameChanged();
2142 //=============================================================================
2146 //=============================================================================
2147 void SMESHGUI::EmitSignalCloseAllDialogs()
2149 emit SignalCloseAllDialogs();
2152 //=============================================================================
2156 //=============================================================================
2157 void SMESHGUI::EmitSignalVisibilityChanged()
2159 emit SignalVisibilityChanged();
2162 //=============================================================================
2166 //=============================================================================
2167 QDialog *SMESHGUI::GetActiveDialogBox()
2169 return myActiveDialogBox;
2172 //=============================================================================
2176 //=============================================================================
2177 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2179 myActiveDialogBox = (QDialog *) aDlg;
2183 //=============================================================================
2187 //=============================================================================
2188 SUIT_Desktop* SMESHGUI::desktop()
2190 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2192 return app->desktop();
2197 //=============================================================================
2201 //=============================================================================
2202 SalomeApp_Study* SMESHGUI::activeStudy()
2204 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2206 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2211 //=============================================================================
2215 //=============================================================================
2216 void SMESHGUI::Modified( bool theIsUpdateActions )
2218 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2219 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2220 appStudy->Modified();
2221 if( theIsUpdateActions )
2222 app->updateActions();
2227 //=============================================================================
2231 //=============================================================================
2232 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2234 /* Here the position is on the bottom right corner - 10 */
2235 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2237 SUIT_Desktop *PP = desktop();
2238 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2239 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2243 //=============================================================================
2247 //=============================================================================
2248 static int isStudyLocked(_PTR(Study) theStudy){
2249 return theStudy->GetProperties()->IsLocked();
2252 static bool checkLock(_PTR(Study) theStudy) {
2253 if (isStudyLocked(theStudy)) {
2254 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2255 QObject::tr("WRN_WARNING"),
2256 QObject::tr("WRN_STUDY_LOCKED") );
2262 //=======================================================================
2263 //function : CheckActiveStudyLocked
2265 //=======================================================================
2267 bool SMESHGUI::isActiveStudyLocked()
2269 _PTR(Study) aStudy = activeStudy()->studyDS();
2270 return checkLock( aStudy );
2273 //=============================================================================
2277 //=============================================================================
2278 bool SMESHGUI::OnGUIEvent( int theCommandID )
2280 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2284 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2285 SUIT_ResourceMgr* mgr = resourceMgr();
2289 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2290 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2293 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2294 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2296 //QAction* act = action( theCommandID );
2298 switch (theCommandID) {
2300 if(checkLock(aStudy)) break;
2312 if(checkLock(aStudy)) break;
2313 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2317 case 150: //MED FILE INFORMATION
2319 SALOME_ListIO selected;
2320 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2322 aSel->selectedObjects( selected );
2323 if( selected.Extent() )
2325 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2326 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2327 if ( !aMesh->_is_nil() )
2329 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2336 case 122: // EXPORT MED
2351 ::ExportMeshToFile(theCommandID);
2355 case 200: // SCALAR BAR
2357 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2358 SALOME_ListIO selected;
2360 aSel->selectedObjects( selected );
2362 if( selected.Extent() ) {
2363 Handle(SALOME_InteractiveObject) anIO = selected.First();
2364 if( anIO->hasEntry() ) {
2365 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2366 anActor->SetControlMode( SMESH_Actor::eNone );
2367 #ifndef DISABLE_PLOT2DVIEWER
2368 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2377 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2382 // dump control distribution data to the text file
2383 ::SaveDistribution();
2389 // show/ distribution
2390 ::ShowDistribution();
2394 #ifndef DISABLE_PLOT2DVIEWER
2397 // plot distribution
2398 ::PlotDistribution();
2409 ::DisableAutoColor();
2412 case 1134: // Clipping
2413 case 1133: // Tranparency
2414 case 1132: // Display preferences (colors, shrink size, line width, ...)
2421 ::SetDisplayMode(theCommandID, myMarkerMap);
2424 //2D quadratic representation
2427 ::SetDisplayMode(theCommandID, myMarkerMap);
2431 case 216: // 0D elements
2434 case 219: // Volumes
2435 case 220: // All Entity
2437 ::SetDisplayEntity(theCommandID);
2440 case 221: // Orientation of faces
2442 LightApp_SelectionMgr* mgr = selectionMgr();
2443 SALOME_ListIO selected; mgr->selectedObjects( selected );
2445 SALOME_ListIteratorOfListIO it(selected);
2446 for( ; it.More(); it.Next()) {
2447 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2448 if(anIObject->hasEntry()) {
2449 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2450 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2459 if(checkLock(aStudy)) break;
2460 SUIT_OverrideCursor wc;
2462 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2465 SMESH::UpdateView();
2467 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2468 SMESH::OnVisuException();
2470 catch (...) { // PAL16774 (Crash after display of many groups)
2471 SMESH::OnVisuException();
2475 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2476 aSel->selectedObjects( l );
2477 aSel->setSelectedObjects( l );
2482 case 301: // DISPLAY
2483 case 302: // DISPLAY ONLY
2485 SMESH::EDisplaing anAction;
2486 switch (theCommandID) {
2487 case 300: anAction = SMESH::eErase; break;
2488 case 301: anAction = SMESH::eDisplay; break;
2489 case 302: anAction = SMESH::eDisplayOnly; break;
2492 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2493 SALOME_ListIO sel_objects, to_process;
2495 aSel->selectedObjects( sel_objects );
2497 if( theCommandID==302 )
2499 MESSAGE("anAction = SMESH::eDisplayOnly");
2500 startOperation( myEraseAll );
2503 extractContainers( sel_objects, to_process );
2506 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2510 SALOME_ListIteratorOfListIO It( to_process );
2511 for ( ; It.More(); It.Next()) {
2513 Handle(SALOME_InteractiveObject) IOS = It.Value();
2514 if (IOS->hasEntry()) {
2516 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2517 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2518 break; // PAL16774 (Crash after display of many groups)
2520 if (anAction == SMESH::eDisplayOnly)
2522 MESSAGE("anAction = SMESH::eDisplayOnly");
2523 anAction = SMESH::eDisplay;
2529 // PAL13338 + PAL15161 -->
2530 if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2531 MESSAGE("anAction = SMESH::eDisplayOnly");
2532 SMESH::UpdateView();
2533 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2535 // PAL13338 + PAL15161 <--
2537 catch (...) { // PAL16774 (Crash after display of many groups)
2538 SMESH::OnVisuException();
2541 if (anAction == SMESH::eErase) {
2542 MESSAGE("anAction == SMESH::eErase");
2544 aSel->setSelectedObjects( l1 );
2547 aSel->setSelectedObjects( to_process );
2554 if(checkLock(aStudy)) break;
2557 EmitSignalDeactivateDialog();
2559 ( new SMESHGUI_NodesDlg( this ) )->show();
2562 SUIT_MessageBox::warning(desktop(),
2563 tr("SMESH_WRN_WARNING"),
2564 tr("SMESH_WRN_VIEWER_VTK"));
2569 case 2151: // FILTER
2573 EmitSignalDeactivateDialog();
2574 ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2579 case 701: // COMPUTE MESH
2580 case 711: // PRECOMPUTE MESH
2581 case 712: // EVALUATE MESH
2582 case 713: // MESH ORDER
2583 case 702: // Create mesh
2584 case 703: // Create sub-mesh
2585 case 704: // Edit mesh/sub-mesh
2586 startOperation( theCommandID );
2588 case 705: // copy mesh
2590 if (checkLock(aStudy)) break;
2591 EmitSignalDeactivateDialog();
2592 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2595 case 710: // Build compound mesh
2597 if (checkLock(aStudy)) break;
2598 EmitSignalDeactivateDialog();
2599 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2603 case 407: // DIAGONAL INVERSION
2604 case 408: // Delete diagonal
2608 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2609 tr( "NOT_A_VTK_VIEWER" ) );
2613 if ( checkLock( aStudy ) )
2616 /*Standard_Boolean aRes;
2617 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2618 if ( aMesh->_is_nil() )
2620 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2621 tr( "SMESH_BAD_SELECTION" ) );
2625 EmitSignalDeactivateDialog();
2626 if ( theCommandID == 407 )
2627 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2629 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2632 case 409: // Change orientation
2633 case 410: // Union of triangles
2634 case 411: // Cutting of quadrangles
2635 case 419: // Splitting volumes into tetrahedra
2639 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2640 tr( "NOT_A_VTK_VIEWER" ) );
2644 if ( checkLock( aStudy ) )
2647 EmitSignalDeactivateDialog();
2648 SMESHGUI_MultiEditDlg* aDlg = NULL;
2649 if ( theCommandID == 409 )
2650 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2651 else if ( theCommandID == 410 )
2652 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2653 else if ( theCommandID == 419 )
2654 aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2656 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2661 case 412: // Smoothing
2663 if(checkLock(aStudy)) break;
2665 EmitSignalDeactivateDialog();
2666 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2669 SUIT_MessageBox::warning(desktop(),
2670 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2674 case 413: // Extrusion
2676 if (checkLock(aStudy)) break;
2678 EmitSignalDeactivateDialog();
2679 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2681 SUIT_MessageBox::warning(desktop(),
2682 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2686 case 414: // Revolution
2688 if(checkLock(aStudy)) break;
2690 EmitSignalDeactivateDialog();
2691 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2694 SUIT_MessageBox::warning(desktop(),
2695 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2699 case 415: // Pattern mapping
2701 if ( checkLock( aStudy ) )
2705 EmitSignalDeactivateDialog();
2706 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2709 SUIT_MessageBox::warning(desktop(),
2710 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2714 case 416: // Extrusion along a path
2716 if (checkLock(aStudy)) break;
2718 EmitSignalDeactivateDialog();
2719 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2721 SUIT_MessageBox::warning(desktop(),
2722 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2726 case 417: // Convert mesh to quadratic
2727 case 418: // create 2D mesh from 3D
2728 case 420: // Reorient faces
2729 case 806: // CREATE GEO GROUP
2731 startOperation( theCommandID );
2734 case 801: // CREATE GROUP
2738 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2739 tr( "NOT_A_VTK_VIEWER" ) );
2743 if(checkLock(aStudy)) break;
2744 EmitSignalDeactivateDialog();
2745 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2747 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2748 SALOME_ListIO selected;
2750 aSel->selectedObjects( selected );
2752 int nbSel = selected.Extent();
2754 // check if mesh is selected
2755 aMesh = SMESH::GetMeshByIO( selected.First() );
2757 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2762 case 802: // CONSTRUCT GROUP
2766 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2767 tr( "NOT_A_VTK_VIEWER" ) );
2771 if(checkLock(aStudy)) break;
2772 EmitSignalDeactivateDialog();
2774 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2775 SALOME_ListIO selected;
2777 aSel->selectedObjects( selected );
2779 int nbSel = selected.Extent();
2781 // check if submesh is selected
2782 Handle(SALOME_InteractiveObject) IObject = selected.First();
2783 if (IObject->hasEntry()) {
2784 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2786 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2787 if (!aSubMesh->_is_nil()) {
2789 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2790 // get submesh elements list by types
2791 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2792 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2793 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2794 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2795 // create group for each type o elements
2796 QString aName = IObject->getName();
2797 QStringList anEntryList;
2798 if (aNodes->length() > 0) {
2799 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2800 aGroup->Add(aNodes.inout());
2801 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2802 anEntryList.append( aSObject->GetID().c_str() );
2804 if (aEdges->length() > 0) {
2805 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2806 aGroup->Add(aEdges.inout());
2807 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2808 anEntryList.append( aSObject->GetID().c_str() );
2810 if (aFaces->length() > 0) {
2811 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2812 aGroup->Add(aFaces.inout());
2813 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2814 anEntryList.append( aSObject->GetID().c_str() );
2816 if (aVolumes->length() > 0) {
2817 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2818 aGroup->Add(aVolumes.inout());
2819 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2820 anEntryList.append( aSObject->GetID().c_str() );
2823 anApp->browseObjects( anEntryList );
2825 catch(const SALOME::SALOME_Exception & S_ex){
2826 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2833 SUIT_MessageBox::warning(desktop(),
2834 tr("SMESH_WRN_WARNING"),
2835 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2840 case 803: // EDIT GROUP
2844 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2845 tr( "NOT_A_VTK_VIEWER" ) );
2849 if(checkLock(aStudy)) break;
2850 EmitSignalDeactivateDialog();
2852 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2853 SALOME_ListIO selected;
2855 aSel->selectedObjects( selected );
2857 SALOME_ListIteratorOfListIO It (selected);
2858 int nbSelectedGroups = 0;
2859 for ( ; It.More(); It.Next() )
2861 SMESH::SMESH_GroupBase_var aGroup =
2862 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2863 if (!aGroup->_is_nil()) {
2865 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2869 if (nbSelectedGroups == 0)
2871 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2877 case 804: // Add elements to group
2879 if(checkLock(aStudy)) break;
2880 if (myState == 800) {
2881 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2882 if (aDlg) aDlg->onAdd();
2887 case 805: // Remove elements from group
2889 if(checkLock(aStudy)) break;
2890 if (myState == 800) {
2891 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2892 if (aDlg) aDlg->onRemove();
2897 case 815: // Edit GEOM GROUP as standalone
2901 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2902 tr( "NOT_A_VTK_VIEWER" ) );
2906 if(checkLock(aStudy)) break;
2907 EmitSignalDeactivateDialog();
2909 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2910 SALOME_ListIO selected;
2912 aSel->selectedObjects( selected );
2914 SALOME_ListIteratorOfListIO It (selected);
2915 for ( ; It.More(); It.Next() )
2917 SMESH::SMESH_GroupOnGeom_var aGroup =
2918 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2919 if (!aGroup->_is_nil()) {
2920 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2925 SMESH::SMESH_GroupOnFilter_var aGroup =
2926 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2927 if (!aGroup->_is_nil()) {
2928 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2936 case 810: // Union Groups
2937 case 811: // Intersect groups
2938 case 812: // Cut groups
2942 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2943 tr( "NOT_A_VTK_VIEWER" ) );
2947 if ( checkLock( aStudy ) )
2950 EmitSignalDeactivateDialog();
2952 SMESHGUI_GroupOpDlg* aDlg = 0;
2953 if ( theCommandID == 810 )
2954 aDlg = new SMESHGUI_UnionGroupsDlg( this );
2955 else if ( theCommandID == 811 )
2956 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2958 aDlg = new SMESHGUI_CutGroupsDlg( this );
2965 case 814: // Create groups of entities from existing groups of superior dimensions
2967 if ( checkLock( aStudy ) )
2970 EmitSignalDeactivateDialog();
2971 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2977 case 813: // Delete groups with their contents
2981 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2982 tr( "NOT_A_VTK_VIEWER" ) );
2986 if ( checkLock( aStudy ) )
2989 EmitSignalDeactivateDialog();
2991 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2995 case 900: // MESH INFOS
2996 case 903: // WHAT IS
2998 int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2999 EmitSignalDeactivateDialog();
3000 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3001 SALOME_ListIO selected;
3003 aSel->selectedObjects( selected );
3005 if ( selected.Extent() > 1 ) { // a dlg for each IO
3006 SALOME_ListIteratorOfListIO It( selected );
3007 for ( ; It.More(); It.Next() ) {
3008 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3009 dlg->showInfo( It.Value() );
3014 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3020 case 904: // FIND ELEM
3022 startOperation( theCommandID );
3026 case 1100: // EDIT HYPOTHESIS
3028 if(checkLock(aStudy)) break;
3030 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3031 SALOME_ListIO selected;
3033 aSel->selectedObjects( selected );
3035 int nbSel = selected.Extent();
3038 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3039 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3041 /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
3042 /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects */
3043 /* Warning : however by internal mechanism all subMeshes icons are changed ! */
3044 if ( !aHypothesis->_is_nil() )
3047 //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
3048 SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
3050 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3060 case 1102: // REMOVE HYPOTHESIS / ALGORITHMS
3062 if(checkLock(aStudy)) break;
3063 SUIT_OverrideCursor wc;
3065 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3066 SALOME_ListIO selected;
3068 aSel->selectedObjects( selected, QString::null, false );
3070 SALOME_ListIteratorOfListIO It(selected);
3071 for (int i = 0; It.More(); It.Next(), i++) {
3072 Handle(SALOME_InteractiveObject) IObject = It.Value();
3073 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3076 aSel->setSelectedObjects( l1 );
3082 case 4009: // ELEM0D
3084 case 4021: // TRIANGLE
3086 case 4023: // POLYGON
3090 case 4134: // PYRAMID
3091 case 4135: // OCTA12
3093 if(checkLock(aStudy)) break;
3095 EmitSignalDeactivateDialog();
3096 SMDSAbs_EntityType type = SMDSEntity_Edge;
3097 switch (theCommandID) {
3098 case 4008: type = SMDSEntity_Ball; break;
3099 case 4009: type = SMDSEntity_0D; break;
3100 case 4021: type = SMDSEntity_Triangle; break;
3101 case 4022: type = SMDSEntity_Quadrangle; break;
3102 case 4031: type = SMDSEntity_Tetra; break;
3103 case 4023: type = SMDSEntity_Polygon; break;
3104 case 4032: type = SMDSEntity_Hexa; break;
3105 case 4133: type = SMDSEntity_Penta; break;
3106 case 4134: type = SMDSEntity_Pyramid; break;
3107 case 4135: type = SMDSEntity_Hexagonal_Prism; break;
3110 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3113 SUIT_MessageBox::warning(desktop(),
3114 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3118 case 4033: // POLYHEDRON
3120 if(checkLock(aStudy)) break;
3122 EmitSignalDeactivateDialog();
3123 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3126 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3127 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3131 case 4034: // QUADRATIC EDGE
3132 case 4035: // QUADRATIC TRIANGLE
3133 case 4036: // QUADRATIC QUADRANGLE
3134 case 4136: // BIQUADRATIC QUADRANGLE
3135 case 4137: // BIQUADRATIC TRIANGLE
3136 case 4037: // QUADRATIC TETRAHEDRON
3137 case 4038: // QUADRATIC PYRAMID
3138 case 4039: // QUADRATIC PENTAHEDRON
3139 case 4040: // QUADRATIC HEXAHEDRON
3140 case 4140: // TRIQUADRATIC HEXAHEDRON
3142 if(checkLock(aStudy)) break;
3144 EmitSignalDeactivateDialog();
3145 SMDSAbs_EntityType type = SMDSEntity_Last;
3147 switch (theCommandID) {
3148 case 4034: type = SMDSEntity_Quad_Edge; break;
3149 case 4035: type = SMDSEntity_Quad_Triangle; break;
3150 case 4036: type = SMDSEntity_Quad_Quadrangle; break;
3151 case 4136: type = SMDSEntity_BiQuad_Quadrangle; break;
3152 case 4137: type = SMDSEntity_BiQuad_Triangle; break;
3153 case 4037: type = SMDSEntity_Quad_Tetra; break;
3154 case 4038: type = SMDSEntity_Quad_Pyramid; break;
3155 case 4039: type = SMDSEntity_Quad_Penta; break;
3156 case 4040: type = SMDSEntity_Quad_Hexa; break;
3157 case 4140: type = SMDSEntity_TriQuad_Hexa; break;
3160 if ( type != SMDSEntity_Last )
3161 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3164 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3165 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3169 case 4041: // REMOVES NODES
3171 if(checkLock(aStudy)) break;
3173 EmitSignalDeactivateDialog();
3174 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3177 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3178 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3182 case 4042: // REMOVES ELEMENTS
3184 if(checkLock(aStudy)) break;
3186 EmitSignalDeactivateDialog();
3187 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3191 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3192 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3196 case 4043: { // CLEAR_MESH
3198 if(checkLock(aStudy)) break;
3200 SALOME_ListIO selected;
3201 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3202 aSel->selectedObjects( selected );
3204 SUIT_OverrideCursor wc;
3205 SALOME_ListIteratorOfListIO It (selected);
3206 for ( ; It.More(); It.Next() )
3208 Handle(SALOME_InteractiveObject) IOS = It.Value();
3209 SMESH::SMESH_Mesh_var aMesh =
3210 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3211 if ( aMesh->_is_nil()) continue;
3213 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3215 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3216 SMESH::ModifiedMesh( aMeshSObj, false, true);
3217 // hide groups and submeshes
3218 _PTR(ChildIterator) anIter =
3219 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3220 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3222 _PTR(SObject) so = anIter->Value();
3223 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3226 catch (const SALOME::SALOME_Exception& S_ex){
3228 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3232 SMESH::UpdateView();
3236 case 4044: // REMOVE ORPHAN NODES
3238 if(checkLock(aStudy)) break;
3239 SALOME_ListIO selected;
3240 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3241 aSel->selectedObjects( selected );
3242 if ( selected.Extent() == 1 ) {
3243 Handle(SALOME_InteractiveObject) anIO = selected.First();
3244 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3245 if ( !aMesh->_is_nil() ) {
3246 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3247 tr( "SMESH_WARNING" ),
3248 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3249 SUIT_MessageBox::Yes |
3250 SUIT_MessageBox::No,
3251 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3254 SUIT_OverrideCursor wc;
3255 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3256 int removed = aMeshEditor->RemoveOrphanNodes();
3257 SUIT_MessageBox::information(SMESHGUI::desktop(),
3258 tr("SMESH_INFORMATION"),
3259 tr("NB_NODES_REMOVED").arg(removed));
3260 if ( removed > 0 ) {
3261 SMESH::UpdateView();
3262 SMESHGUI::Modified();
3265 catch (const SALOME::SALOME_Exception& S_ex) {
3266 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3275 case 4051: // RENUMBERING NODES
3277 if(checkLock(aStudy)) break;
3279 EmitSignalDeactivateDialog();
3280 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3284 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3285 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3289 case 4052: // RENUMBERING ELEMENTS
3291 if(checkLock(aStudy)) break;
3293 EmitSignalDeactivateDialog();
3294 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3298 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3299 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3303 case 4061: // TRANSLATION
3305 if(checkLock(aStudy)) break;
3307 EmitSignalDeactivateDialog();
3308 ( new SMESHGUI_TranslationDlg( this ) )->show();
3311 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3312 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3316 case 4062: // ROTATION
3318 if(checkLock(aStudy)) break;
3320 EmitSignalDeactivateDialog();
3321 ( new SMESHGUI_RotationDlg( this ) )->show();
3324 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3325 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3329 case 4063: // SYMMETRY
3331 if(checkLock(aStudy)) break;
3333 EmitSignalDeactivateDialog();
3334 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3337 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3338 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3342 case 4064: // SEWING
3344 if(checkLock(aStudy)) break;
3346 EmitSignalDeactivateDialog();
3347 ( new SMESHGUI_SewingDlg( this ) )->show();
3350 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3351 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3355 case 4065: // MERGE NODES
3357 if(checkLock(aStudy)) break;
3359 EmitSignalDeactivateDialog();
3360 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3363 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3364 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3368 case 4066: // MERGE EQUAL ELEMENTS
3370 if (checkLock(aStudy)) break;
3372 EmitSignalDeactivateDialog();
3373 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3375 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3376 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3381 case 4067: // MAKE MESH PASS THROUGH POINT
3382 startOperation( 4067 );
3387 if(checkLock(aStudy)) break;
3389 EmitSignalDeactivateDialog();
3390 ( new SMESHGUI_ScaleDlg( this ) )->show();
3393 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3394 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3399 case 4069: // DUPLICATE NODES
3401 if(checkLock(aStudy)) break;
3403 EmitSignalDeactivateDialog();
3404 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3407 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3408 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3413 case 4070: // 0D_ON_ALL_NODES
3414 startOperation( 4070 );
3417 case 5105: // Library of selection filters
3419 static QList<int> aTypes;
3420 if ( aTypes.isEmpty() )
3422 aTypes.append( SMESH::NODE );
3423 aTypes.append( SMESH::EDGE );
3424 aTypes.append( SMESH::FACE );
3425 aTypes.append( SMESH::VOLUME );
3427 if (!myFilterLibraryDlg)
3428 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3429 else if (myFilterLibraryDlg->isHidden())
3430 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3431 myFilterLibraryDlg->raise();
3435 case 6017: // CONTROLS
3463 LightApp_SelectionMgr* mgr = selectionMgr();
3464 SALOME_ListIO selected; mgr->selectedObjects( selected );
3466 if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3467 _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3469 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3470 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
3471 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3472 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
3473 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3474 SUIT_OverrideCursor wc;
3475 ::Control( theCommandID );
3480 SUIT_MessageBox::warning(desktop(),
3481 tr( "SMESH_WRN_WARNING" ),
3482 tr( "SMESH_BAD_SELECTION" ) );
3486 SUIT_MessageBox::warning(desktop(),
3487 tr( "SMESH_WRN_WARNING" ),
3488 tr( "NOT_A_VTK_VIEWER" ) );
3492 OverallMeshQuality();
3496 SUIT_OverrideCursor wc;
3497 LightApp_SelectionMgr* mgr = selectionMgr();
3498 SALOME_ListIO selected; mgr->selectedObjects( selected );
3500 SALOME_ListIteratorOfListIO it(selected);
3501 for( ; it.More(); it.Next()) {
3502 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3503 if(anIObject->hasEntry()) {
3504 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3505 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3513 SUIT_OverrideCursor wc;
3514 LightApp_SelectionMgr* mgr = selectionMgr();
3515 SALOME_ListIO selected; mgr->selectedObjects( selected );
3517 SALOME_ListIteratorOfListIO it(selected);
3518 for( ; it.More(); it.Next()) {
3519 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3520 if(anIObject->hasEntry())
3521 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3522 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3530 int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3531 EmitSignalDeactivateDialog();
3532 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3538 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3539 //updateObjBrowser();
3543 //=============================================================================
3547 //=============================================================================
3548 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3553 //=============================================================================
3557 //=============================================================================
3558 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3563 //=============================================================================
3567 //=============================================================================
3568 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3573 //=============================================================================
3574 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3575 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3577 //=============================================================================
3578 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3579 SUIT_ViewWindow* wnd )
3581 if(theIO->hasEntry()){
3582 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3583 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3587 //=======================================================================
3588 // function : createSMESHAction
3590 //=======================================================================
3591 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3592 const int key, const bool toggle, const QString& shortcutAction )
3595 QWidget* parent = application()->desktop();
3596 SUIT_ResourceMgr* resMgr = resourceMgr();
3598 if ( !icon_id.isEmpty() )
3599 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3601 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3602 if ( !pix.isNull() )
3603 icon = QIcon( pix );
3605 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3606 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3607 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3609 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3610 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3613 //=======================================================================
3614 // function : createPopupItem
3616 //=======================================================================
3617 void SMESHGUI::createPopupItem( const int id,
3618 const QString& clients,
3619 const QString& types,
3620 const QString& theRule,
3623 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3624 popupMgr()->insert( action( id ), pId, 0 );
3626 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3627 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3628 QString rule = "(%1) and (%2) and (%3)";
3629 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3630 if( clients.isEmpty() )
3631 rule = rule.arg( QString( "true" ) );
3633 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3634 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3637 bool cont = myRules.contains( id );
3639 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3641 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3642 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3645 //=======================================================================
3646 // function : initialize
3648 //=======================================================================
3649 void SMESHGUI::initialize( CAM_Application* app )
3651 SalomeApp_Module::initialize( app );
3653 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3655 /* Automatic Update flag */
3656 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3658 // ----- create actions --------------
3660 //createSMESHAction( 111, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3661 createSMESHAction( 112, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3662 createSMESHAction( 113, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3663 createSMESHAction( 114, "NUM" );
3664 createSMESHAction( 115, "IMPORT_STL" );
3665 createSMESHAction( 116, "IMPORT_CGNS" );
3666 createSMESHAction( 117, "IMPORT_SAUV" );
3667 createSMESHAction( 118, "IMPORT_GMF" );
3668 createSMESHAction( 121, "DAT" );
3669 createSMESHAction( 122, "MED" );
3670 createSMESHAction( 123, "UNV" );
3671 createSMESHAction( 140, "STL" );
3672 createSMESHAction( 142, "CGNS");
3673 createSMESHAction( 144, "SAUV");
3674 createSMESHAction( 146, "GMF" );
3675 createSMESHAction( 124, "DAT" );
3676 createSMESHAction( 125, "MED" );
3677 createSMESHAction( 126, "UNV" );
3678 createSMESHAction( 141, "STL" );
3679 createSMESHAction( 143, "CGNS");
3680 createSMESHAction( 145, "SAUV");
3681 createSMESHAction( 147, "GMF" );
3682 createSMESHAction( 150, "FILE_INFO" );
3683 createSMESHAction( 33, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3684 createSMESHAction( 5105, "SEL_FILTER_LIB" );
3685 createSMESHAction( 701, "COMPUTE", "ICON_COMPUTE" );
3686 createSMESHAction( 702, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3687 createSMESHAction( 703, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3688 createSMESHAction( 704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3689 createSMESHAction( 705, "COPY_MESH", "ICON_COPY_MESH" );
3690 createSMESHAction( 710, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3691 createSMESHAction( 711, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3692 createSMESHAction( 712, "EVALUATE", "ICON_COMPUTE" );
3693 createSMESHAction( 713, "MESH_ORDER", "ICON_COMPUTE" );
3694 createSMESHAction( 806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3695 createSMESHAction( 801, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3696 createSMESHAction( 802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3697 createSMESHAction( 803, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3698 createSMESHAction( 815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3699 createSMESHAction( 804, "ADD" );
3700 createSMESHAction( 805, "REMOVE" );
3701 createSMESHAction( 810, "UN_GROUP", "ICON_UNION" );
3702 createSMESHAction( 811, "INT_GROUP", "ICON_INTERSECT" );
3703 createSMESHAction( 812, "CUT_GROUP", "ICON_CUT" );
3704 createSMESHAction( 814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3705 createSMESHAction( 813, "DEL_GROUP", "ICON_DEL_GROUP" );
3706 createSMESHAction( 900, "ADV_INFO", "ICON_ADV_INFO" );
3707 //createSMESHAction( 902, "STD_INFO", "ICON_STD_INFO" );
3708 //createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3709 createSMESHAction( 904, "FIND_ELEM", "ICON_FIND_ELEM" );
3710 createSMESHAction( 6001, "LENGTH", "ICON_LENGTH", 0, true );
3711 createSMESHAction( 6002, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3712 createSMESHAction( 6021, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3713 createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3714 createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3715 createSMESHAction( 6024, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3716 createSMESHAction( 6025, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3717 createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3718 createSMESHAction( 6027, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3719 createSMESHAction( 6028, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3720 createSMESHAction( 6029, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3721 createSMESHAction( 6030, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3722 createSMESHAction( 6031, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3723 createSMESHAction( 6032, "OVERALL_MESH_QUALITY" );
3724 createSMESHAction( 6003, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3725 createSMESHAction( 6004, "CONNECTION", "ICON_CONNECTION", 0, true );
3726 createSMESHAction( 6005, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3727 createSMESHAction( 6011, "AREA", "ICON_AREA", 0, true );
3728 createSMESHAction( 6012, "TAPER", "ICON_TAPER", 0, true );
3729 createSMESHAction( 6013, "ASPECT", "ICON_ASPECT", 0, true );
3730 createSMESHAction( 6014, "MIN_ANG", "ICON_ANGLE", 0, true );
3731 createSMESHAction( 6015, "WARP", "ICON_WARP", 0, true );
3732 createSMESHAction( 6016, "SKEW", "ICON_SKEW", 0, true );
3733 createSMESHAction( 6017, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3734 createSMESHAction( 6018, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3735 createSMESHAction( 6019, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3736 createSMESHAction( 6009, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3737 createSMESHAction( 4000, "NODE", "ICON_DLG_NODE" );
3738 createSMESHAction( 4009, "ELEM0D", "ICON_DLG_ELEM0D" );
3739 createSMESHAction( 4008, "BALL", "ICON_DLG_BALL" );
3740 createSMESHAction( 4010, "EDGE", "ICON_DLG_EDGE" );
3741 createSMESHAction( 4021, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3742 createSMESHAction( 4022, "QUAD", "ICON_DLG_QUADRANGLE" );
3743 createSMESHAction( 4023, "POLYGON", "ICON_DLG_POLYGON" );
3744 createSMESHAction( 4031, "TETRA", "ICON_DLG_TETRAS" );
3745 createSMESHAction( 4032, "HEXA", "ICON_DLG_HEXAS" );
3746 createSMESHAction( 4133, "PENTA", "ICON_DLG_PENTA" );
3747 createSMESHAction( 4134, "PYRAMID", "ICON_DLG_PYRAMID" );
3748 createSMESHAction( 4135, "OCTA", "ICON_DLG_OCTA" );
3749 createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3750 createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3751 createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3752 createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3753 createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3754 createSMESHAction( 4137, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3755 createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3756 createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3757 createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3758 createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3759 createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3760 createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3761 createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3762 createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3763 createSMESHAction( 4043, "CLEAR_MESH" , "ICON_CLEAR_MESH" );
3764 createSMESHAction( 4051, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3765 createSMESHAction( 4052, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3766 createSMESHAction( 4061, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3767 createSMESHAction( 4062, "ROT", "ICON_DLG_MESH_ROTATION" );
3768 createSMESHAction( 4063, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3769 createSMESHAction( 4064, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3770 createSMESHAction( 4065, "MERGE", "ICON_SMESH_MERGE_NODES" );
3771 createSMESHAction( 4066, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3772 createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3773 createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" );
3774 createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3775 createSMESHAction( 4070, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3776 createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" );
3777 createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" );
3778 createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3779 createSMESHAction( 410, "UNION", "ICON_UNIONTRI" );
3780 createSMESHAction( 411, "CUT", "ICON_CUTQUAD" );
3781 createSMESHAction( 412, "SMOOTH", "ICON_DLG_SMOOTHING" );
3782 createSMESHAction( 413, "EXTRUSION", "ICON_EXTRUSION" );
3783 createSMESHAction( 414, "REVOLUTION", "ICON_REVOLUTION" );
3784 createSMESHAction( 415, "MAP", "ICON_MAP" );
3785 createSMESHAction( 416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3786 createSMESHAction( 417, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3787 createSMESHAction( 418, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3788 createSMESHAction( 419, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3789 createSMESHAction( 420, "REORIENT_2D", "ICON_REORIENT_2D" );
3790 createSMESHAction( 200, "RESET" );
3791 createSMESHAction( 201, "SCALAR_BAR_PROP" );
3792 createSMESHAction( 2021, "SAVE_DISTRIBUTION" );
3793 createSMESHAction( 2022, "SHOW_DISTRIBUTION","",0, true );
3794 #ifndef DISABLE_PLOT2DVIEWER
3795 createSMESHAction( 2023, "PLOT_DISTRIBUTION" );
3797 createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true );
3798 createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true );
3799 createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true );
3800 createSMESHAction( 214, "UPDATE", "ICON_UPDATE" );
3801 createSMESHAction( 215, "NODES", "ICON_POINTS", 0, true );
3802 createSMESHAction( 222, "BALLS", "ICON_DLG_BALL", 0, true );
3803 createSMESHAction( 216, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3804 createSMESHAction( 217, "EDGES", "ICON_DLG_EDGE", 0, true );
3805 createSMESHAction( 218, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3806 createSMESHAction( 219, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3807 createSMESHAction( 220, "ALL" );
3808 createSMESHAction( 221, "FACE_ORIENTATION", "", 0, true );
3810 createSMESHAction( 231, "LINE_REPRESENTATION", "", 0, true );
3811 createSMESHAction( 232, "ARC_REPRESENTATION", "", 0, true );
3813 createSMESHAction( 1100, "EDIT_HYPO" );
3814 createSMESHAction( 1102, "UNASSIGN" );
3815 createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3816 createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3817 createSMESHAction( 1131, "DISPMODE" );
3818 createSMESHAction( 1132, "COLORS" );
3819 createSMESHAction( 1133, "TRANSP" );
3820 createSMESHAction( 1134, "CLIP" );
3821 createSMESHAction( 1135, "DISP_ENT" );
3822 createSMESHAction( 1136, "AUTO_COLOR" );
3823 createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3824 createSMESHAction( 2000, "CTRL" );
3826 createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3827 createSMESHAction( 502, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3829 createSMESHAction( 300, "HIDE" );
3830 createSMESHAction( 301, "SHOW" );
3831 createSMESHAction( 302, "DISPLAY_ONLY" );
3833 // ----- create menu --------------
3834 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3835 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3836 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3837 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3838 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3839 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3840 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3841 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3843 createMenu( separator(), fileId );
3845 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3846 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3847 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3848 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3849 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3850 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3851 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3852 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3853 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3854 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3856 //createMenu( 111, importId, -1 );
3857 createMenu( 112, importId, -1 );
3858 createMenu( 113, importId, -1 );
3859 createMenu( 115, importId, -1 );
3861 createMenu( 116, importId, -1 );
3863 createMenu( 117, importId, -1 );
3864 createMenu( 118, importId, -1 );
3865 createMenu( 121, exportId, -1 );
3866 createMenu( 122, exportId, -1 );
3867 createMenu( 123, exportId, -1 );
3868 createMenu( 140, exportId, -1 ); // export to STL
3870 createMenu( 142, exportId, -1 ); // export to CGNS
3872 createMenu( 144, exportId, -1 ); // export to SAUV
3873 createMenu( 146, exportId, -1 ); // export to GMF
3874 createMenu( separator(), fileId, 10 );
3876 createMenu( 33, editId, -1 );
3878 createMenu( 5105, toolsId, -1 );
3880 createMenu( 702, meshId, -1 ); // "Mesh" menu
3881 createMenu( 703, meshId, -1 );
3882 createMenu( 704, meshId, -1 );
3883 createMenu( 710, meshId, -1 );
3884 createMenu( 705, meshId, -1 );
3885 createMenu( separator(), meshId, -1 );
3886 createMenu( 701, meshId, -1 );
3887 createMenu( 711, meshId, -1 );
3888 createMenu( 712, meshId, -1 );
3889 createMenu( 713, meshId, -1 );
3890 createMenu( separator(), meshId, -1 );
3891 createMenu( 801, meshId, -1 );
3892 createMenu( 806, meshId, -1 );
3893 createMenu( 802, meshId, -1 );
3894 createMenu( 803, meshId, -1 );
3895 createMenu( 815, meshId, -1 );
3896 createMenu( separator(), meshId, -1 );
3897 createMenu( 810, meshId, -1 );
3898 createMenu( 811, meshId, -1 );
3899 createMenu( 812, meshId, -1 );
3900 createMenu( separator(), meshId, -1 );
3901 createMenu( 814, meshId, -1 );
3902 createMenu( separator(), meshId, -1 );
3903 createMenu( 900, meshId, -1 );
3904 //createMenu( 902, meshId, -1 );
3905 //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3906 createMenu( 904, meshId, -1 );
3907 createMenu( separator(), meshId, -1 );
3909 createMenu( 6005, nodeId, -1 );
3910 createMenu( 6028, nodeId, -1 );
3911 createMenu( 6002, edgeId, -1 );
3912 createMenu( 6003, edgeId, -1 );
3913 createMenu( 6001, edgeId, -1 );
3914 createMenu( 6004, edgeId, -1 );
3915 createMenu( 6029, edgeId, -1 );
3916 createMenu( 6021, faceId, -1 );
3917 createMenu( 6025, faceId, -1 );
3918 createMenu( 6027, faceId, -1 );
3919 createMenu( 6018, faceId, -1 );
3920 createMenu( 6019, faceId, -1 );
3921 createMenu( 6011, faceId, -1 );
3922 createMenu( 6012, faceId, -1 );
3923 createMenu( 6013, faceId, -1 );
3924 createMenu( 6014, faceId, -1 );
3925 createMenu( 6015, faceId, -1 );
3926 createMenu( 6016, faceId, -1 );
3927 createMenu( 6022, faceId, -1 );
3928 createMenu( 6030, faceId, -1 );
3929 createMenu( 6017, volumeId, -1 );
3930 createMenu( 6009, volumeId, -1 );
3931 createMenu( 6023, volumeId, -1 );
3932 createMenu( 6024, volumeId, -1 );
3933 createMenu( 6026, volumeId, -1 );
3934 createMenu( 6031, volumeId, -1 );
3935 createMenu( separator(), ctrlId, -1 );
3936 createMenu( 6032, ctrlId, -1 );
3938 createMenu( 4000, addId, -1 );
3939 createMenu( 4009, addId, -1 );
3940 createMenu( 4070, addId, -1 );
3941 createMenu( 4008, addId, -1 );
3942 createMenu( 4010, addId, -1 );
3943 createMenu( 4021, addId, -1 );
3944 createMenu( 4022, addId, -1 );
3945 createMenu( 4023, addId, -1 );
3946 createMenu( 4031, addId, -1 );
3947 createMenu( 4032, addId, -1 );
3948 createMenu( 4133, addId, -1 );
3949 createMenu( 4134, addId, -1 );
3950 createMenu( 4135, addId, -1 );
3951 createMenu( 4033, addId, -1 );
3952 createMenu( separator(), addId, -1 );
3953 createMenu( 4034, addId, -1 );
3954 createMenu( 4035, addId, -1 );
3955 createMenu( 4137, addId, -1 );
3956 createMenu( 4036, addId, -1 );
3957 createMenu( 4136, addId, -1 );
3958 createMenu( 4037, addId, -1 );
3959 createMenu( 4038, addId, -1 );
3960 createMenu( 4039, addId, -1 );
3961 createMenu( 4040, addId, -1 );
3962 createMenu( 4140, addId, -1 );
3964 createMenu( 4041, removeId, -1 );
3965 createMenu( 4042, removeId, -1 );
3966 createMenu( 4044, removeId, -1 );
3967 createMenu( separator(), removeId, -1 );
3968 createMenu( 813, removeId, -1 );
3969 createMenu( separator(), removeId, -1 );
3970 createMenu( 4043, removeId, -1 );
3972 createMenu( 4051, renumId, -1 );
3973 createMenu( 4052, renumId, -1 );
3975 createMenu( 4061, transfId, -1 );
3976 createMenu( 4062, transfId, -1 );
3977 createMenu( 4063, transfId, -1 );
3978 createMenu( 4068, transfId, -1 );
3979 createMenu( 4064, transfId, -1 );
3980 createMenu( 4065, transfId, -1 );
3981 createMenu( 4066, transfId, -1 );
3982 createMenu( 4069, transfId, -1 );
3984 createMenu( 4067,modifyId, -1 );
3985 createMenu( 407, modifyId, -1 );
3986 createMenu( 408, modifyId, -1 );
3987 createMenu( 409, modifyId, -1 );
3988 createMenu( 420, modifyId, -1 );
3989 createMenu( 410, modifyId, -1 );
3990 createMenu( 411, modifyId, -1 );
3991 createMenu( 419, modifyId, -1 );
3992 createMenu( 412, modifyId, -1 );
3993 createMenu( 413, modifyId, -1 );
3994 createMenu( 416, modifyId, -1 );
3995 createMenu( 414, modifyId, -1 );
3996 createMenu( 415, modifyId, -1 );
3997 createMenu( 417, modifyId, -1 );
3998 createMenu( 418, modifyId, -1 );
4000 createMenu( 501, measureId, -1 );
4001 createMenu( 502, measureId, -1 );
4002 createMenu( 214, viewId, -1 );
4004 // ----- create toolbars --------------
4005 int meshTb = createTool( tr( "TB_MESH" ) ),
4006 ctrlTb = createTool( tr( "TB_CTRL" ) ),
4007 addRemTb = createTool( tr( "TB_ADD_REMOVE" ) ),
4008 modifyTb = createTool( tr( "TB_MODIFY" ) ),
4009 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
4011 createTool( 702, meshTb );
4012 createTool( 703, meshTb );
4013 createTool( 704, meshTb );
4014 createTool( 710, meshTb );
4015 createTool( 705, meshTb );
4016 createTool( separator(), meshTb );
4017 createTool( 701, meshTb );
4018 createTool( 711, meshTb );
4019 createTool( 712, meshTb );
4020 createTool( 713, meshTb );
4021 createTool( separator(), meshTb );
4022 createTool( 801, meshTb );
4023 createTool( 806, meshTb );
4024 createTool( 802, meshTb );
4025 createTool( 803, meshTb );
4026 //createTool( 815, meshTb );
4027 createTool( separator(), meshTb );
4028 createTool( 900, meshTb );
4029 //createTool( 902, meshTb );
4030 //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4031 createTool( 904, meshTb );
4032 createTool( separator(), meshTb );
4034 createTool( 6005, ctrlTb );
4035 createTool( 6028, ctrlTb );
4036 createTool( separator(), ctrlTb );
4037 createTool( 6002, ctrlTb );
4038 createTool( 6003, ctrlTb );
4039 createTool( 6001, ctrlTb );
4040 createTool( 6004, ctrlTb );
4041 createTool( 6029, ctrlTb );
4042 createTool( separator(), ctrlTb );
4043 createTool( 6021, ctrlTb );
4044 createTool( 6025, ctrlTb );
4045 createTool( 6027, ctrlTb );
4046 createTool( 6018, ctrlTb );
4047 createTool( 6019, ctrlTb );
4048 createTool( 6011, ctrlTb );
4049 createTool( 6012, ctrlTb );
4050 createTool( 6013, ctrlTb );
4051 createTool( 6014, ctrlTb );
4052 createTool( 6015, ctrlTb );
4053 createTool( 6016, ctrlTb );
4054 createTool( 6022, ctrlTb );
4055 createTool( 6030, ctrlTb );
4056 createTool( separator(), ctrlTb );
4057 createTool( 6017, ctrlTb );
4058 createTool( 6009, ctrlTb );
4059 createTool( 6023, ctrlTb );
4060 createTool( 6024, ctrlTb );
4061 createTool( 6026, ctrlTb );
4062 createTool( 6031, ctrlTb );
4063 createTool( separator(), ctrlTb );
4065 createTool( 4000, addRemTb );
4066 createTool( 4009, addRemTb );
4067 createTool( 4070, addRemTb );
4068 createTool( 4008, addRemTb );
4069 createTool( 4010, addRemTb );
4070 createTool( 4021, addRemTb );
4071 createTool( 4022, addRemTb );
4072 createTool( 4023, addRemTb );
4073 createTool( 4031, addRemTb );
4074 createTool( 4032, addRemTb );
4075 createTool( 4133, addRemTb );
4076 createTool( 4134, addRemTb );
4077 createTool( 4135, addRemTb );
4078 createTool( 4033, addRemTb );
4079 createTool( separator(), addRemTb );
4080 createTool( 4034, addRemTb );
4081 createTool( 4035, addRemTb );
4082 createTool( 4137, addRemTb );
4083 createTool( 4036, addRemTb );
4084 createTool( 4136, addRemTb );
4085 createTool( 4037, addRemTb );
4086 createTool( 4038, addRemTb );
4087 createTool( 4039, addRemTb );
4088 createTool( 4040, addRemTb );
4089 createTool( 4140, addRemTb );
4090 createTool( separator(), addRemTb );
4091 createTool( 4041, addRemTb );
4092 createTool( 4042, addRemTb );
4093 createTool( 4044, addRemTb );
4094 createTool( 4043, addRemTb );
4095 createTool( separator(), addRemTb );
4096 createTool( 4051, addRemTb );
4097 createTool( 4052, addRemTb );
4098 createTool( separator(), addRemTb );
4099 createTool( 4061, addRemTb );
4100 createTool( 4062, addRemTb );
4101 createTool( 4063, addRemTb );
4102 createTool( 4068, addRemTb );
4103 createTool( 4064, addRemTb );
4104 createTool( 4065, addRemTb );
4105 createTool( 4066, addRemTb );
4106 createTool( 4069, addRemTb );
4107 createTool( separator(), addRemTb );
4109 createTool( 4067,modifyTb );
4110 createTool( 407, modifyTb );
4111 createTool( 408, modifyTb );
4112 createTool( 409, modifyTb );
4113 createTool( 420, modifyTb );
4114 createTool( 410, modifyTb );
4115 createTool( 411, modifyTb );
4116 createTool( 419, modifyTb );
4117 createTool( 412, modifyTb );
4118 createTool( 413, modifyTb );
4119 createTool( 416, modifyTb );
4120 createTool( 414, modifyTb );
4121 createTool( 415, modifyTb );
4122 createTool( 417, modifyTb );
4123 createTool( 418, modifyTb );
4125 createTool( 214, dispModeTb );
4127 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4128 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4131 QString OB = "'ObjectBrowser'",
4132 View = "'" + SVTK_Viewer::Type() + "'",
4134 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4135 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4136 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4137 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4138 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4139 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4140 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4141 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4142 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4143 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4144 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4146 mesh_part = mesh + " " + subMesh + " " + group,
4147 mesh_group = mesh + " " + group,
4148 hyp_alg = hypo + " " + algo;
4150 // popup for object browser
4152 isInvisible("not( isVisible )"),
4153 isEmpty("numberOfNodes = 0"),
4154 isNotEmpty("numberOfNodes <> 0"),
4156 // has nodes, edges, etc in VISIBLE! actor
4157 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4158 hasElems("(count( elemTypes ) > 0)"),
4159 hasDifferentElems("(count( elemTypes ) > 1)"),
4160 hasBalls("({'BallElem'} in elemTypes)"),
4161 hasElems0d("({'Elem0d'} in elemTypes)"),
4162 hasEdges("({'Edge'} in elemTypes)"),
4163 hasFaces("({'Face'} in elemTypes)"),
4164 hasVolumes("({'Volume'} in elemTypes)");
4166 createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
4167 createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
4168 createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
4169 createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
4170 createPopupItem( 803, OB, group ); // EDIT_GROUP
4171 createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
4173 popupMgr()->insert( separator(), -1, 0 );
4174 createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
4175 createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
4176 createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
4177 createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
4178 createPopupItem( 214, OB, mesh_part ); // UPDATE
4179 createPopupItem( 900, OB, mesh_part ); // ADV_INFO
4180 createPopupItem( 904, OB, mesh_group ); // FIND_ELEM
4181 createPopupItem( 6032, OB, mesh_part ); // CTRL_INFO
4182 popupMgr()->insert( separator(), -1, 0 );
4183 createPopupItem( 801, OB, mesh ); // CREATE_GROUP
4184 createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
4185 createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
4186 popupMgr()->insert( separator(), -1, 0 );
4187 createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
4188 createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4189 popupMgr()->insert( separator(), -1, 0 );
4190 createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
4191 popupMgr()->insert( separator(), -1, 0 );
4192 createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
4193 createPopupItem( 418, OB, mesh + " " + group, // create 2D mesh from 3D
4195 popupMgr()->insert( separator(), -1, 0 );
4197 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4198 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4199 QString only_one_2D = only_one_non_empty + " && dim>1";
4201 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4202 createPopupItem( 125, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_MED
4203 createPopupItem( 126, OB, mesh_group, only_one_non_empty, anId ); // EXPORT_UNV
4204 createPopupItem( 141, OB, mesh_group, only_one_2D, anId ); // EXPORT_STL
4206 createPopupItem( 143, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_CGNS
4208 createPopupItem( 145, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_SAUV
4209 createPopupItem( 147, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_GMF
4210 createPopupItem( 124, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_DAT
4211 createPopupItem( 33, OB, mesh_part + " " + hyp_alg ); // DELETE
4212 createPopupItem( 813, OB, group ); // DEL_GROUP with contents
4213 popupMgr()->insert( separator(), -1, 0 );
4216 createPopupItem( 803, View, group ); // EDIT_GROUP
4217 createPopupItem( 804, View, elems ); // ADD
4218 createPopupItem( 805, View, elems ); // REMOVE
4220 popupMgr()->insert( separator(), -1, 0 );
4221 createPopupItem( 214, View, mesh_part ); // UPDATE
4222 createPopupItem( 900, View, mesh_part ); // ADV_INFO
4223 createPopupItem( 904, View, mesh ); // FIND_ELEM
4224 popupMgr()->insert( separator(), -1, 0 );
4226 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
4227 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
4228 popupMgr()->insert( separator(), -1, 0 );
4230 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4231 QString aType = QString( "%1type in {%2}" ).arg( lc );
4232 aType = aType.arg( mesh_part );
4233 QString aMeshInVTK = aClient + "&&" + aType;
4235 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4236 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4237 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4239 //-------------------------------------------------
4241 //-------------------------------------------------
4242 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4244 popupMgr()->insert( action( 9010 ), anId, -1 );
4245 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4246 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4248 popupMgr()->insert( action( 9011 ), anId, -1 );
4249 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4250 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4252 popupMgr()->insert( separator(), -1, -1 );
4254 //-------------------------------------------------
4256 //-------------------------------------------------
4257 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4259 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4260 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4261 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4263 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4264 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4265 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4267 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4268 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4269 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4271 popupMgr()->insert( separator(), anId, -1 );
4273 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4274 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4275 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4277 //-------------------------------------------------
4279 //-------------------------------------------------
4280 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4282 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4284 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4285 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4286 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4288 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4289 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4290 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4292 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4293 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4294 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4296 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4297 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4298 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4300 popupMgr()->insert( action( 222 ), anId, -1 ); // BALLS
4301 popupMgr()->setRule( action( 222 ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4302 popupMgr()->setRule( action( 222 ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4304 popupMgr()->insert( separator(), anId, -1 );
4306 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4307 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4310 //-------------------------------------------------
4311 // Representation of the 2D Quadratic elements
4312 //-------------------------------------------------
4313 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4314 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4315 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4316 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4318 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4319 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4320 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4322 //-------------------------------------------------
4323 // Orientation of faces
4324 //-------------------------------------------------
4325 popupMgr()->insert( action( 221 ), -1, -1 );
4326 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4327 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4329 //-------------------------------------------------
4331 //-------------------------------------------------
4332 popupMgr()->insert( action( 1132 ), -1, -1 );
4333 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4335 //-------------------------------------------------
4337 //-------------------------------------------------
4338 popupMgr()->insert( action( 1133 ), -1, -1 );
4339 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4341 //-------------------------------------------------
4343 //-------------------------------------------------
4345 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4346 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4347 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4348 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4350 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4352 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4353 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4355 popupMgr()->insert( separator(), anId, -1 );
4357 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4359 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4360 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4361 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4363 popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4364 popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4365 popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4367 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4369 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4370 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4371 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4373 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4374 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4375 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4377 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4378 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4379 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4381 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4382 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4383 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4384 popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4385 popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4386 popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4388 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4390 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4391 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4392 QtxPopupMgr::VisibleRule );
4393 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4395 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4396 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4397 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4399 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4400 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4401 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4403 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4404 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4405 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4407 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4408 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4409 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4411 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4412 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4413 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4415 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4416 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4417 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4419 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4420 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4421 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4423 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4424 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4425 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4427 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4428 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4429 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4431 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4432 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4433 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4435 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4436 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4437 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4438 popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4439 popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4440 popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4442 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4444 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4445 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4446 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4448 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4449 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4450 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4452 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4453 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4454 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4456 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4457 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4458 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4460 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4461 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4462 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4464 popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4465 popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4466 popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4468 popupMgr()->insert( separator(), anId, -1 );
4470 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4471 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4473 popupMgr()->insert( separator(), anId, -1 );
4475 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4477 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4478 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4480 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4481 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4482 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4484 #ifndef DISABLE_PLOT2DVIEWER
4485 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4486 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4489 //-------------------------------------------------
4491 //-------------------------------------------------
4492 popupMgr()->insert( separator(), -1, -1 );
4493 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4494 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4495 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4496 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4498 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4499 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4501 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4502 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4504 popupMgr()->insert( separator(), -1, -1 );
4506 //-------------------------------------------------
4508 //-------------------------------------------------
4509 popupMgr()->insert( action( 1134 ), -1, -1 );
4510 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4512 popupMgr()->insert( separator(), -1, -1 );
4514 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4515 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4517 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4518 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4521 //================================================================================
4523 * \brief Return true if SMESH or GEOM objects are selected.
4524 * Is called form LightApp_Module::activateModule() which clear selection if
4525 * not isSelectionCompatible()
4527 //================================================================================
4529 bool SMESHGUI::isSelectionCompatible()
4531 bool isCompatible = true;
4532 SALOME_ListIO selected;
4533 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4534 Sel->selectedObjects( selected );
4536 SALOME_ListIteratorOfListIO It( selected );
4537 for ( ; isCompatible && It.More(); It.Next())
4539 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4540 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4542 return isCompatible;
4546 bool SMESHGUI::reusableOperation( const int id )
4548 // compute, evaluate and precompute are not reusable operations
4549 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4552 bool SMESHGUI::activateModule( SUIT_Study* study )
4554 bool res = SalomeApp_Module::activateModule( study );
4556 setMenuShown( true );
4557 setToolShown( true );
4559 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4560 PyGILState_STATE gstate = PyGILState_Ensure();
4561 PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4562 if(pluginsmanager==NULL)
4566 PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4571 PyGILState_Release(gstate);
4572 // end of GEOM plugins loading
4574 // Reset actions accelerator keys
4575 //action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4576 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4577 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4579 action( 33)->setEnabled(true); // Delete: Key_Delete
4581 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4582 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4583 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4584 if ( _PTR(Study) aStudy = s->studyDS()) {
4585 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4586 updateObjBrowser(); // objects can be removed
4589 // get all view currently opened in the study and connect their signals to
4590 // the corresponding slots of the class.
4591 SUIT_Desktop* aDesk = study->application()->desktop();
4593 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4594 SUIT_ViewWindow* wnd;
4595 foreach ( wnd, wndList )
4602 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4604 setMenuShown( false );
4605 setToolShown( false );
4607 EmitSignalCloseAllDialogs();
4609 // Unset actions accelerator keys
4610 //action(111)->setShortcut(QKeySequence()); // Import DAT
4611 action(112)->setShortcut(QKeySequence()); // Import UNV
4612 action(113)->setShortcut(QKeySequence()); // Import MED
4614 action( 33)->setEnabled(false); // Delete: Key_Delete
4616 return SalomeApp_Module::deactivateModule( study );
4619 void SMESHGUI::studyClosed( SUIT_Study* s )
4621 SMESH::RemoveVisuData( s->id() );
4622 SalomeApp_Module::studyClosed( s );
4625 void SMESHGUI::OnGUIEvent()
4627 const QObject* obj = sender();
4628 if ( !obj || !obj->inherits( "QAction" ) )
4630 int id = actionId((QAction*)obj);
4635 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4637 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4638 if ( CORBA::is_nil( myComponentSMESH ) )
4640 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4642 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4643 return aGUI.myComponentSMESH;
4646 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4647 return myComponentSMESH;
4650 QString SMESHGUI::engineIOR() const
4652 CORBA::ORB_var anORB = getApp()->orb();
4653 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4654 return QString( anIOR.in() );
4657 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4659 SalomeApp_Module::contextMenuPopup( client, menu, title );
4661 selectionMgr()->selectedObjects( lst );
4662 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4663 Handle(SALOME_InteractiveObject) io = lst.First();
4664 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4665 _PTR(Study) study = appStudy->studyDS();
4666 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4668 QString aName = QString( obj->GetName().c_str() );
4669 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4670 aName.remove( (aName.length() - 1), 1 );
4676 LightApp_Selection* SMESHGUI::createSelection() const
4678 return new SMESHGUI_Selection();
4681 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4683 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4684 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4687 void SMESHGUI::viewManagers( QStringList& list ) const
4689 list.append( SVTK_Viewer::Type() );
4692 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4694 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4695 SMESH::UpdateSelectionProp( this );
4697 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4698 for(int i = 0; i < aViews.count() ; i++){
4699 SUIT_ViewWindow *sf = aViews[i];
4705 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4707 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4708 myClippingPlaneInfoMap.erase( theViewManager );
4711 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4713 theActor->AddObserver( SMESH::DeleteActorEvent,
4714 myEventCallbackCommand.GetPointer(),
4718 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4719 unsigned long theEvent,
4720 void* theClientData,
4723 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4724 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4725 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4726 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4727 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4728 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4729 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4730 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4731 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4732 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4733 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4734 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4735 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4736 if( anActor == *anIter3 ) {
4737 anActorList.erase( anIter3 );
4748 void SMESHGUI::createPreferences()
4750 // General tab ------------------------------------------------------------------------
4751 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4753 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4754 setPreferenceProperty( autoUpdate, "columns", 2 );
4755 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4756 setPreferenceProperty( lim, "min", 0 );
4757 setPreferenceProperty( lim, "max", 100000000 );
4758 setPreferenceProperty( lim, "step", 1000 );
4759 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4760 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4762 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4763 setPreferenceProperty( qaGroup, "columns", 2 );
4764 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4765 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4766 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4767 setPreferenceProperty( prec, "min", 0 );
4768 setPreferenceProperty( prec, "max", 16 );
4769 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4770 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4771 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4772 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4773 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4775 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4776 setPreferenceProperty( dispgroup, "columns", 2 );
4777 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4779 modes.append( tr("MEN_WIRE") );
4780 modes.append( tr("MEN_SHADE") );
4781 modes.append( tr("MEN_NODES") );
4782 modes.append( tr("MEN_SHRINK") );
4783 QList<QVariant> indices;
4784 indices.append( 0 );
4785 indices.append( 1 );
4786 indices.append( 2 );
4787 indices.append( 3 );
4788 setPreferenceProperty( dispmode, "strings", modes );
4789 setPreferenceProperty( dispmode, "indexes", indices );
4791 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4792 setPreferenceProperty( arcgroup, "columns", 2 );
4793 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4794 QStringList quadraticModes;
4795 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4796 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4798 indices.append( 0 );
4799 indices.append( 1 );
4800 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4801 setPreferenceProperty( quadraticmode, "indexes", indices );
4803 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4804 "SMESH", "max_angle" );
4805 setPreferenceProperty( maxAngle, "min", 1 );
4806 setPreferenceProperty( maxAngle, "max", 90 );
4810 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4811 setPreferenceProperty( exportgroup, "columns", 2 );
4812 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4813 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4815 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4816 setPreferenceProperty( computeGroup, "columns", 2 );
4817 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4819 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4820 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4821 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4823 indices.append( 0 );
4824 indices.append( 1 );
4825 indices.append( 2 );
4826 setPreferenceProperty( notifyMode, "strings", modes );
4827 setPreferenceProperty( notifyMode, "indexes", indices );
4829 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4830 setPreferenceProperty( infoGroup, "columns", 2 );
4831 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4833 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4834 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4836 indices.append( 0 );
4837 indices.append( 1 );
4838 setPreferenceProperty( elemInfo, "strings", modes );
4839 setPreferenceProperty( elemInfo, "indexes", indices );
4840 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4841 setPreferenceProperty( nodesLim, "min", 0 );
4842 setPreferenceProperty( nodesLim, "max", 10000000 );
4843 setPreferenceProperty( nodesLim, "step", 10000 );
4844 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4845 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
4846 setPreferenceProperty( ctrlLim, "min", 0 );
4847 setPreferenceProperty( ctrlLim, "max", 10000000 );
4848 setPreferenceProperty( ctrlLim, "step", 1000 );
4849 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
4850 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
4851 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
4852 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
4853 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
4855 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4856 setPreferenceProperty( segGroup, "columns", 2 );
4857 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4858 "SMESH", "segmentation" );
4859 setPreferenceProperty( segLen, "min", 1 );
4860 setPreferenceProperty( segLen, "max", 10000000 );
4861 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4862 "SMESH", "nb_segments_per_edge" );
4863 setPreferenceProperty( nbSeg, "min", 1 );
4864 setPreferenceProperty( nbSeg, "max", 10000000 );
4866 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4867 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4868 "SMESH", "forget_mesh_on_hyp_modif" );
4871 // Quantities with individual precision settings
4872 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4873 setPreferenceProperty( precGroup, "columns", 2 );
4875 const int nbQuantities = 6;
4876 int precs[nbQuantities], ii = 0;
4877 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4878 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4879 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4880 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4881 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4882 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4883 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4884 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4885 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4886 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4887 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4888 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4890 // Set property for precision value for spinboxes
4891 for ( ii = 0; ii < nbQuantities; ii++ ){
4892 setPreferenceProperty( precs[ii], "min", -14 );
4893 setPreferenceProperty( precs[ii], "max", 14 );
4894 setPreferenceProperty( precs[ii], "precision", 2 );
4897 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4898 setPreferenceProperty( previewGroup, "columns", 2 );
4899 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4900 setPreferenceProperty( chunkSize, "min", 1 );
4901 setPreferenceProperty( chunkSize, "max", 1000 );
4902 setPreferenceProperty( chunkSize, "step", 50 );
4904 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4905 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4907 // Mesh tab ------------------------------------------------------------------------
4908 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4909 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4910 setPreferenceProperty( nodeGroup, "columns", 3 );
4912 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4914 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4916 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4917 QList<QVariant> aMarkerTypeIndicesList;
4918 QList<QVariant> aMarkerTypeIconsList;
4919 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4920 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4921 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4922 aMarkerTypeIndicesList << i;
4923 aMarkerTypeIconsList << pixmap;
4925 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4926 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4928 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4930 QList<QVariant> aMarkerScaleIndicesList;
4931 QStringList aMarkerScaleValuesList;
4932 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4933 aMarkerScaleIndicesList << i;
4934 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4936 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4937 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4939 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4940 //setPreferenceProperty( elemGroup, "columns", 2 );
4942 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4943 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4944 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
4945 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
4946 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4947 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
4948 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4949 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4952 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4953 setPreferenceProperty( grpGroup, "columns", 2 );
4955 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4956 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
4958 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4959 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4960 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
4961 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
4962 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4963 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4964 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
4965 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
4966 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4967 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4969 setPreferenceProperty( size0d, "min", 1 );
4970 setPreferenceProperty( size0d, "max", 10 );
4972 setPreferenceProperty( ballSize, "min", 1 );
4973 setPreferenceProperty( ballSize, "max", 10 );
4975 setPreferenceProperty( elemW, "min", 1 );
4976 setPreferenceProperty( elemW, "max", 5 );
4978 setPreferenceProperty( outW, "min", 1 );
4979 setPreferenceProperty( outW, "max", 5 );
4981 setPreferenceProperty( shrink, "min", 0 );
4982 setPreferenceProperty( shrink, "max", 100 );
4984 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
4985 setPreferenceProperty( numGroup, "columns", 2 );
4987 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
4988 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
4990 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
4991 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
4993 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4994 setPreferenceProperty( orientGroup, "columns", 1 );
4996 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4997 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4999 setPreferenceProperty( orientScale, "min", 0.05 );
5000 setPreferenceProperty( orientScale, "max", 0.5 );
5001 setPreferenceProperty( orientScale, "step", 0.05 );
5003 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5005 // Selection tab ------------------------------------------------------------------------
5006 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5008 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5009 setPreferenceProperty( selGroup, "columns", 2 );
5011 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5012 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5014 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5015 setPreferenceProperty( preGroup, "columns", 2 );
5017 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5019 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5020 setPreferenceProperty( precSelGroup, "columns", 2 );
5022 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5023 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5024 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5026 // Scalar Bar tab ------------------------------------------------------------------------
5027 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5028 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5029 setPreferenceProperty( fontGr, "columns", 2 );
5031 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5032 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5034 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5035 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5037 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5038 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5040 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5041 setPreferenceProperty( numcol, "min", 2 );
5042 setPreferenceProperty( numcol, "max", 256 );
5044 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5045 setPreferenceProperty( numlab, "min", 2 );
5046 setPreferenceProperty( numlab, "max", 65 );
5048 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5049 setPreferenceProperty( orientGr, "columns", 2 );
5050 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5051 QStringList orients;
5052 orients.append( tr( "SMESH_VERTICAL" ) );
5053 orients.append( tr( "SMESH_HORIZONTAL" ) );
5054 indices.clear(); indices.append( 0 ); indices.append( 1 );
5055 setPreferenceProperty( orient, "strings", orients );
5056 setPreferenceProperty( orient, "indexes", indices );
5058 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5059 setPreferenceProperty( posVSizeGr, "columns", 2 );
5060 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5061 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5062 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5063 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5064 setPreferenceProperty( xv, "step", 0.1 );
5065 setPreferenceProperty( xv, "min", 0.0 );
5066 setPreferenceProperty( xv, "max", 1.0 );
5067 setPreferenceProperty( yv, "step", 0.1 );
5068 setPreferenceProperty( yv, "min", 0.0 );
5069 setPreferenceProperty( yv, "max", 1.0 );
5070 setPreferenceProperty( wv, "step", 0.1 );
5071 setPreferenceProperty( wv, "min", 0.0 );
5072 setPreferenceProperty( wv, "max", 1.0 );
5073 setPreferenceProperty( hv, "min", 0.0 );
5074 setPreferenceProperty( hv, "max", 1.0 );
5075 setPreferenceProperty( hv, "step", 0.1 );
5077 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5078 setPreferenceProperty( posHSizeGr, "columns", 2 );
5079 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5080 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5081 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5082 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5083 setPreferenceProperty( xv, "min", 0.0 );
5084 setPreferenceProperty( xv, "max", 1.0 );
5085 setPreferenceProperty( xv, "step", 0.1 );
5086 setPreferenceProperty( xh, "min", 0.0 );
5087 setPreferenceProperty( xh, "max", 1.0 );
5088 setPreferenceProperty( xh, "step", 0.1 );
5089 setPreferenceProperty( yh, "min", 0.0 );
5090 setPreferenceProperty( yh, "max", 1.0 );
5091 setPreferenceProperty( yh, "step", 0.1 );
5092 setPreferenceProperty( wh, "min", 0.0 );
5093 setPreferenceProperty( wh, "max", 1.0 );
5094 setPreferenceProperty( wh, "step", 0.1 );
5095 setPreferenceProperty( hh, "min", 0.0 );
5096 setPreferenceProperty( hh, "max", 1.0 );
5097 setPreferenceProperty( hh, "step", 0.1 );
5099 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5100 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5101 setPreferenceProperty( distributionGr, "columns", 3 );
5103 types.append( tr( "SMESH_MONOCOLOR" ) );
5104 types.append( tr( "SMESH_MULTICOLOR" ) );
5105 indices.clear(); indices.append( 0 ); indices.append( 1 );
5106 setPreferenceProperty( coloringType, "strings", types );
5107 setPreferenceProperty( coloringType, "indexes", indices );
5108 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5112 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5114 if( sect=="SMESH" ) {
5115 float sbX1,sbY1,sbW,sbH;
5116 float aTol = 1.00000009999999;
5117 std::string aWarning;
5118 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5119 if( name=="selection_object_color" || name=="selection_element_color" ||
5120 name=="highlight_color" ||
5121 name=="selection_precision_node" || name=="selection_precision_element" ||
5122 name=="selection_precision_object")
5123 SMESH::UpdateSelectionProp( this );
5124 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5125 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5126 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5127 if(sbX1+sbW > aTol){
5128 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5131 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5132 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5135 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5136 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5137 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5138 if(sbY1+sbH > aTol){
5139 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5140 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5141 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5144 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5145 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5146 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5147 if(sbX1+sbW > aTol){
5148 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5151 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5152 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5155 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5156 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5157 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5158 if(sbY1+sbH > aTol){
5159 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5162 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5163 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5166 else if ( name == "segmentation" ) {
5167 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5168 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5170 else if ( name == "nb_segments_per_edge" ) {
5171 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5172 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5174 else if ( name == "historical_python_dump" ||
5175 name == "forget_mesh_on_hyp_modif") {
5176 QString val = aResourceMgr->stringValue( "SMESH", name );
5177 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5179 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5180 SMESH::UpdateFontProp( this );
5182 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5183 SMESH::UpdateFontProp( this );
5186 if(aWarning.size() != 0){
5187 aWarning += "The default values are applied instead.";
5188 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5189 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5190 QObject::tr(aWarning.c_str()));
5195 //================================================================================
5197 * \brief Update something in accordance with update flags
5198 * \param theFlags - update flags
5200 * Update viewer or/and object browser etc. in accordance with update flags ( see
5201 * LightApp_UpdateFlags enumeration ).
5203 //================================================================================
5204 void SMESHGUI::update( const int flags )
5206 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5207 SMESH::UpdateView();
5209 SalomeApp_Module::update( flags );
5212 //================================================================================
5214 * \brief Set default selection mode
5216 * SLOT called when operation commited. Sets default selection mode
5218 //================================================================================
5219 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5221 SVTK_ViewWindow* vtkWnd =
5222 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5224 vtkWnd->SetSelectionMode( ActorSelection );
5227 //================================================================================
5229 * \brief Set default selection mode
5231 * SLOT called when operation aborted. Sets default selection mode
5233 //================================================================================
5234 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5236 SVTK_ViewWindow* vtkWnd =
5237 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5239 vtkWnd->SetSelectionMode( ActorSelection );
5242 //================================================================================
5244 * \brief Creates operation with given identifier
5245 * \param id - identifier of operation to be started
5246 * \return Pointer on created operation or NULL if operation is not created
5248 * Virtual method redefined from the base class creates operation with given id.
5249 * It is called called automatically from startOperation method of base class.
5251 //================================================================================
5252 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5254 LightApp_Operation* op = 0;
5255 // to do : create operation here
5258 case 417: //convert to quadratic
5259 op = new SMESHGUI_ConvToQuadOp();
5261 case 418: // create 2D mesh as boundary on 3D
5262 op = new SMESHGUI_Make2DFrom3DOp();
5264 case 420: // Reorient faces
5265 op = new SMESHGUI_ReorientFacesOp();
5267 case 701: // Compute mesh
5268 op = new SMESHGUI_ComputeOp();
5270 case 702: // Create mesh
5271 op = new SMESHGUI_MeshOp( true, true );
5273 case 703: // Create sub-mesh
5274 op = new SMESHGUI_MeshOp( true, false );
5276 case 704: // Edit mesh/sub-mesh
5277 op = new SMESHGUI_MeshOp( false );
5279 case 711: // Precompute mesh
5280 op = new SMESHGUI_PrecomputeOp();
5282 case 712: // Evaluate mesh
5283 op = new SMESHGUI_EvaluateOp();
5285 case 713: // Evaluate mesh
5286 op = new SMESHGUI_MeshOrderOp();
5288 case 806: // Create group on geom
5289 op = new SMESHGUI_GroupOnShapeOp();
5291 case 904: // Find element
5292 op = new SMESHGUI_FindElemByPointOp();
5294 case 4067: // Make mesh pass through point
5295 op = new SMESHGUI_MakeNodeAtPointOp();
5297 case 4070: // Create 0D elements on all nodes
5298 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5305 op = SalomeApp_Module::createOperation( id );
5309 //================================================================================
5311 * \brief Stops current operations and starts a given one
5312 * \param id - The id of the operation to start
5314 //================================================================================
5316 void SMESHGUI::switchToOperation(int id)
5318 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5319 activeStudy()->abortAllOperations();
5320 startOperation( id );
5323 LightApp_Displayer* SMESHGUI::displayer()
5326 myDisplayer = new SMESHGUI_Displayer( getApp() );
5330 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5333 int aTolerance = 64;
5334 int anIterations = 0;
5340 if( anIterations % aPeriod == 0 )
5343 if( aTolerance < 1 )
5347 aHue = (int)( 360.0 * rand() / RAND_MAX );
5350 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5351 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5352 for( ; it != itEnd; ++it )
5354 SALOMEDS::Color anAutoColor = *it;
5355 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5358 aQColor.getHsv( &h, &s, &v );
5359 if( abs( h - aHue ) < aTolerance )
5371 aColor.setHsv( aHue, 255, 255 );
5373 SALOMEDS::Color aSColor;
5374 aSColor.R = aColor.redF();
5375 aSColor.G = aColor.greenF();
5376 aSColor.B = aColor.blueF();
5381 const char* gSeparator = "_"; // character used to separate parameter names
5382 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5383 const char* gPathSep = "|"; // character used to separate paths
5386 * \brief Store visual parameters
5388 * This method is called just before the study document is saved.
5389 * Store visual parameters in AttributeParameter attribue(s)
5391 void SMESHGUI::storeVisualParameters (int savePoint)
5394 Kernel_Utils::Localizer loc;
5396 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5397 if (!appStudy || !appStudy->studyDS())
5399 _PTR(Study) studyDS = appStudy->studyDS();
5401 // componentName is used for encoding of entries when storing them in IParameters
5402 std::string componentName = myComponentSMESH->ComponentDataType();
5403 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5404 //if (!aSComponent) return;
5407 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5408 componentName.c_str(),
5410 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5412 // store map of custom markers
5413 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5414 if( !aMarkerMap.empty() )
5416 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5417 for( ; anIter != aMarkerMap.end(); anIter++ )
5419 int anId = anIter->first;
5420 VTK::MarkerData aMarkerData = anIter->second;
5421 std::string aMarkerFileName = aMarkerData.first;
5422 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5423 if( aMarkerTexture.size() < 3 )
5424 continue; // should contain at least width, height and the first value
5426 QString aPropertyName( "texture" );
5427 aPropertyName += gSeparator;
5428 aPropertyName += QString::number( anId );
5430 QString aPropertyValue = aMarkerFileName.c_str();
5431 aPropertyValue += gPathSep;
5433 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5434 ushort aWidth = *aTextureIter++;
5435 ushort aHeight = *aTextureIter++;
5436 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5437 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5438 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5439 aPropertyValue += QString::number( *aTextureIter );
5441 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5445 // viewers counters are used for storing view_numbers in IParameters
5448 // main cycle to store parameters of displayed objects
5449 QList<SUIT_ViewManager*> lst;
5450 QList<SUIT_ViewManager*>::Iterator it;
5451 getApp()->viewManagers(lst);
5452 for (it = lst.begin(); it != lst.end(); it++)
5454 SUIT_ViewManager* vman = *it;
5455 QString vType = vman->getType();
5457 // saving VTK actors properties
5458 if (vType == SVTK_Viewer::Type())
5460 // store the clipping planes attached to the view manager
5461 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5462 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5463 if( anIter != myClippingPlaneInfoMap.end() )
5464 aClippingPlaneInfoList = anIter->second;
5466 if( !aClippingPlaneInfoList.empty() ) {
5467 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5468 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5470 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5471 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5473 QString aPropertyName( "ClippingPlane" );
5474 aPropertyName += gSeparator;
5475 aPropertyName += QString::number( vtkViewers );
5476 aPropertyName += gSeparator;
5477 aPropertyName += QString::number( anId );
5479 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5480 aPropertyValue += gDigitsSep;
5481 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5482 aPropertyValue += gDigitsSep;
5483 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5484 aPropertyValue += gDigitsSep;
5485 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5487 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5491 QVector<SUIT_ViewWindow*> views = vman->getViews();
5492 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5494 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5496 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5497 vtkActorCollection* allActors = aCopy.GetActors();
5498 allActors->InitTraversal();
5499 while (vtkActor* actor = allActors->GetNextActor())
5501 if (actor->GetVisibility()) // store only visible actors
5503 SMESH_Actor* aSmeshActor = 0;
5504 if (actor->IsA("SMESH_Actor"))
5505 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5506 if (aSmeshActor && aSmeshActor->hasIO())
5508 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5511 // entry is "encoded" = it does NOT contain component adress,
5512 // since it is a subject to change on next component loading
5513 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5515 std::string param, vtkParam = vType.toLatin1().data();
5516 vtkParam += gSeparator;
5517 vtkParam += QString::number(vtkViewers).toLatin1().data();
5518 vtkParam += gSeparator;
5521 param = vtkParam + "Visibility";
5522 ip->setParameter(entry, param, "On");
5525 param = vtkParam + "Representation";
5526 ip->setParameter(entry, param, QString::number
5527 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5530 param = vtkParam + "IsShrunk";
5531 ip->setParameter(entry, param, QString::number
5532 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5534 // Displayed entities
5535 unsigned int aMode = aSmeshActor->GetEntityMode();
5536 bool isE = aMode & SMESH_Actor::eEdges;
5537 bool isF = aMode & SMESH_Actor::eFaces;
5538 bool isV = aMode & SMESH_Actor::eVolumes;
5539 bool is0d = aMode & SMESH_Actor::e0DElements;
5540 bool isB = aMode & SMESH_Actor::eBallElem;
5542 QString modeStr ("e");
5543 modeStr += gDigitsSep; modeStr += QString::number(isE);
5544 modeStr += gDigitsSep; modeStr += "f";
5545 modeStr += gDigitsSep; modeStr += QString::number(isF);
5546 modeStr += gDigitsSep; modeStr += "v";
5547 modeStr += gDigitsSep; modeStr += QString::number(isV);
5548 modeStr += gDigitsSep; modeStr += "0d";
5549 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5550 modeStr += gDigitsSep; modeStr += "b";
5551 modeStr += gDigitsSep; modeStr += QString::number(isB);
5553 param = vtkParam + "Entities";
5554 ip->setParameter(entry, param, modeStr.toLatin1().data());
5560 aSmeshActor->GetSufaceColor(r, g, b, delta);
5561 QStringList colorStr;
5562 colorStr << "surface";
5563 colorStr << QString::number(r);
5564 colorStr << QString::number(g);
5565 colorStr << QString::number(b);
5567 colorStr << "backsurface";
5568 colorStr << QString::number(delta);
5570 aSmeshActor->GetVolumeColor(r, g, b, delta);
5571 colorStr << "volume";
5572 colorStr << QString::number(r);
5573 colorStr << QString::number(g);
5574 colorStr << QString::number(b);
5575 colorStr << QString::number(delta);
5577 aSmeshActor->GetEdgeColor(r, g, b);
5579 colorStr << QString::number(r);
5580 colorStr << QString::number(g);
5581 colorStr << QString::number(b);
5583 aSmeshActor->GetNodeColor(r, g, b);
5585 colorStr << QString::number(r);
5586 colorStr << QString::number(g);
5587 colorStr << QString::number(b);
5589 aSmeshActor->GetOutlineColor(r, g, b);
5590 colorStr << "outline";
5591 colorStr << QString::number(r);
5592 colorStr << QString::number(g);
5593 colorStr << QString::number(b);
5595 aSmeshActor->Get0DColor(r, g, b);
5596 colorStr << "elem0d";
5597 colorStr << QString::number(r);
5598 colorStr << QString::number(g);
5599 colorStr << QString::number(b);
5601 aSmeshActor->GetBallColor(r, g, b);
5603 colorStr << QString::number(r);
5604 colorStr << QString::number(g);
5605 colorStr << QString::number(b);
5607 aSmeshActor->GetFacesOrientationColor(r, g, b);
5608 colorStr << "orientation";
5609 colorStr << QString::number(r);
5610 colorStr << QString::number(g);
5611 colorStr << QString::number(b);
5613 param = vtkParam + "Colors";
5614 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5617 QStringList sizeStr;
5619 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5620 sizeStr << "outline";
5621 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5622 sizeStr << "elem0d";
5623 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5625 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5626 sizeStr << "shrink";
5627 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5628 sizeStr << "orientation";
5629 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5630 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5632 param = vtkParam + "Sizes";
5633 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5638 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5639 if( aMarkerType == VTK::MT_USER ) {
5640 markerStr += "custom";
5641 markerStr += gDigitsSep;
5642 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5646 markerStr += gDigitsSep;
5647 markerStr += QString::number( (int)aMarkerType );
5648 markerStr += gDigitsSep;
5649 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5652 param = vtkParam + "PointMarker";
5653 ip->setParameter(entry, param, markerStr.toLatin1().data());
5656 param = vtkParam + "Opacity";
5657 ip->setParameter(entry, param,
5658 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5661 param = vtkParam + "ClippingPlane";
5663 if( !aClippingPlaneInfoList.empty() ) {
5664 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5665 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5667 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5668 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5669 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5670 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5671 if( aSmeshActor == *anIter2 ) {
5672 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5673 QString::number( anId ).toLatin1().constData() );
5680 ip->setParameter( entry, param, "Off" );
5681 } // if (io->hasEntry())
5682 } // SMESH_Actor && hasIO
5684 } // while.. actors traversal
5688 } // if (SVTK view model)
5689 } // for (viewManagers)
5692 // data structures for clipping planes processing
5695 vtkIdType Orientation;
5699 typedef std::list<TPlaneData> TPlaneDataList;
5700 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5702 typedef std::list<vtkActor*> TActorList;
5705 TActorList ActorList;
5706 SUIT_ViewManager* ViewManager;
5708 typedef std::list<TPlaneInfo> TPlaneInfoList;
5709 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5712 * \brief Restore visual parameters
5714 * This method is called after the study document is opened.
5715 * Restore visual parameters from AttributeParameter attribue(s)
5717 void SMESHGUI::restoreVisualParameters (int savePoint)
5720 Kernel_Utils::Localizer loc;
5722 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5723 if (!appStudy || !appStudy->studyDS())
5725 _PTR(Study) studyDS = appStudy->studyDS();
5727 // componentName is used for encoding of entries when storing them in IParameters
5728 std::string componentName = myComponentSMESH->ComponentDataType();
5729 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5730 //if (!aSComponent) return;
5733 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5734 componentName.c_str(),
5736 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5738 // restore map of custom markers and map of clipping planes
5739 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5740 TPlaneDataMap aPlaneDataMap;
5742 std::vector<std::string> properties = ip->getProperties();
5743 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5745 std::string property = *propIt;
5746 QString aPropertyName( property.c_str() );
5747 QString aPropertyValue( ip->getProperty( property ).c_str() );
5749 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5750 if( aPropertyNameList.isEmpty() )
5753 QString aPropertyType = aPropertyNameList[0];
5754 if( aPropertyType == "texture" )
5756 if( aPropertyNameList.size() != 2 )
5760 int anId = aPropertyNameList[1].toInt( &ok );
5761 if( !ok || anId < 1 )
5764 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5765 if( aPropertyValueList.size() != 2 )
5768 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5769 QString aMarkerTextureString = aPropertyValueList[1];
5770 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5771 if( aMarkerTextureStringList.size() != 3 )
5775 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5780 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5784 VTK::MarkerTexture aMarkerTexture;
5785 aMarkerTexture.push_back( aWidth );
5786 aMarkerTexture.push_back( aHeight );
5788 QString aMarkerTextureData = aMarkerTextureStringList[2];
5789 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5791 QChar aChar = aMarkerTextureData.at( i );
5792 if( aChar.isDigit() )
5793 aMarkerTexture.push_back( aChar.digitValue() );
5796 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5798 else if( aPropertyType == "ClippingPlane" )
5800 if( aPropertyNameList.size() != 3 )
5804 int aViewId = aPropertyNameList[1].toInt( &ok );
5805 if( !ok || aViewId < 0 )
5809 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5810 if( !ok || aClippingPlaneId < 0 )
5813 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5814 if( aPropertyValueList.size() != 4 )
5817 TPlaneData aPlaneData;
5818 aPlaneData.Id = aClippingPlaneId;
5821 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5826 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5831 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5836 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5840 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5841 aPlaneDataList.push_back( aPlaneData );
5845 TPlaneInfoMap aPlaneInfoMap;
5847 std::vector<std::string> entries = ip->getEntries();
5849 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5851 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5852 QString entry (ip->decodeEntry(*entIt).c_str());
5854 // Check that the entry corresponds to a real object in the Study
5855 // as the object may be deleted or modified after the visual state is saved.
5856 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5857 if (!so) continue; //Skip the not existent entry
5859 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5860 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5862 std::vector<std::string>::iterator namesIt = paramNames.begin();
5863 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5865 // actors are stored in a map after displaying of them for
5866 // quicker access in the future: map < viewID to actor >
5867 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5869 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5871 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5872 // '_' is used as separator and should not be used in viewer type or parameter names.
5873 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5874 if (lst.size() != 3)
5877 QString viewerTypStr = lst[0];
5878 QString viewIndexStr = lst[1];
5879 QString paramNameStr = lst[2];
5882 int viewIndex = viewIndexStr.toUInt(&ok);
5883 if (!ok) // bad conversion of view index to integer
5887 if (viewerTypStr == SVTK_Viewer::Type())
5889 SMESH_Actor* aSmeshActor = 0;
5890 if (vtkActors.IsBound(viewIndex))
5891 aSmeshActor = vtkActors.Find(viewIndex);
5893 QList<SUIT_ViewManager*> lst;
5894 getApp()->viewManagers(viewerTypStr, lst);
5896 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5897 SUIT_ViewManager* vman = NULL;
5898 if (viewIndex >= 0 && viewIndex < lst.count())
5899 vman = lst.at(viewIndex);
5901 if (paramNameStr == "Visibility")
5903 if (!aSmeshActor && displayer() && vman)
5905 SUIT_ViewModel* vmodel = vman->getViewModel();
5906 // SVTK view model can be casted to SALOME_View
5907 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5909 // store displayed actor in a temporary map for quicker
5910 // access later when restoring other parameters
5911 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5912 vtkRenderer* Renderer = vtkView->getRenderer();
5913 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5914 vtkActorCollection* theActors = aCopy.GetActors();
5915 theActors->InitTraversal();
5916 bool isFound = false;
5917 vtkActor *ac = theActors->GetNextActor();
5918 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5919 if (ac->IsA("SMESH_Actor")) {
5920 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5921 if (aGeomAc->hasIO()) {
5922 Handle(SALOME_InteractiveObject) io =
5923 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5924 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5926 vtkActors.Bind(viewIndex, aGeomAc);
5932 } // if (paramNameStr == "Visibility")
5935 // the rest properties "work" with SMESH_Actor
5938 QString val ((*valuesIt).c_str());
5941 if (paramNameStr == "Representation") {
5942 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5945 else if (paramNameStr == "IsShrunk") {
5947 if (!aSmeshActor->IsShrunk())
5948 aSmeshActor->SetShrink();
5951 if (aSmeshActor->IsShrunk())
5952 aSmeshActor->UnShrink();
5955 // Displayed entities
5956 else if (paramNameStr == "Entities") {
5957 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5958 int aEntityMode = SMESH_Actor::eAllEntity;
5959 for ( int i = 0; i < mode.count(); i+=2 ) {
5960 if ( i < mode.count()-1 ) {
5961 QString type = mode[i];
5962 bool val = mode[i+1].toInt();
5963 if ( type == "e" && !val )
5964 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
5965 else if ( type == "f" && !val )
5966 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
5967 else if ( type == "v" && !val )
5968 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
5969 else if ( type == "0d" && !val )
5970 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
5971 else if ( type == "b" && !val )
5972 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
5975 aSmeshActor->SetEntityMode( aEntityMode );
5978 else if (paramNameStr == "Colors") {
5979 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5986 QColor outlineColor;
5987 QColor orientationColor;
5993 // below lines are required to get default values for delta coefficients
5994 // of backface color for faces and color of reversed volumes
5995 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
5996 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
5997 for ( int i = 0; i < colors.count(); i++ ) {
5998 QString type = colors[i];
5999 if ( type == "surface" ) {
6000 // face color is set by 3 values r:g:b, where
6001 // - r,g,b - is rgb color components
6002 if ( i+1 >= colors.count() ) break; // format error
6003 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6004 if ( i+2 >= colors.count() ) break; // format error
6005 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6006 if ( i+3 >= colors.count() ) break; // format error
6007 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6008 faceColor.setRgbF( r, g, b );
6011 else if ( type == "backsurface" ) {
6012 // backface color can be defined in several ways
6013 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6014 // - in latest versions, it is set as delta coefficient
6015 bool rgbOk = false, deltaOk;
6016 if ( i+1 >= colors.count() ) break; // format error
6017 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6018 int delta = colors[i+1].toInt( &deltaOk );
6020 if ( i+1 < colors.count() ) // index is shifted to 1
6021 g = colors[i+1].toDouble( &rgbOk );
6022 if ( rgbOk ) i++; // shift index
6023 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6024 b = colors[i+1].toDouble( &rgbOk );
6026 // - as currently there's no way to set directly backsurface color as it was before,
6027 // we ignore old dump where r,g,b triple was set
6028 // - also we check that delta parameter is set properly
6029 if ( !rgbOk && deltaOk )
6032 else if ( type == "volume" ) {
6033 // volume color is set by 4 values r:g:b:delta, where
6034 // - r,g,b - is a normal volume rgb color components
6035 // - delta - is a reversed volume color delta coefficient
6036 if ( i+1 >= colors.count() ) break; // format error
6037 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6038 if ( i+2 >= colors.count() ) break; // format error
6039 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6040 if ( i+3 >= colors.count() ) break; // format error
6041 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6042 if ( i+4 >= colors.count() ) break; // format error
6043 int delta = colors[i+4].toInt( &bOk );
6044 if ( !bOk ) break; // format error
6045 volumeColor.setRgbF( r, g, b );
6049 else if ( type == "edge" ) {
6050 // edge color is set by 3 values r:g:b, where
6051 // - r,g,b - is rgb color components
6052 if ( i+1 >= colors.count() ) break; // format error
6053 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6054 if ( i+2 >= colors.count() ) break; // format error
6055 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6056 if ( i+3 >= colors.count() ) break; // format error
6057 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6058 edgeColor.setRgbF( r, g, b );
6061 else if ( type == "node" ) {
6062 // node color is set by 3 values r:g:b, where
6063 // - r,g,b - is rgb color components
6064 if ( i+1 >= colors.count() ) break; // format error
6065 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6066 if ( i+2 >= colors.count() ) break; // format error
6067 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6068 if ( i+3 >= colors.count() ) break; // format error
6069 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6070 nodeColor.setRgbF( r, g, b );
6073 else if ( type == "elem0d" ) {
6074 // 0d element color is set by 3 values r:g:b, where
6075 // - r,g,b - is rgb color components
6076 if ( i+1 >= colors.count() ) break; // format error
6077 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6078 if ( i+2 >= colors.count() ) break; // format error
6079 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6080 if ( i+3 >= colors.count() ) break; // format error
6081 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6082 elem0dColor.setRgbF( r, g, b );
6085 else if ( type == "ball" ) {
6086 // ball color is set by 3 values r:g:b, where
6087 // - r,g,b - is rgb color components
6088 if ( i+1 >= colors.count() ) break; // format error
6089 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6090 if ( i+2 >= colors.count() ) break; // format error
6091 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6092 if ( i+3 >= colors.count() ) break; // format error
6093 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6094 ballColor.setRgbF( r, g, b );
6097 else if ( type == "outline" ) {
6098 // outline color is set by 3 values r:g:b, where
6099 // - r,g,b - is rgb color components
6100 if ( i+1 >= colors.count() ) break; // format error
6101 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6102 if ( i+2 >= colors.count() ) break; // format error
6103 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6104 if ( i+3 >= colors.count() ) break; // format error
6105 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6106 outlineColor.setRgbF( r, g, b );
6109 else if ( type == "orientation" ) {
6110 // orientation color is set by 3 values r:g:b, where
6111 // - r,g,b - is rgb color components
6112 if ( i+1 >= colors.count() ) break; // format error
6113 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6114 if ( i+2 >= colors.count() ) break; // format error
6115 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6116 if ( i+3 >= colors.count() ) break; // format error
6117 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6118 orientationColor.setRgbF( r, g, b );
6123 if ( nodeColor.isValid() )
6124 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6126 if ( edgeColor.isValid() )
6127 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6129 if ( faceColor.isValid() )
6130 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6132 if ( volumeColor.isValid() )
6133 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6134 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6135 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6137 if ( elem0dColor.isValid() )
6138 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6140 if ( ballColor.isValid() )
6141 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6143 if ( outlineColor.isValid() )
6144 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6145 // orientation color
6146 if ( orientationColor.isValid() )
6147 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6150 else if (paramNameStr == "Sizes") {
6151 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6154 int outlineWidth = -1;
6155 int elem0dSize = -1;
6157 double shrinkSize = -1;
6158 double orientationSize = -1;
6159 bool orientation3d = false;
6160 for ( int i = 0; i < sizes.count(); i++ ) {
6161 QString type = sizes[i];
6162 if ( type == "line" ) {
6163 // line (wireframe) width is given as single integer value
6164 if ( i+1 >= sizes.count() ) break; // format error
6165 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6169 if ( type == "outline" ) {
6170 // outline width is given as single integer value
6171 if ( i+1 >= sizes.count() ) break; // format error
6172 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6176 else if ( type == "elem0d" ) {
6177 // 0d element size is given as single integer value
6178 if ( i+1 >= sizes.count() ) break; // format error
6179 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6183 else if ( type == "ball" ) {
6184 // ball size is given as single integer value
6185 if ( i+1 >= sizes.count() ) break; // format error
6186 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6190 else if ( type == "shrink" ) {
6191 // shrink factor is given as single floating point value
6192 if ( i+1 >= sizes.count() ) break; // format error
6193 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6197 else if ( type == "orientation" ) {
6198 // orientation vectors are specified by two values size:3d, where
6199 // - size - is a floating point value specifying scale factor
6200 // - 3d - is a boolean
6201 if ( i+1 >= sizes.count() ) break; // format error
6202 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6203 if ( i+2 >= sizes.count() ) break; // format error
6204 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6205 orientationSize = v1;
6206 orientation3d = (bool)v2;
6210 // line (wireframe) width
6211 if ( lineWidth > 0 )
6212 aSmeshActor->SetLineWidth( lineWidth );
6214 if ( outlineWidth > 0 )
6215 aSmeshActor->SetOutlineWidth( outlineWidth );
6216 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6217 aSmeshActor->SetOutlineWidth( lineWidth );
6219 if ( elem0dSize > 0 )
6220 aSmeshActor->Set0DSize( elem0dSize );
6223 aSmeshActor->SetBallSize( ballSize );
6225 if ( shrinkSize > 0 )
6226 aSmeshActor->SetShrinkFactor( shrinkSize );
6227 // orientation vectors
6228 if ( orientationSize > 0 ) {
6229 aSmeshActor->SetFacesOrientationScale( orientationSize );
6230 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6234 else if (paramNameStr == "PointMarker") {
6235 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6236 if( data.count() >= 2 ) {
6238 int aParam1 = data[1].toInt( &ok );
6240 if( data[0] == "std" && data.count() == 3 ) {
6241 int aParam2 = data[2].toInt( &ok );
6242 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6244 else if( data[0] == "custom" ) {
6245 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6246 if( markerIt != aMarkerMap.end() ) {
6247 VTK::MarkerData aMarkerData = markerIt->second;
6248 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6255 else if (paramNameStr == "Opacity") {
6256 aSmeshActor->SetOpacity(val.toFloat());
6259 else if (paramNameStr.startsWith("ClippingPlane")) {
6260 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6261 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
6262 // new format - val looks like "Off" or "0" (plane id)
6263 // (note: in new format "Off" value is used only for consistency,
6264 // so it is processed together with values in old format)
6265 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
6266 if( anIsOldFormat ) {
6267 if (paramNameStr == "ClippingPlane1" || val == "Off")
6268 aSmeshActor->RemoveAllClippingPlanes();
6270 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
6271 double aDistance = vals[1].toFloat();
6273 anAngle[0] = vals[2].toFloat();
6274 anAngle[1] = vals[3].toFloat();
6276 QList<SUIT_ViewManager*> lst;
6277 getApp()->viewManagers(viewerTypStr, lst);
6278 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6279 if (viewIndex >= 0 && viewIndex < lst.count()) {
6280 SUIT_ViewManager* vman = lst.at(viewIndex);
6281 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6283 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6285 SMESH::TActorList anActorList;
6286 anActorList.push_back( aSmeshActor );
6287 SMESH::OrientedPlane* aPlane =
6288 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
6290 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6291 aClippingPlaneInfo.Plane = aPlane;
6292 aClippingPlaneInfo.ActorList = anActorList;
6293 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6300 int aPlaneId = val.toInt( &ok );
6301 if( ok && aPlaneId >= 0 ) {
6302 bool anIsDefinedPlane = false;
6303 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6304 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6305 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6306 TPlaneInfo& aPlaneInfo = *anIter;
6307 if( aPlaneInfo.PlaneId == aPlaneId ) {
6308 aPlaneInfo.ActorList.push_back( aSmeshActor );
6309 anIsDefinedPlane = true;
6313 if( !anIsDefinedPlane ) {
6314 TPlaneInfo aPlaneInfo;
6315 aPlaneInfo.PlaneId = aPlaneId;
6316 aPlaneInfo.ActorList.push_back( aSmeshActor );
6317 aPlaneInfo.ViewManager = vman;
6319 // to make the list sorted by plane id
6320 anIter = aPlaneInfoList.begin();
6321 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6322 const TPlaneInfo& aPlaneInfoRef = *anIter;
6323 if( aPlaneInfoRef.PlaneId > aPlaneId )
6326 aPlaneInfoList.insert( anIter, aPlaneInfo );
6331 } // if (aSmeshActor)
6332 } // other parameters than Visibility
6334 } // for names/parameters iterator
6335 } // for entries iterator
6337 // take into account planes with empty list of actors referred to them
6338 QList<SUIT_ViewManager*> aVMList;
6339 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6341 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6342 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6343 int aViewId = aPlaneDataIter->first;
6344 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6345 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6347 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6349 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6350 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6351 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6352 const TPlaneData& aPlaneData = *anIter2;
6353 int aPlaneId = aPlaneData.Id;
6355 bool anIsFound = false;
6356 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6357 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6358 const TPlaneInfo& aPlaneInfo = *anIter3;
6359 if( aPlaneInfo.PlaneId == aPlaneId ) {
6366 TPlaneInfo aPlaneInfo; // ActorList field is empty
6367 aPlaneInfo.PlaneId = aPlaneId;
6368 aPlaneInfo.ViewManager = aViewManager;
6370 // to make the list sorted by plane id
6371 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6372 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6373 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6374 if( aPlaneInfoRef.PlaneId > aPlaneId )
6377 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6383 // add clipping planes to actors according to the restored parameters
6384 // and update the clipping plane map
6385 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6386 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6387 int aViewId = anIter1->first;
6388 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6390 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6391 if( anIter2 == aPlaneDataMap.end() )
6393 const TPlaneDataList& aPlaneDataList = anIter2->second;
6395 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6396 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6397 const TPlaneInfo& aPlaneInfo = *anIter3;
6398 int aPlaneId = aPlaneInfo.PlaneId;
6399 const TActorList& anActorList = aPlaneInfo.ActorList;
6400 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6404 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6408 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6410 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6411 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6412 const TPlaneData& aPlaneData = *anIter4;
6413 if( aPlaneData.Id == aPlaneId ) {
6414 SMESH::OrientedPlane* aPlane =
6415 SMESHGUI_ClippingDlg::AddPlane( anActorList,
6417 (SMESH::Orientation)aPlaneData.Orientation,
6418 aPlaneData.Distance,
6421 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6422 aClippingPlaneInfo.Plane = aPlane;
6423 aClippingPlaneInfo.ActorList = anActorList;
6424 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6432 // update all VTK views
6433 QList<SUIT_ViewManager*> lst;
6434 getApp()->viewManagers(lst);
6435 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6436 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6437 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6438 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6439 vtkView->getRenderer()->ResetCameraClippingRange();
6446 \brief Adds preferences for dfont of VTK viewer
6448 \param pIf group identifier
6449 \param param parameter
6450 \return identifier of preferences
6452 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6454 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6456 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6459 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6460 fam.append( tr( "SMESH_FONT_COURIER" ) );
6461 fam.append( tr( "SMESH_FONT_TIMES" ) );
6463 setPreferenceProperty( tfont, "fonts", fam );
6465 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6466 if ( needSize ) f = f | QtxFontEdit::Size;
6467 setPreferenceProperty( tfont, "features", f );
6473 \brief Actions after hypothesis edition
6474 Updates object browser after hypothesis edition
6476 void SMESHGUI::onHypothesisEdit( int result )
6479 SMESHGUI::Modified();
6480 updateObjBrowser( true );
6485 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6486 \param pview view being closed
6488 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6489 #ifndef DISABLE_PLOT2DVIEWER
6490 //Crear all Plot2d Viewers if need.
6491 SMESH::ClearPlot2Viewers(pview);
6495 void SMESHGUI::message( const QString& msg )
6498 QStringList data = msg.split("/");
6499 if ( data.count() > 0 ) {
6500 if ( data.first() == "mesh_loading" ) {
6502 QString entry = data.count() > 1 ? data[1] : QString();
6503 if ( entry.isEmpty() )
6506 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6508 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6511 name = obj->GetName().c_str();
6512 if ( name.isEmpty() )
6515 if ( data.last() == "stop" )
6516 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6518 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6519 QApplication::processEvents();
6525 \brief Connects or disconnects signals about activating and cloning view on the module slots
6526 \param pview view which is connected/disconnected
6528 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6532 SUIT_ViewManager* viewMgr = pview->getViewManager();
6534 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6535 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6537 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6538 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6543 \brief Return \c true if object can be renamed
6545 bool SMESHGUI::renameAllowed( const QString& entry) const {
6546 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6550 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6554 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6559 if(appStudy->isComponent(entry) || obj->isReference())
6562 // check type to prevent renaming of inappropriate objects
6563 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6564 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6565 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6566 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6567 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6568 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6575 Rename object by entry.
6576 \param entry entry of the object
6577 \param name new name of the object
6578 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6580 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6582 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6586 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6591 _PTR(Study) aStudy = appStudy->studyDS();
6596 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6598 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6603 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6604 _PTR(GenericAttribute) anAttr;
6605 _PTR(AttributeName) aName;
6607 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6609 // check type to prevent renaming of inappropriate objects
6610 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6611 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6612 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6613 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6614 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6615 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6616 if ( !name.isEmpty() ) {
6617 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6619 // update name of group object and its actor
6620 Handle(SALOME_InteractiveObject) IObject =
6621 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6623 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6624 if( !aGroupObject->_is_nil() ) {
6625 aGroupObject->SetName( qPrintable(name) );
6626 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6627 anActor->setName( qPrintable(name) );
6638 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6640 static QList<QColor> colors;
6642 if ( colors.isEmpty() ) {
6644 for (int s = 0; s < 2 ; s++)
6646 for (int v = 100; v >= 40; v = v - 20)
6648 for (int h = 0; h < 359 ; h = h + 60)
6650 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
6655 static int currentColor = 0;
6657 SALOMEDS::Color color;
6658 color.R = (double)colors[currentColor].red() / 255.0;
6659 color.G = (double)colors[currentColor].green() / 255.0;
6660 color.B = (double)colors[currentColor].blue() / 255.0;
6662 currentColor = (currentColor+1) % colors.count();