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( 6032,View, mesh_part ); // CTRL_INFO
4224 createPopupItem( 904, View, mesh ); // FIND_ELEM
4225 popupMgr()->insert( separator(), -1, 0 );
4227 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
4228 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
4229 popupMgr()->insert( separator(), -1, 0 );
4231 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4232 QString aType = QString( "%1type in {%2}" ).arg( lc );
4233 aType = aType.arg( mesh_part );
4234 QString aMeshInVTK = aClient + "&&" + aType;
4236 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4237 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4238 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4240 //-------------------------------------------------
4242 //-------------------------------------------------
4243 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4245 popupMgr()->insert( action( 9010 ), anId, -1 );
4246 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4247 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4249 popupMgr()->insert( action( 9011 ), anId, -1 );
4250 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4251 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4253 popupMgr()->insert( separator(), -1, -1 );
4255 //-------------------------------------------------
4257 //-------------------------------------------------
4258 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4260 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4261 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4262 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4264 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4265 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4266 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4268 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4269 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4270 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4272 popupMgr()->insert( separator(), anId, -1 );
4274 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4275 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4276 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4278 //-------------------------------------------------
4280 //-------------------------------------------------
4281 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4283 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4285 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4286 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4287 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4289 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4290 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4291 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4293 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4294 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4295 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4297 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4298 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4299 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4301 popupMgr()->insert( action( 222 ), anId, -1 ); // BALLS
4302 popupMgr()->setRule( action( 222 ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4303 popupMgr()->setRule( action( 222 ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4305 popupMgr()->insert( separator(), anId, -1 );
4307 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4308 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4311 //-------------------------------------------------
4312 // Representation of the 2D Quadratic elements
4313 //-------------------------------------------------
4314 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4315 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4316 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4317 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4319 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4320 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4321 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4323 //-------------------------------------------------
4324 // Orientation of faces
4325 //-------------------------------------------------
4326 popupMgr()->insert( action( 221 ), -1, -1 );
4327 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4328 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4330 //-------------------------------------------------
4332 //-------------------------------------------------
4333 popupMgr()->insert( action( 1132 ), -1, -1 );
4334 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4336 //-------------------------------------------------
4338 //-------------------------------------------------
4339 popupMgr()->insert( action( 1133 ), -1, -1 );
4340 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4342 //-------------------------------------------------
4344 //-------------------------------------------------
4346 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4347 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4348 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4349 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4351 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4353 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4354 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4356 popupMgr()->insert( separator(), anId, -1 );
4358 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4360 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4361 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4362 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4364 popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4365 popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4366 popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4368 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4370 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4371 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4372 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4374 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4375 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4376 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4378 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4379 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4380 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4382 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4383 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4384 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4385 popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4386 popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4387 popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4389 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4391 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4392 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4393 QtxPopupMgr::VisibleRule );
4394 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4396 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4397 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4398 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4400 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4401 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4402 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4404 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4405 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4406 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4408 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4409 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4410 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4412 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4413 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4414 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4416 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4417 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4418 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4420 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4421 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4422 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4424 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4425 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4426 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4428 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4429 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4430 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4432 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4433 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4434 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4436 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4437 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4438 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4439 popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4440 popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4441 popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4443 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4445 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4446 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4447 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4449 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4450 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4451 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4453 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4454 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4455 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4457 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4458 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4459 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4461 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4462 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4463 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4465 popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4466 popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4467 popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4469 popupMgr()->insert( separator(), anId, -1 );
4471 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4472 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4474 popupMgr()->insert( separator(), anId, -1 );
4476 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4478 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4479 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4481 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4482 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4483 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4485 #ifndef DISABLE_PLOT2DVIEWER
4486 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4487 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4490 //-------------------------------------------------
4492 //-------------------------------------------------
4493 popupMgr()->insert( separator(), -1, -1 );
4494 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4495 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4496 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4497 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4499 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4500 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4502 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4503 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4505 popupMgr()->insert( separator(), -1, -1 );
4507 //-------------------------------------------------
4509 //-------------------------------------------------
4510 popupMgr()->insert( action( 1134 ), -1, -1 );
4511 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4513 popupMgr()->insert( separator(), -1, -1 );
4515 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4516 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4518 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4519 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4522 //================================================================================
4524 * \brief Return true if SMESH or GEOM objects are selected.
4525 * Is called form LightApp_Module::activateModule() which clear selection if
4526 * not isSelectionCompatible()
4528 //================================================================================
4530 bool SMESHGUI::isSelectionCompatible()
4532 bool isCompatible = true;
4533 SALOME_ListIO selected;
4534 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4535 Sel->selectedObjects( selected );
4537 SALOME_ListIteratorOfListIO It( selected );
4538 for ( ; isCompatible && It.More(); It.Next())
4540 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4541 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4543 return isCompatible;
4547 bool SMESHGUI::reusableOperation( const int id )
4549 // compute, evaluate and precompute are not reusable operations
4550 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4553 bool SMESHGUI::activateModule( SUIT_Study* study )
4555 bool res = SalomeApp_Module::activateModule( study );
4557 setMenuShown( true );
4558 setToolShown( true );
4560 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4561 PyGILState_STATE gstate = PyGILState_Ensure();
4562 PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4563 if(pluginsmanager==NULL)
4567 PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4572 PyGILState_Release(gstate);
4573 // end of GEOM plugins loading
4575 // Reset actions accelerator keys
4576 //action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4577 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4578 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4580 action( 33)->setEnabled(true); // Delete: Key_Delete
4582 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4583 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4584 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4585 if ( _PTR(Study) aStudy = s->studyDS()) {
4586 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4587 updateObjBrowser(); // objects can be removed
4590 // get all view currently opened in the study and connect their signals to
4591 // the corresponding slots of the class.
4592 SUIT_Desktop* aDesk = study->application()->desktop();
4594 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4595 SUIT_ViewWindow* wnd;
4596 foreach ( wnd, wndList )
4603 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4605 setMenuShown( false );
4606 setToolShown( false );
4608 EmitSignalCloseAllDialogs();
4610 // Unset actions accelerator keys
4611 //action(111)->setShortcut(QKeySequence()); // Import DAT
4612 action(112)->setShortcut(QKeySequence()); // Import UNV
4613 action(113)->setShortcut(QKeySequence()); // Import MED
4615 action( 33)->setEnabled(false); // Delete: Key_Delete
4617 return SalomeApp_Module::deactivateModule( study );
4620 void SMESHGUI::studyClosed( SUIT_Study* s )
4622 SMESH::RemoveVisuData( s->id() );
4623 SalomeApp_Module::studyClosed( s );
4626 void SMESHGUI::OnGUIEvent()
4628 const QObject* obj = sender();
4629 if ( !obj || !obj->inherits( "QAction" ) )
4631 int id = actionId((QAction*)obj);
4636 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4638 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4639 if ( CORBA::is_nil( myComponentSMESH ) )
4641 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4643 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4644 return aGUI.myComponentSMESH;
4647 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4648 return myComponentSMESH;
4651 QString SMESHGUI::engineIOR() const
4653 CORBA::ORB_var anORB = getApp()->orb();
4654 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4655 return QString( anIOR.in() );
4658 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4660 SalomeApp_Module::contextMenuPopup( client, menu, title );
4662 selectionMgr()->selectedObjects( lst );
4663 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4664 Handle(SALOME_InteractiveObject) io = lst.First();
4665 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4666 _PTR(Study) study = appStudy->studyDS();
4667 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4669 QString aName = QString( obj->GetName().c_str() );
4670 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4671 aName.remove( (aName.length() - 1), 1 );
4677 LightApp_Selection* SMESHGUI::createSelection() const
4679 return new SMESHGUI_Selection();
4682 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4684 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4685 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4688 void SMESHGUI::viewManagers( QStringList& list ) const
4690 list.append( SVTK_Viewer::Type() );
4693 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4695 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4696 SMESH::UpdateSelectionProp( this );
4698 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4699 for(int i = 0; i < aViews.count() ; i++){
4700 SUIT_ViewWindow *sf = aViews[i];
4706 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4708 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4709 myClippingPlaneInfoMap.erase( theViewManager );
4712 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4714 theActor->AddObserver( SMESH::DeleteActorEvent,
4715 myEventCallbackCommand.GetPointer(),
4719 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4720 unsigned long theEvent,
4721 void* theClientData,
4724 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4725 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4726 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4727 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4728 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4729 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4730 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4731 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4732 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4733 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4734 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4735 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4736 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4737 if( anActor == *anIter3 ) {
4738 anActorList.erase( anIter3 );
4749 void SMESHGUI::createPreferences()
4751 // General tab ------------------------------------------------------------------------
4752 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4754 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4755 setPreferenceProperty( autoUpdate, "columns", 2 );
4756 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4757 setPreferenceProperty( lim, "min", 0 );
4758 setPreferenceProperty( lim, "max", 100000000 );
4759 setPreferenceProperty( lim, "step", 1000 );
4760 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4761 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4763 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4764 setPreferenceProperty( qaGroup, "columns", 2 );
4765 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4766 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4767 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4768 setPreferenceProperty( prec, "min", 0 );
4769 setPreferenceProperty( prec, "max", 16 );
4770 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4771 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4772 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4773 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4774 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4776 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4777 setPreferenceProperty( dispgroup, "columns", 2 );
4778 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4780 modes.append( tr("MEN_WIRE") );
4781 modes.append( tr("MEN_SHADE") );
4782 modes.append( tr("MEN_NODES") );
4783 modes.append( tr("MEN_SHRINK") );
4784 QList<QVariant> indices;
4785 indices.append( 0 );
4786 indices.append( 1 );
4787 indices.append( 2 );
4788 indices.append( 3 );
4789 setPreferenceProperty( dispmode, "strings", modes );
4790 setPreferenceProperty( dispmode, "indexes", indices );
4792 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4793 setPreferenceProperty( arcgroup, "columns", 2 );
4794 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4795 QStringList quadraticModes;
4796 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4797 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4799 indices.append( 0 );
4800 indices.append( 1 );
4801 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4802 setPreferenceProperty( quadraticmode, "indexes", indices );
4804 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4805 "SMESH", "max_angle" );
4806 setPreferenceProperty( maxAngle, "min", 1 );
4807 setPreferenceProperty( maxAngle, "max", 90 );
4811 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4812 setPreferenceProperty( exportgroup, "columns", 2 );
4813 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4814 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4816 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4817 setPreferenceProperty( computeGroup, "columns", 2 );
4818 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4820 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4821 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4822 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4824 indices.append( 0 );
4825 indices.append( 1 );
4826 indices.append( 2 );
4827 setPreferenceProperty( notifyMode, "strings", modes );
4828 setPreferenceProperty( notifyMode, "indexes", indices );
4830 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4831 setPreferenceProperty( infoGroup, "columns", 2 );
4832 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4834 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4835 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4837 indices.append( 0 );
4838 indices.append( 1 );
4839 setPreferenceProperty( elemInfo, "strings", modes );
4840 setPreferenceProperty( elemInfo, "indexes", indices );
4841 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4842 setPreferenceProperty( nodesLim, "min", 0 );
4843 setPreferenceProperty( nodesLim, "max", 10000000 );
4844 setPreferenceProperty( nodesLim, "step", 10000 );
4845 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4846 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
4847 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4848 setPreferenceProperty( ctrlLim, "min", 0 );
4849 setPreferenceProperty( ctrlLim, "max", 10000000 );
4850 setPreferenceProperty( ctrlLim, "step", 1000 );
4851 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
4852 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
4853 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
4854 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
4855 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
4857 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4858 setPreferenceProperty( segGroup, "columns", 2 );
4859 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4860 "SMESH", "segmentation" );
4861 setPreferenceProperty( segLen, "min", 1 );
4862 setPreferenceProperty( segLen, "max", 10000000 );
4863 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4864 "SMESH", "nb_segments_per_edge" );
4865 setPreferenceProperty( nbSeg, "min", 1 );
4866 setPreferenceProperty( nbSeg, "max", 10000000 );
4868 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4869 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4870 "SMESH", "forget_mesh_on_hyp_modif" );
4873 // Quantities with individual precision settings
4874 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4875 setPreferenceProperty( precGroup, "columns", 2 );
4877 const int nbQuantities = 6;
4878 int precs[nbQuantities], ii = 0;
4879 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4880 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4881 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4882 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4883 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4884 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4885 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4886 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4887 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4888 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4889 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4890 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4892 // Set property for precision value for spinboxes
4893 for ( ii = 0; ii < nbQuantities; ii++ ){
4894 setPreferenceProperty( precs[ii], "min", -14 );
4895 setPreferenceProperty( precs[ii], "max", 14 );
4896 setPreferenceProperty( precs[ii], "precision", 2 );
4899 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4900 setPreferenceProperty( previewGroup, "columns", 2 );
4901 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4902 setPreferenceProperty( chunkSize, "min", 1 );
4903 setPreferenceProperty( chunkSize, "max", 1000 );
4904 setPreferenceProperty( chunkSize, "step", 50 );
4906 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4907 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4909 // Mesh tab ------------------------------------------------------------------------
4910 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4911 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4912 setPreferenceProperty( nodeGroup, "columns", 3 );
4914 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4916 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4918 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4919 QList<QVariant> aMarkerTypeIndicesList;
4920 QList<QVariant> aMarkerTypeIconsList;
4921 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4922 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4923 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4924 aMarkerTypeIndicesList << i;
4925 aMarkerTypeIconsList << pixmap;
4927 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4928 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4930 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4932 QList<QVariant> aMarkerScaleIndicesList;
4933 QStringList aMarkerScaleValuesList;
4934 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4935 aMarkerScaleIndicesList << i;
4936 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4938 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4939 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4941 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4942 //setPreferenceProperty( elemGroup, "columns", 2 );
4944 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4945 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4946 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
4947 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
4948 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4949 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
4950 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4951 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4954 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4955 setPreferenceProperty( grpGroup, "columns", 2 );
4957 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4958 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
4960 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4961 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4962 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
4963 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
4964 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4965 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4966 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
4967 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
4968 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4969 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4971 setPreferenceProperty( size0d, "min", 1 );
4972 setPreferenceProperty( size0d, "max", 10 );
4974 setPreferenceProperty( ballSize, "min", 1 );
4975 setPreferenceProperty( ballSize, "max", 10 );
4977 setPreferenceProperty( elemW, "min", 1 );
4978 setPreferenceProperty( elemW, "max", 5 );
4980 setPreferenceProperty( outW, "min", 1 );
4981 setPreferenceProperty( outW, "max", 5 );
4983 setPreferenceProperty( shrink, "min", 0 );
4984 setPreferenceProperty( shrink, "max", 100 );
4986 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
4987 setPreferenceProperty( numGroup, "columns", 2 );
4989 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
4990 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
4992 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
4993 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
4995 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4996 setPreferenceProperty( orientGroup, "columns", 1 );
4998 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4999 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5001 setPreferenceProperty( orientScale, "min", 0.05 );
5002 setPreferenceProperty( orientScale, "max", 0.5 );
5003 setPreferenceProperty( orientScale, "step", 0.05 );
5005 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5007 // Selection tab ------------------------------------------------------------------------
5008 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5010 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5011 setPreferenceProperty( selGroup, "columns", 2 );
5013 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5014 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5016 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5017 setPreferenceProperty( preGroup, "columns", 2 );
5019 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5021 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5022 setPreferenceProperty( precSelGroup, "columns", 2 );
5024 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5025 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5026 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5028 // Scalar Bar tab ------------------------------------------------------------------------
5029 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5030 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5031 setPreferenceProperty( fontGr, "columns", 2 );
5033 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5034 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5036 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5037 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5039 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5040 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5042 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5043 setPreferenceProperty( numcol, "min", 2 );
5044 setPreferenceProperty( numcol, "max", 256 );
5046 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5047 setPreferenceProperty( numlab, "min", 2 );
5048 setPreferenceProperty( numlab, "max", 65 );
5050 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5051 setPreferenceProperty( orientGr, "columns", 2 );
5052 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5053 QStringList orients;
5054 orients.append( tr( "SMESH_VERTICAL" ) );
5055 orients.append( tr( "SMESH_HORIZONTAL" ) );
5056 indices.clear(); indices.append( 0 ); indices.append( 1 );
5057 setPreferenceProperty( orient, "strings", orients );
5058 setPreferenceProperty( orient, "indexes", indices );
5060 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5061 setPreferenceProperty( posVSizeGr, "columns", 2 );
5062 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5063 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5064 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5065 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5066 setPreferenceProperty( xv, "step", 0.1 );
5067 setPreferenceProperty( xv, "min", 0.0 );
5068 setPreferenceProperty( xv, "max", 1.0 );
5069 setPreferenceProperty( yv, "step", 0.1 );
5070 setPreferenceProperty( yv, "min", 0.0 );
5071 setPreferenceProperty( yv, "max", 1.0 );
5072 setPreferenceProperty( wv, "step", 0.1 );
5073 setPreferenceProperty( wv, "min", 0.0 );
5074 setPreferenceProperty( wv, "max", 1.0 );
5075 setPreferenceProperty( hv, "min", 0.0 );
5076 setPreferenceProperty( hv, "max", 1.0 );
5077 setPreferenceProperty( hv, "step", 0.1 );
5079 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5080 setPreferenceProperty( posHSizeGr, "columns", 2 );
5081 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5082 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5083 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5084 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5085 setPreferenceProperty( xv, "min", 0.0 );
5086 setPreferenceProperty( xv, "max", 1.0 );
5087 setPreferenceProperty( xv, "step", 0.1 );
5088 setPreferenceProperty( xh, "min", 0.0 );
5089 setPreferenceProperty( xh, "max", 1.0 );
5090 setPreferenceProperty( xh, "step", 0.1 );
5091 setPreferenceProperty( yh, "min", 0.0 );
5092 setPreferenceProperty( yh, "max", 1.0 );
5093 setPreferenceProperty( yh, "step", 0.1 );
5094 setPreferenceProperty( wh, "min", 0.0 );
5095 setPreferenceProperty( wh, "max", 1.0 );
5096 setPreferenceProperty( wh, "step", 0.1 );
5097 setPreferenceProperty( hh, "min", 0.0 );
5098 setPreferenceProperty( hh, "max", 1.0 );
5099 setPreferenceProperty( hh, "step", 0.1 );
5101 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5102 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5103 setPreferenceProperty( distributionGr, "columns", 3 );
5105 types.append( tr( "SMESH_MONOCOLOR" ) );
5106 types.append( tr( "SMESH_MULTICOLOR" ) );
5107 indices.clear(); indices.append( 0 ); indices.append( 1 );
5108 setPreferenceProperty( coloringType, "strings", types );
5109 setPreferenceProperty( coloringType, "indexes", indices );
5110 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5114 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5116 if( sect=="SMESH" ) {
5117 float sbX1,sbY1,sbW,sbH;
5118 float aTol = 1.00000009999999;
5119 std::string aWarning;
5120 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5121 if( name=="selection_object_color" || name=="selection_element_color" ||
5122 name=="highlight_color" ||
5123 name=="selection_precision_node" || name=="selection_precision_element" ||
5124 name=="selection_precision_object")
5125 SMESH::UpdateSelectionProp( this );
5126 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5127 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5128 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5129 if(sbX1+sbW > aTol){
5130 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5133 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5134 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5137 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5138 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5139 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5140 if(sbY1+sbH > aTol){
5141 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5142 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5143 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5146 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5147 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5148 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5149 if(sbX1+sbW > aTol){
5150 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5153 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5154 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5157 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5158 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5159 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5160 if(sbY1+sbH > aTol){
5161 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5164 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5165 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5168 else if ( name == "segmentation" ) {
5169 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5170 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5172 else if ( name == "nb_segments_per_edge" ) {
5173 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5174 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5176 else if ( name == "historical_python_dump" ||
5177 name == "forget_mesh_on_hyp_modif") {
5178 QString val = aResourceMgr->stringValue( "SMESH", name );
5179 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5181 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5182 SMESH::UpdateFontProp( this );
5184 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5185 SMESH::UpdateFontProp( this );
5188 if(aWarning.size() != 0){
5189 aWarning += "The default values are applied instead.";
5190 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5191 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5192 QObject::tr(aWarning.c_str()));
5197 //================================================================================
5199 * \brief Update something in accordance with update flags
5200 * \param theFlags - update flags
5202 * Update viewer or/and object browser etc. in accordance with update flags ( see
5203 * LightApp_UpdateFlags enumeration ).
5205 //================================================================================
5206 void SMESHGUI::update( const int flags )
5208 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5209 SMESH::UpdateView();
5211 SalomeApp_Module::update( flags );
5214 //================================================================================
5216 * \brief Set default selection mode
5218 * SLOT called when operation commited. Sets default selection mode
5220 //================================================================================
5221 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5223 SVTK_ViewWindow* vtkWnd =
5224 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5226 vtkWnd->SetSelectionMode( ActorSelection );
5229 //================================================================================
5231 * \brief Set default selection mode
5233 * SLOT called when operation aborted. Sets default selection mode
5235 //================================================================================
5236 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5238 SVTK_ViewWindow* vtkWnd =
5239 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5241 vtkWnd->SetSelectionMode( ActorSelection );
5244 //================================================================================
5246 * \brief Creates operation with given identifier
5247 * \param id - identifier of operation to be started
5248 * \return Pointer on created operation or NULL if operation is not created
5250 * Virtual method redefined from the base class creates operation with given id.
5251 * It is called called automatically from startOperation method of base class.
5253 //================================================================================
5254 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5256 LightApp_Operation* op = 0;
5257 // to do : create operation here
5260 case 417: //convert to quadratic
5261 op = new SMESHGUI_ConvToQuadOp();
5263 case 418: // create 2D mesh as boundary on 3D
5264 op = new SMESHGUI_Make2DFrom3DOp();
5266 case 420: // Reorient faces
5267 op = new SMESHGUI_ReorientFacesOp();
5269 case 701: // Compute mesh
5270 op = new SMESHGUI_ComputeOp();
5272 case 702: // Create mesh
5273 op = new SMESHGUI_MeshOp( true, true );
5275 case 703: // Create sub-mesh
5276 op = new SMESHGUI_MeshOp( true, false );
5278 case 704: // Edit mesh/sub-mesh
5279 op = new SMESHGUI_MeshOp( false );
5281 case 711: // Precompute mesh
5282 op = new SMESHGUI_PrecomputeOp();
5284 case 712: // Evaluate mesh
5285 op = new SMESHGUI_EvaluateOp();
5287 case 713: // Evaluate mesh
5288 op = new SMESHGUI_MeshOrderOp();
5290 case 806: // Create group on geom
5291 op = new SMESHGUI_GroupOnShapeOp();
5293 case 904: // Find element
5294 op = new SMESHGUI_FindElemByPointOp();
5296 case 4067: // Make mesh pass through point
5297 op = new SMESHGUI_MakeNodeAtPointOp();
5299 case 4070: // Create 0D elements on all nodes
5300 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5307 op = SalomeApp_Module::createOperation( id );
5311 //================================================================================
5313 * \brief Stops current operations and starts a given one
5314 * \param id - The id of the operation to start
5316 //================================================================================
5318 void SMESHGUI::switchToOperation(int id)
5320 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5321 activeStudy()->abortAllOperations();
5322 startOperation( id );
5325 LightApp_Displayer* SMESHGUI::displayer()
5328 myDisplayer = new SMESHGUI_Displayer( getApp() );
5332 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5335 int aTolerance = 64;
5336 int anIterations = 0;
5342 if( anIterations % aPeriod == 0 )
5345 if( aTolerance < 1 )
5349 aHue = (int)( 360.0 * rand() / RAND_MAX );
5352 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5353 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5354 for( ; it != itEnd; ++it )
5356 SALOMEDS::Color anAutoColor = *it;
5357 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5360 aQColor.getHsv( &h, &s, &v );
5361 if( abs( h - aHue ) < aTolerance )
5373 aColor.setHsv( aHue, 255, 255 );
5375 SALOMEDS::Color aSColor;
5376 aSColor.R = aColor.redF();
5377 aSColor.G = aColor.greenF();
5378 aSColor.B = aColor.blueF();
5383 const char* gSeparator = "_"; // character used to separate parameter names
5384 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5385 const char* gPathSep = "|"; // character used to separate paths
5388 * \brief Store visual parameters
5390 * This method is called just before the study document is saved.
5391 * Store visual parameters in AttributeParameter attribue(s)
5393 void SMESHGUI::storeVisualParameters (int savePoint)
5396 Kernel_Utils::Localizer loc;
5398 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5399 if (!appStudy || !appStudy->studyDS())
5401 _PTR(Study) studyDS = appStudy->studyDS();
5403 // componentName is used for encoding of entries when storing them in IParameters
5404 std::string componentName = myComponentSMESH->ComponentDataType();
5405 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5406 //if (!aSComponent) return;
5409 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5410 componentName.c_str(),
5412 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5414 // store map of custom markers
5415 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5416 if( !aMarkerMap.empty() )
5418 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5419 for( ; anIter != aMarkerMap.end(); anIter++ )
5421 int anId = anIter->first;
5422 VTK::MarkerData aMarkerData = anIter->second;
5423 std::string aMarkerFileName = aMarkerData.first;
5424 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5425 if( aMarkerTexture.size() < 3 )
5426 continue; // should contain at least width, height and the first value
5428 QString aPropertyName( "texture" );
5429 aPropertyName += gSeparator;
5430 aPropertyName += QString::number( anId );
5432 QString aPropertyValue = aMarkerFileName.c_str();
5433 aPropertyValue += gPathSep;
5435 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5436 ushort aWidth = *aTextureIter++;
5437 ushort aHeight = *aTextureIter++;
5438 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5439 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5440 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5441 aPropertyValue += QString::number( *aTextureIter );
5443 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5447 // viewers counters are used for storing view_numbers in IParameters
5450 // main cycle to store parameters of displayed objects
5451 QList<SUIT_ViewManager*> lst;
5452 QList<SUIT_ViewManager*>::Iterator it;
5453 getApp()->viewManagers(lst);
5454 for (it = lst.begin(); it != lst.end(); it++)
5456 SUIT_ViewManager* vman = *it;
5457 QString vType = vman->getType();
5459 // saving VTK actors properties
5460 if (vType == SVTK_Viewer::Type())
5462 // store the clipping planes attached to the view manager
5463 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5464 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5465 if( anIter != myClippingPlaneInfoMap.end() )
5466 aClippingPlaneInfoList = anIter->second;
5468 if( !aClippingPlaneInfoList.empty() ) {
5469 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5470 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5472 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5473 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5475 QString aPropertyName( "ClippingPlane" );
5476 aPropertyName += gSeparator;
5477 aPropertyName += QString::number( vtkViewers );
5478 aPropertyName += gSeparator;
5479 aPropertyName += QString::number( anId );
5481 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5482 aPropertyValue += gDigitsSep;
5483 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5484 aPropertyValue += gDigitsSep;
5485 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5486 aPropertyValue += gDigitsSep;
5487 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5489 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5493 QVector<SUIT_ViewWindow*> views = vman->getViews();
5494 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5496 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5498 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5499 vtkActorCollection* allActors = aCopy.GetActors();
5500 allActors->InitTraversal();
5501 while (vtkActor* actor = allActors->GetNextActor())
5503 if (actor->GetVisibility()) // store only visible actors
5505 SMESH_Actor* aSmeshActor = 0;
5506 if (actor->IsA("SMESH_Actor"))
5507 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5508 if (aSmeshActor && aSmeshActor->hasIO())
5510 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5513 // entry is "encoded" = it does NOT contain component adress,
5514 // since it is a subject to change on next component loading
5515 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5517 std::string param, vtkParam = vType.toLatin1().data();
5518 vtkParam += gSeparator;
5519 vtkParam += QString::number(vtkViewers).toLatin1().data();
5520 vtkParam += gSeparator;
5523 param = vtkParam + "Visibility";
5524 ip->setParameter(entry, param, "On");
5527 param = vtkParam + "Representation";
5528 ip->setParameter(entry, param, QString::number
5529 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5532 param = vtkParam + "IsShrunk";
5533 ip->setParameter(entry, param, QString::number
5534 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5536 // Displayed entities
5537 unsigned int aMode = aSmeshActor->GetEntityMode();
5538 bool isE = aMode & SMESH_Actor::eEdges;
5539 bool isF = aMode & SMESH_Actor::eFaces;
5540 bool isV = aMode & SMESH_Actor::eVolumes;
5541 bool is0d = aMode & SMESH_Actor::e0DElements;
5542 bool isB = aMode & SMESH_Actor::eBallElem;
5544 QString modeStr ("e");
5545 modeStr += gDigitsSep; modeStr += QString::number(isE);
5546 modeStr += gDigitsSep; modeStr += "f";
5547 modeStr += gDigitsSep; modeStr += QString::number(isF);
5548 modeStr += gDigitsSep; modeStr += "v";
5549 modeStr += gDigitsSep; modeStr += QString::number(isV);
5550 modeStr += gDigitsSep; modeStr += "0d";
5551 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5552 modeStr += gDigitsSep; modeStr += "b";
5553 modeStr += gDigitsSep; modeStr += QString::number(isB);
5555 param = vtkParam + "Entities";
5556 ip->setParameter(entry, param, modeStr.toLatin1().data());
5562 aSmeshActor->GetSufaceColor(r, g, b, delta);
5563 QStringList colorStr;
5564 colorStr << "surface";
5565 colorStr << QString::number(r);
5566 colorStr << QString::number(g);
5567 colorStr << QString::number(b);
5569 colorStr << "backsurface";
5570 colorStr << QString::number(delta);
5572 aSmeshActor->GetVolumeColor(r, g, b, delta);
5573 colorStr << "volume";
5574 colorStr << QString::number(r);
5575 colorStr << QString::number(g);
5576 colorStr << QString::number(b);
5577 colorStr << QString::number(delta);
5579 aSmeshActor->GetEdgeColor(r, g, b);
5581 colorStr << QString::number(r);
5582 colorStr << QString::number(g);
5583 colorStr << QString::number(b);
5585 aSmeshActor->GetNodeColor(r, g, b);
5587 colorStr << QString::number(r);
5588 colorStr << QString::number(g);
5589 colorStr << QString::number(b);
5591 aSmeshActor->GetOutlineColor(r, g, b);
5592 colorStr << "outline";
5593 colorStr << QString::number(r);
5594 colorStr << QString::number(g);
5595 colorStr << QString::number(b);
5597 aSmeshActor->Get0DColor(r, g, b);
5598 colorStr << "elem0d";
5599 colorStr << QString::number(r);
5600 colorStr << QString::number(g);
5601 colorStr << QString::number(b);
5603 aSmeshActor->GetBallColor(r, g, b);
5605 colorStr << QString::number(r);
5606 colorStr << QString::number(g);
5607 colorStr << QString::number(b);
5609 aSmeshActor->GetFacesOrientationColor(r, g, b);
5610 colorStr << "orientation";
5611 colorStr << QString::number(r);
5612 colorStr << QString::number(g);
5613 colorStr << QString::number(b);
5615 param = vtkParam + "Colors";
5616 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5619 QStringList sizeStr;
5621 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5622 sizeStr << "outline";
5623 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5624 sizeStr << "elem0d";
5625 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5627 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5628 sizeStr << "shrink";
5629 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5630 sizeStr << "orientation";
5631 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5632 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5634 param = vtkParam + "Sizes";
5635 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5640 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5641 if( aMarkerType == VTK::MT_USER ) {
5642 markerStr += "custom";
5643 markerStr += gDigitsSep;
5644 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5648 markerStr += gDigitsSep;
5649 markerStr += QString::number( (int)aMarkerType );
5650 markerStr += gDigitsSep;
5651 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5654 param = vtkParam + "PointMarker";
5655 ip->setParameter(entry, param, markerStr.toLatin1().data());
5658 param = vtkParam + "Opacity";
5659 ip->setParameter(entry, param,
5660 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5663 param = vtkParam + "ClippingPlane";
5665 if( !aClippingPlaneInfoList.empty() ) {
5666 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5667 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5669 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5670 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5671 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5672 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5673 if( aSmeshActor == *anIter2 ) {
5674 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5675 QString::number( anId ).toLatin1().constData() );
5682 ip->setParameter( entry, param, "Off" );
5683 } // if (io->hasEntry())
5684 } // SMESH_Actor && hasIO
5686 } // while.. actors traversal
5690 } // if (SVTK view model)
5691 } // for (viewManagers)
5694 // data structures for clipping planes processing
5697 vtkIdType Orientation;
5701 typedef std::list<TPlaneData> TPlaneDataList;
5702 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5704 typedef std::list<vtkActor*> TActorList;
5707 TActorList ActorList;
5708 SUIT_ViewManager* ViewManager;
5710 typedef std::list<TPlaneInfo> TPlaneInfoList;
5711 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5714 * \brief Restore visual parameters
5716 * This method is called after the study document is opened.
5717 * Restore visual parameters from AttributeParameter attribue(s)
5719 void SMESHGUI::restoreVisualParameters (int savePoint)
5722 Kernel_Utils::Localizer loc;
5724 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5725 if (!appStudy || !appStudy->studyDS())
5727 _PTR(Study) studyDS = appStudy->studyDS();
5729 // componentName is used for encoding of entries when storing them in IParameters
5730 std::string componentName = myComponentSMESH->ComponentDataType();
5731 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5732 //if (!aSComponent) return;
5735 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5736 componentName.c_str(),
5738 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5740 // restore map of custom markers and map of clipping planes
5741 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5742 TPlaneDataMap aPlaneDataMap;
5744 std::vector<std::string> properties = ip->getProperties();
5745 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5747 std::string property = *propIt;
5748 QString aPropertyName( property.c_str() );
5749 QString aPropertyValue( ip->getProperty( property ).c_str() );
5751 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5752 if( aPropertyNameList.isEmpty() )
5755 QString aPropertyType = aPropertyNameList[0];
5756 if( aPropertyType == "texture" )
5758 if( aPropertyNameList.size() != 2 )
5762 int anId = aPropertyNameList[1].toInt( &ok );
5763 if( !ok || anId < 1 )
5766 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5767 if( aPropertyValueList.size() != 2 )
5770 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5771 QString aMarkerTextureString = aPropertyValueList[1];
5772 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5773 if( aMarkerTextureStringList.size() != 3 )
5777 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5782 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5786 VTK::MarkerTexture aMarkerTexture;
5787 aMarkerTexture.push_back( aWidth );
5788 aMarkerTexture.push_back( aHeight );
5790 QString aMarkerTextureData = aMarkerTextureStringList[2];
5791 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5793 QChar aChar = aMarkerTextureData.at( i );
5794 if( aChar.isDigit() )
5795 aMarkerTexture.push_back( aChar.digitValue() );
5798 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5800 else if( aPropertyType == "ClippingPlane" )
5802 if( aPropertyNameList.size() != 3 )
5806 int aViewId = aPropertyNameList[1].toInt( &ok );
5807 if( !ok || aViewId < 0 )
5811 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5812 if( !ok || aClippingPlaneId < 0 )
5815 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5816 if( aPropertyValueList.size() != 4 )
5819 TPlaneData aPlaneData;
5820 aPlaneData.Id = aClippingPlaneId;
5823 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5828 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5833 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5838 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5842 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5843 aPlaneDataList.push_back( aPlaneData );
5847 TPlaneInfoMap aPlaneInfoMap;
5849 std::vector<std::string> entries = ip->getEntries();
5851 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5853 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5854 QString entry (ip->decodeEntry(*entIt).c_str());
5856 // Check that the entry corresponds to a real object in the Study
5857 // as the object may be deleted or modified after the visual state is saved.
5858 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5859 if (!so) continue; //Skip the not existent entry
5861 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5862 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5864 std::vector<std::string>::iterator namesIt = paramNames.begin();
5865 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5867 // actors are stored in a map after displaying of them for
5868 // quicker access in the future: map < viewID to actor >
5869 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5871 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5873 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5874 // '_' is used as separator and should not be used in viewer type or parameter names.
5875 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5876 if (lst.size() != 3)
5879 QString viewerTypStr = lst[0];
5880 QString viewIndexStr = lst[1];
5881 QString paramNameStr = lst[2];
5884 int viewIndex = viewIndexStr.toUInt(&ok);
5885 if (!ok) // bad conversion of view index to integer
5889 if (viewerTypStr == SVTK_Viewer::Type())
5891 SMESH_Actor* aSmeshActor = 0;
5892 if (vtkActors.IsBound(viewIndex))
5893 aSmeshActor = vtkActors.Find(viewIndex);
5895 QList<SUIT_ViewManager*> lst;
5896 getApp()->viewManagers(viewerTypStr, lst);
5898 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5899 SUIT_ViewManager* vman = NULL;
5900 if (viewIndex >= 0 && viewIndex < lst.count())
5901 vman = lst.at(viewIndex);
5903 if (paramNameStr == "Visibility")
5905 if (!aSmeshActor && displayer() && vman)
5907 SUIT_ViewModel* vmodel = vman->getViewModel();
5908 // SVTK view model can be casted to SALOME_View
5909 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5911 // store displayed actor in a temporary map for quicker
5912 // access later when restoring other parameters
5913 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5914 vtkRenderer* Renderer = vtkView->getRenderer();
5915 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5916 vtkActorCollection* theActors = aCopy.GetActors();
5917 theActors->InitTraversal();
5918 bool isFound = false;
5919 vtkActor *ac = theActors->GetNextActor();
5920 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5921 if (ac->IsA("SMESH_Actor")) {
5922 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5923 if (aGeomAc->hasIO()) {
5924 Handle(SALOME_InteractiveObject) io =
5925 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5926 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5928 vtkActors.Bind(viewIndex, aGeomAc);
5934 } // if (paramNameStr == "Visibility")
5937 // the rest properties "work" with SMESH_Actor
5940 QString val ((*valuesIt).c_str());
5943 if (paramNameStr == "Representation") {
5944 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5947 else if (paramNameStr == "IsShrunk") {
5949 if (!aSmeshActor->IsShrunk())
5950 aSmeshActor->SetShrink();
5953 if (aSmeshActor->IsShrunk())
5954 aSmeshActor->UnShrink();
5957 // Displayed entities
5958 else if (paramNameStr == "Entities") {
5959 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5960 int aEntityMode = SMESH_Actor::eAllEntity;
5961 for ( int i = 0; i < mode.count(); i+=2 ) {
5962 if ( i < mode.count()-1 ) {
5963 QString type = mode[i];
5964 bool val = mode[i+1].toInt();
5965 if ( type == "e" && !val )
5966 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
5967 else if ( type == "f" && !val )
5968 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
5969 else if ( type == "v" && !val )
5970 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
5971 else if ( type == "0d" && !val )
5972 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
5973 else if ( type == "b" && !val )
5974 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
5977 aSmeshActor->SetEntityMode( aEntityMode );
5980 else if (paramNameStr == "Colors") {
5981 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5988 QColor outlineColor;
5989 QColor orientationColor;
5995 // below lines are required to get default values for delta coefficients
5996 // of backface color for faces and color of reversed volumes
5997 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
5998 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
5999 for ( int i = 0; i < colors.count(); i++ ) {
6000 QString type = colors[i];
6001 if ( type == "surface" ) {
6002 // face color is set by 3 values r:g:b, where
6003 // - r,g,b - is rgb color components
6004 if ( i+1 >= colors.count() ) break; // format error
6005 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6006 if ( i+2 >= colors.count() ) break; // format error
6007 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6008 if ( i+3 >= colors.count() ) break; // format error
6009 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6010 faceColor.setRgbF( r, g, b );
6013 else if ( type == "backsurface" ) {
6014 // backface color can be defined in several ways
6015 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6016 // - in latest versions, it is set as delta coefficient
6017 bool rgbOk = false, deltaOk;
6018 if ( i+1 >= colors.count() ) break; // format error
6019 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6020 int delta = colors[i+1].toInt( &deltaOk );
6022 if ( i+1 < colors.count() ) // index is shifted to 1
6023 g = colors[i+1].toDouble( &rgbOk );
6024 if ( rgbOk ) i++; // shift index
6025 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6026 b = colors[i+1].toDouble( &rgbOk );
6028 // - as currently there's no way to set directly backsurface color as it was before,
6029 // we ignore old dump where r,g,b triple was set
6030 // - also we check that delta parameter is set properly
6031 if ( !rgbOk && deltaOk )
6034 else if ( type == "volume" ) {
6035 // volume color is set by 4 values r:g:b:delta, where
6036 // - r,g,b - is a normal volume rgb color components
6037 // - delta - is a reversed volume color delta coefficient
6038 if ( i+1 >= colors.count() ) break; // format error
6039 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6040 if ( i+2 >= colors.count() ) break; // format error
6041 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6042 if ( i+3 >= colors.count() ) break; // format error
6043 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6044 if ( i+4 >= colors.count() ) break; // format error
6045 int delta = colors[i+4].toInt( &bOk );
6046 if ( !bOk ) break; // format error
6047 volumeColor.setRgbF( r, g, b );
6051 else if ( type == "edge" ) {
6052 // edge color is set by 3 values r:g:b, where
6053 // - r,g,b - is rgb color components
6054 if ( i+1 >= colors.count() ) break; // format error
6055 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6056 if ( i+2 >= colors.count() ) break; // format error
6057 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6058 if ( i+3 >= colors.count() ) break; // format error
6059 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6060 edgeColor.setRgbF( r, g, b );
6063 else if ( type == "node" ) {
6064 // node color is set by 3 values r:g:b, where
6065 // - r,g,b - is rgb color components
6066 if ( i+1 >= colors.count() ) break; // format error
6067 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6068 if ( i+2 >= colors.count() ) break; // format error
6069 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6070 if ( i+3 >= colors.count() ) break; // format error
6071 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6072 nodeColor.setRgbF( r, g, b );
6075 else if ( type == "elem0d" ) {
6076 // 0d element color is set by 3 values r:g:b, where
6077 // - r,g,b - is rgb color components
6078 if ( i+1 >= colors.count() ) break; // format error
6079 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6080 if ( i+2 >= colors.count() ) break; // format error
6081 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6082 if ( i+3 >= colors.count() ) break; // format error
6083 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6084 elem0dColor.setRgbF( r, g, b );
6087 else if ( type == "ball" ) {
6088 // ball color is set by 3 values r:g:b, where
6089 // - r,g,b - is rgb color components
6090 if ( i+1 >= colors.count() ) break; // format error
6091 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6092 if ( i+2 >= colors.count() ) break; // format error
6093 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6094 if ( i+3 >= colors.count() ) break; // format error
6095 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6096 ballColor.setRgbF( r, g, b );
6099 else if ( type == "outline" ) {
6100 // outline color is set by 3 values r:g:b, where
6101 // - r,g,b - is rgb color components
6102 if ( i+1 >= colors.count() ) break; // format error
6103 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6104 if ( i+2 >= colors.count() ) break; // format error
6105 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6106 if ( i+3 >= colors.count() ) break; // format error
6107 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6108 outlineColor.setRgbF( r, g, b );
6111 else if ( type == "orientation" ) {
6112 // orientation color is set by 3 values r:g:b, where
6113 // - r,g,b - is rgb color components
6114 if ( i+1 >= colors.count() ) break; // format error
6115 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6116 if ( i+2 >= colors.count() ) break; // format error
6117 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6118 if ( i+3 >= colors.count() ) break; // format error
6119 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6120 orientationColor.setRgbF( r, g, b );
6125 if ( nodeColor.isValid() )
6126 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6128 if ( edgeColor.isValid() )
6129 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6131 if ( faceColor.isValid() )
6132 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6134 if ( volumeColor.isValid() )
6135 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6136 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6137 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6139 if ( elem0dColor.isValid() )
6140 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6142 if ( ballColor.isValid() )
6143 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6145 if ( outlineColor.isValid() )
6146 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6147 // orientation color
6148 if ( orientationColor.isValid() )
6149 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6152 else if (paramNameStr == "Sizes") {
6153 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6156 int outlineWidth = -1;
6157 int elem0dSize = -1;
6159 double shrinkSize = -1;
6160 double orientationSize = -1;
6161 bool orientation3d = false;
6162 for ( int i = 0; i < sizes.count(); i++ ) {
6163 QString type = sizes[i];
6164 if ( type == "line" ) {
6165 // line (wireframe) width is given as single integer value
6166 if ( i+1 >= sizes.count() ) break; // format error
6167 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6171 if ( type == "outline" ) {
6172 // outline width is given as single integer value
6173 if ( i+1 >= sizes.count() ) break; // format error
6174 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6178 else if ( type == "elem0d" ) {
6179 // 0d element size is given as single integer value
6180 if ( i+1 >= sizes.count() ) break; // format error
6181 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6185 else if ( type == "ball" ) {
6186 // ball size is given as single integer value
6187 if ( i+1 >= sizes.count() ) break; // format error
6188 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6192 else if ( type == "shrink" ) {
6193 // shrink factor is given as single floating point value
6194 if ( i+1 >= sizes.count() ) break; // format error
6195 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6199 else if ( type == "orientation" ) {
6200 // orientation vectors are specified by two values size:3d, where
6201 // - size - is a floating point value specifying scale factor
6202 // - 3d - is a boolean
6203 if ( i+1 >= sizes.count() ) break; // format error
6204 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6205 if ( i+2 >= sizes.count() ) break; // format error
6206 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6207 orientationSize = v1;
6208 orientation3d = (bool)v2;
6212 // line (wireframe) width
6213 if ( lineWidth > 0 )
6214 aSmeshActor->SetLineWidth( lineWidth );
6216 if ( outlineWidth > 0 )
6217 aSmeshActor->SetOutlineWidth( outlineWidth );
6218 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6219 aSmeshActor->SetOutlineWidth( lineWidth );
6221 if ( elem0dSize > 0 )
6222 aSmeshActor->Set0DSize( elem0dSize );
6225 aSmeshActor->SetBallSize( ballSize );
6227 if ( shrinkSize > 0 )
6228 aSmeshActor->SetShrinkFactor( shrinkSize );
6229 // orientation vectors
6230 if ( orientationSize > 0 ) {
6231 aSmeshActor->SetFacesOrientationScale( orientationSize );
6232 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6236 else if (paramNameStr == "PointMarker") {
6237 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6238 if( data.count() >= 2 ) {
6240 int aParam1 = data[1].toInt( &ok );
6242 if( data[0] == "std" && data.count() == 3 ) {
6243 int aParam2 = data[2].toInt( &ok );
6244 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6246 else if( data[0] == "custom" ) {
6247 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6248 if( markerIt != aMarkerMap.end() ) {
6249 VTK::MarkerData aMarkerData = markerIt->second;
6250 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6257 else if (paramNameStr == "Opacity") {
6258 aSmeshActor->SetOpacity(val.toFloat());
6261 else if (paramNameStr.startsWith("ClippingPlane")) {
6262 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6263 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
6264 // new format - val looks like "Off" or "0" (plane id)
6265 // (note: in new format "Off" value is used only for consistency,
6266 // so it is processed together with values in old format)
6267 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
6268 if( anIsOldFormat ) {
6269 if (paramNameStr == "ClippingPlane1" || val == "Off")
6270 aSmeshActor->RemoveAllClippingPlanes();
6272 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
6273 double aDistance = vals[1].toFloat();
6275 anAngle[0] = vals[2].toFloat();
6276 anAngle[1] = vals[3].toFloat();
6278 QList<SUIT_ViewManager*> lst;
6279 getApp()->viewManagers(viewerTypStr, lst);
6280 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6281 if (viewIndex >= 0 && viewIndex < lst.count()) {
6282 SUIT_ViewManager* vman = lst.at(viewIndex);
6283 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6285 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6287 SMESH::TActorList anActorList;
6288 anActorList.push_back( aSmeshActor );
6289 SMESH::OrientedPlane* aPlane =
6290 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
6292 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6293 aClippingPlaneInfo.Plane = aPlane;
6294 aClippingPlaneInfo.ActorList = anActorList;
6295 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6302 int aPlaneId = val.toInt( &ok );
6303 if( ok && aPlaneId >= 0 ) {
6304 bool anIsDefinedPlane = false;
6305 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6306 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6307 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6308 TPlaneInfo& aPlaneInfo = *anIter;
6309 if( aPlaneInfo.PlaneId == aPlaneId ) {
6310 aPlaneInfo.ActorList.push_back( aSmeshActor );
6311 anIsDefinedPlane = true;
6315 if( !anIsDefinedPlane ) {
6316 TPlaneInfo aPlaneInfo;
6317 aPlaneInfo.PlaneId = aPlaneId;
6318 aPlaneInfo.ActorList.push_back( aSmeshActor );
6319 aPlaneInfo.ViewManager = vman;
6321 // to make the list sorted by plane id
6322 anIter = aPlaneInfoList.begin();
6323 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6324 const TPlaneInfo& aPlaneInfoRef = *anIter;
6325 if( aPlaneInfoRef.PlaneId > aPlaneId )
6328 aPlaneInfoList.insert( anIter, aPlaneInfo );
6333 } // if (aSmeshActor)
6334 } // other parameters than Visibility
6336 } // for names/parameters iterator
6337 } // for entries iterator
6339 // take into account planes with empty list of actors referred to them
6340 QList<SUIT_ViewManager*> aVMList;
6341 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6343 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6344 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6345 int aViewId = aPlaneDataIter->first;
6346 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6347 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6349 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6351 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6352 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6353 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6354 const TPlaneData& aPlaneData = *anIter2;
6355 int aPlaneId = aPlaneData.Id;
6357 bool anIsFound = false;
6358 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6359 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6360 const TPlaneInfo& aPlaneInfo = *anIter3;
6361 if( aPlaneInfo.PlaneId == aPlaneId ) {
6368 TPlaneInfo aPlaneInfo; // ActorList field is empty
6369 aPlaneInfo.PlaneId = aPlaneId;
6370 aPlaneInfo.ViewManager = aViewManager;
6372 // to make the list sorted by plane id
6373 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6374 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6375 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6376 if( aPlaneInfoRef.PlaneId > aPlaneId )
6379 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6385 // add clipping planes to actors according to the restored parameters
6386 // and update the clipping plane map
6387 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6388 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6389 int aViewId = anIter1->first;
6390 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6392 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6393 if( anIter2 == aPlaneDataMap.end() )
6395 const TPlaneDataList& aPlaneDataList = anIter2->second;
6397 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6398 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6399 const TPlaneInfo& aPlaneInfo = *anIter3;
6400 int aPlaneId = aPlaneInfo.PlaneId;
6401 const TActorList& anActorList = aPlaneInfo.ActorList;
6402 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6406 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6410 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6412 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6413 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6414 const TPlaneData& aPlaneData = *anIter4;
6415 if( aPlaneData.Id == aPlaneId ) {
6416 SMESH::OrientedPlane* aPlane =
6417 SMESHGUI_ClippingDlg::AddPlane( anActorList,
6419 (SMESH::Orientation)aPlaneData.Orientation,
6420 aPlaneData.Distance,
6423 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6424 aClippingPlaneInfo.Plane = aPlane;
6425 aClippingPlaneInfo.ActorList = anActorList;
6426 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6434 // update all VTK views
6435 QList<SUIT_ViewManager*> lst;
6436 getApp()->viewManagers(lst);
6437 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6438 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6439 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6440 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6441 vtkView->getRenderer()->ResetCameraClippingRange();
6448 \brief Adds preferences for dfont of VTK viewer
6450 \param pIf group identifier
6451 \param param parameter
6452 \return identifier of preferences
6454 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6456 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6458 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6461 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6462 fam.append( tr( "SMESH_FONT_COURIER" ) );
6463 fam.append( tr( "SMESH_FONT_TIMES" ) );
6465 setPreferenceProperty( tfont, "fonts", fam );
6467 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6468 if ( needSize ) f = f | QtxFontEdit::Size;
6469 setPreferenceProperty( tfont, "features", f );
6475 \brief Actions after hypothesis edition
6476 Updates object browser after hypothesis edition
6478 void SMESHGUI::onHypothesisEdit( int result )
6481 SMESHGUI::Modified();
6482 updateObjBrowser( true );
6487 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6488 \param pview view being closed
6490 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6491 #ifndef DISABLE_PLOT2DVIEWER
6492 //Crear all Plot2d Viewers if need.
6493 SMESH::ClearPlot2Viewers(pview);
6497 void SMESHGUI::message( const QString& msg )
6500 QStringList data = msg.split("/");
6501 if ( data.count() > 0 ) {
6502 if ( data.first() == "mesh_loading" ) {
6504 QString entry = data.count() > 1 ? data[1] : QString();
6505 if ( entry.isEmpty() )
6508 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6510 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6513 name = obj->GetName().c_str();
6514 if ( name.isEmpty() )
6517 if ( data.last() == "stop" )
6518 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6520 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6521 QApplication::processEvents();
6527 \brief Connects or disconnects signals about activating and cloning view on the module slots
6528 \param pview view which is connected/disconnected
6530 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6534 SUIT_ViewManager* viewMgr = pview->getViewManager();
6536 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6537 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6539 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6540 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6545 \brief Return \c true if object can be renamed
6547 bool SMESHGUI::renameAllowed( const QString& entry) const {
6548 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6552 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6556 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6561 if(appStudy->isComponent(entry) || obj->isReference())
6564 // check type to prevent renaming of inappropriate objects
6565 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6566 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6567 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6568 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6569 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6570 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6577 Rename object by entry.
6578 \param entry entry of the object
6579 \param name new name of the object
6580 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6582 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6584 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6588 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6593 _PTR(Study) aStudy = appStudy->studyDS();
6598 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6600 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6605 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6606 _PTR(GenericAttribute) anAttr;
6607 _PTR(AttributeName) aName;
6609 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6611 // check type to prevent renaming of inappropriate objects
6612 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6613 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6614 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6615 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6616 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6617 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6618 if ( !name.isEmpty() ) {
6619 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6621 // update name of group object and its actor
6622 Handle(SALOME_InteractiveObject) IObject =
6623 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6625 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6626 if( !aGroupObject->_is_nil() ) {
6627 aGroupObject->SetName( qPrintable(name) );
6628 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6629 anActor->setName( qPrintable(name) );
6640 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6642 static QList<QColor> colors;
6644 if ( colors.isEmpty() ) {
6646 for (int s = 0; s < 2 ; s++)
6648 for (int v = 100; v >= 40; v = v - 20)
6650 for (int h = 0; h < 359 ; h = h + 60)
6652 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
6657 static int currentColor = 0;
6659 SALOMEDS::Color color;
6660 color.R = (double)colors[currentColor].red() / 255.0;
6661 color.G = (double)colors[currentColor].green() / 255.0;
6662 color.B = (double)colors[currentColor].blue() / 255.0;
6664 currentColor = (currentColor+1) % colors.count();