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>
165 #include <SALOMEDS_SObject.hxx>
168 #include <Standard_ErrorHandler.hxx>
169 #include <NCollection_DataMap.hxx>
171 #include <Basics_Utils.hxx>
173 //To disable automatic genericobj management, the following line should be commented.
174 //Otherwise, it should be uncommented.
175 //Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
176 #define WITHGENERICOBJ
178 // Below macro, when uncommented, switches on simplified (more performant) algorithm
179 // of auto-color picking up
180 #define SIMPLE_AUTOCOLOR
184 //=============================================================
185 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
188 void ExportMeshToFile(int theCommandID);
190 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
192 void SetDisplayEntity(int theCommandID);
194 void Control( int theCommandID );
198 //=============================================================
199 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
203 std::string myExtension;
205 if ( theCommandID == 113 ) {
206 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
207 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
209 else if ( theCommandID == 112 ) {
210 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
212 else if ( theCommandID == 111 ) {
213 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
215 else if ( theCommandID == 115 ) {
216 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
218 else if ( theCommandID == 116 ) {
219 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
221 else if ( theCommandID == 117 ) {
222 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
223 filter.append( QObject::tr( "All files (*)" ) );
225 else if ( theCommandID == 118 ) {
226 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
227 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
230 QString anInitialPath = "";
231 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
232 anInitialPath = QDir::currentPath();
234 QStringList filenames;
235 bool toCreateGroups = true;
237 // if ( theCommandID == 118 ) { // GMF
238 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
239 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
240 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
241 // fd->setNameFilters( filter );
242 // fd->SetChecked( true );
244 // filenames << fd->selectedFile();
245 // toCreateGroups = fd->IsChecked();
251 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
254 QObject::tr( "SMESH_IMPORT_MESH" ) );
256 if ( filenames.count() > 0 ) {
257 SUIT_OverrideCursor wc;
258 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
261 QStringList anEntryList;
262 bool isEmpty = false;
263 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
264 QString filename = *it;
265 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
267 switch ( theCommandID ) {
270 // DAT format (currently unsupported)
271 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
272 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
278 aMeshes->length( 1 );
279 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toLatin1().constData() );
280 if ( aMeshes[0]->_is_nil() )
281 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
282 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
288 SMESH::DriverMED_ReadStatus res;
289 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toLatin1().constData(), res );
290 if ( res != SMESH::DRS_OK ) {
291 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
292 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
299 aMeshes->length( 1 );
300 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toLatin1().constData() );
301 if ( aMeshes[0]->_is_nil() ) {
302 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
303 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
310 SMESH::DriverMED_ReadStatus res;
311 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toLatin1().constData(), res );
312 if ( res != SMESH::DRS_OK ) {
313 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
314 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
321 SMESH::DriverMED_ReadStatus res;
322 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toLatin1().constData(), res );
323 if ( res != SMESH::DRS_OK ) {
324 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
325 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
332 SMESH::ComputeError_var res;
333 aMeshes->length( 1 );
334 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toLatin1().constData(),
337 if ( res->code != SMESH::DRS_OK ) {
338 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
339 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
340 if ( strlen( res->comment.in() ) > 0 ) {
341 errors.back() += ": ";
342 errors.back() += res->comment.in();
349 catch ( const SALOME::SALOME_Exception& S_ex ) {
350 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
351 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
354 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
355 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
357 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
358 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
359 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
360 if ( theCommandID == 112 ) // mesh names aren't taken from the file for UNV import
361 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
363 anEntryList.append( aMeshSO->GetID().c_str() );
365 // obj has been published in study. Its refcount has been incremented.
366 // It is safe to decrement its refcount
367 // so that it will be destroyed when the entry in study will be removed
368 aMeshes[i]->UnRegister();
376 // update Object browser
377 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
379 // browse to the published meshes
380 if( LightApp_Application* anApp =
381 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
382 anApp->browseObjects( anEntryList );
384 // show Error message box if there were errors
385 if ( errors.count() > 0 ) {
386 SUIT_MessageBox::critical( SMESHGUI::desktop(),
387 QObject::tr( "SMESH_ERROR" ),
388 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
391 // show warning message box, if some imported mesh is empty
393 SUIT_MessageBox::warning( SMESHGUI::desktop(),
394 QObject::tr( "SMESH_WRN_WARNING" ),
395 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
400 //================================================================================
402 * \brief Export selected meshes or groups into a file
404 //================================================================================
406 void ExportMeshToFile( int theCommandID )
408 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
409 SALOME_ListIO selected;
411 aSel->selectedObjects( selected );
413 const bool isMED = ( theCommandID == 122 || theCommandID == 125 );
414 const bool isDAT = ( theCommandID == 121 || theCommandID == 124 );
415 const bool isUNV = ( theCommandID == 123 || theCommandID == 126 );
416 const bool isSTL = ( theCommandID == 140 || theCommandID == 141 );
417 const bool isCGNS= ( theCommandID == 142 || theCommandID == 143 );
418 const bool isSAUV= ( theCommandID == 144 || theCommandID == 145 );
419 const bool isGMF = ( theCommandID == 146 || theCommandID == 147 );
421 // actually, the following condition can't be met (added for insurance)
422 if( selected.Extent() == 0 ||
423 ( selected.Extent() > 1 && !isMED && !isSTL ))
426 // get mesh object from selection and check duplication of their names
427 bool hasDuplicatedMeshNames = false;
428 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
429 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
430 SALOME_ListIteratorOfListIO It( selected );
431 for( ; It.More(); It.Next() )
433 Handle(SALOME_InteractiveObject) anIObject = It.Value();
434 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
435 if ( aMeshItem->_is_nil() ) {
436 SUIT_MessageBox::warning( SMESHGUI::desktop(),
437 QObject::tr( "SMESH_WRN_WARNING" ),
438 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
442 QString aMeshName = anIObject->getName();
444 // check for name duplications
445 if ( !hasDuplicatedMeshNames )
446 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
447 if( aMeshName == (*aMeshIter).second ) {
448 hasDuplicatedMeshNames = true;
453 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
456 if( hasDuplicatedMeshNames && isMED ) {
457 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
458 QObject::tr("SMESH_WRN_WARNING"),
459 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
460 QObject::tr("SMESH_BUT_YES"),
461 QObject::tr("SMESH_BUT_NO"), 0, 1);
466 aMeshIter = aMeshList.begin();
467 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
468 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
469 QString aMeshName = (*aMeshIter).second;
471 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
473 // check for equal group names within each mesh
474 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
475 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
476 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
477 int aRet = SUIT_MessageBox::warning
478 (SMESHGUI::desktop(),
479 QObject::tr("SMESH_WRN_WARNING"),
480 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
481 QObject::tr("SMESH_BUT_YES"),
482 QObject::tr("SMESH_BUT_NO"), 0, 1);
489 // Warn the user about presence of not supported elements
491 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
495 notSupportedElemTypes.push_back( SMESH::Entity_0D );
496 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
501 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
502 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
503 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
504 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
505 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
506 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
507 notSupportedElemTypes.push_back( SMESH::Entity_0D );
508 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
513 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
514 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
515 notSupportedElemTypes.push_back( SMESH::Entity_0D );
516 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
521 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
522 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
527 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
528 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
529 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
530 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
531 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
532 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
533 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
538 notSupportedElemTypes.push_back( SMESH::Entity_0D );
539 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
540 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
541 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
542 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
543 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
544 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
545 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
546 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
548 if ( ! notSupportedElemTypes.empty() )
550 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
551 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
552 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
553 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
555 if ( !presentNotSupported.empty() )
558 const char* typeMsg[SMESH::Entity_Last] = {
559 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
560 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
561 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
562 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
563 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
564 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
565 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
566 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
568 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
569 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
570 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
571 if ( iType != presentNotSupported.size() - 1 )
572 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
574 int aRet = SUIT_MessageBox::warning
575 (SMESHGUI::desktop(),
576 QObject::tr("SMESH_WRN_WARNING"),
577 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
578 QObject::tr("SMESH_BUT_YES"),
579 QObject::tr("SMESH_BUT_NO"), 0, 1);
584 // Get parameters of export operation
587 SMESH::MED_VERSION aFormat;
588 // Init the parameters with the default values
589 bool aIsASCII_STL = true;
590 bool toCreateGroups = false;
591 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
593 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
594 bool toOverwrite = true;
595 bool toFindOutDim = true;
597 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
598 QString anInitialPath = "";
599 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
600 anInitialPath = QDir::currentPath();
602 // Get a file name to write in and additional otions
603 if ( isUNV || isDAT || isGMF ) // Export w/o options
606 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
608 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
610 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
611 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
612 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
613 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
614 anInitialPath + QString("/") + aMeshName,
615 aFilter, aTitle, false);
617 else if ( isCGNS )// Export to CGNS
619 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
620 fd->setWindowTitle( aTitle );
621 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
622 if ( !anInitialPath.isEmpty() )
623 fd->setDirectory( anInitialPath );
624 fd->selectFile(aMeshName);
625 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
626 fd->setValidator( fv );
629 aFilename = fd->selectedFile();
630 toOverwrite = fv->isOverwrite();
634 else if ( isSTL ) // Export to STL
636 QMap<QString, int> aFilterMap;
637 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
638 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
641 QMap<QString, int>::const_iterator it = aFilterMap.begin();
642 for ( ; it != aFilterMap.end(); ++it )
643 filters.push_back( it.key() );
645 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
646 fd->setWindowTitle( aTitle );
647 fd->setNameFilters( filters );
648 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
649 if ( !anInitialPath.isEmpty() )
650 fd->setDirectory( anInitialPath );
651 fd->selectFile(aMeshName);
655 aFilename = fd->selectedFile();
656 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
661 else if ( isMED || isSAUV ) // Export to MED or SAUV
663 QMap<QString, SMESH::MED_VERSION> aFilterMap;
664 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
666 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
667 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
668 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
671 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
672 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
673 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
677 QString aDefaultFilter;
678 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
679 for ( ; it != aFilterMap.end(); ++it ) {
680 filters.push_back( it.key() );
681 if (it.value() == SMESH::MED_V2_2)
682 aDefaultFilter = it.key();
684 QStringList checkBoxes;
685 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
687 SalomeApp_CheckFileDlg* fd =
688 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
689 fd->setWindowTitle( aTitle );
690 fd->setNameFilters( filters );
691 fd->selectNameFilter(aDefaultFilter);
692 fd->SetChecked(0,toCreateGroups);
693 fd->SetChecked(1,toFindOutDim);
694 if ( !anInitialPath.isEmpty() )
695 fd->setDirectory( anInitialPath );
696 fd->selectFile(aMeshName);
698 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
699 fd->setValidator( fv );
704 aFilename = fd->selectedFile();
706 aFilename = QString::null;
709 aFormat = aFilterMap[fd->selectedNameFilter()];
710 toOverwrite = fv->isOverwrite();
712 if ( !aFilename.isEmpty() ) {
713 // med-2.1 does not support poly elements
714 if ( aFormat==SMESH::MED_V2_1 )
715 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
716 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
717 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
718 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
719 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
721 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
722 QObject::tr("SMESH_WRN_WARNING"),
723 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
724 QObject::tr("SMESH_BUT_YES"),
725 QObject::tr("SMESH_BUT_NO"), 0, 1);
733 // can't append to an existing using other format
734 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
735 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toLatin1().constData(), aVersion );
736 if( !isVersionOk || aVersion != aFormat ) {
737 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
738 QObject::tr("SMESH_WRN_WARNING"),
739 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
740 QObject::tr("SMESH_BUT_YES"),
741 QObject::tr("SMESH_BUT_NO"), 0, 1);
748 QStringList aMeshNamesCollisionList;
749 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toLatin1().constData() );
750 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
751 QString anExistingMeshName( aMeshNames[ i ] );
752 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
753 QString anExportMeshName = (*aMeshIter).second;
754 if( anExportMeshName == anExistingMeshName ) {
755 aMeshNamesCollisionList.append( anExportMeshName );
760 if( !aMeshNamesCollisionList.isEmpty() ) {
761 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
762 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
763 QObject::tr("SMESH_WRN_WARNING"),
764 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
765 QObject::tr("SMESH_BUT_YES"),
766 QObject::tr("SMESH_BUT_NO"),
767 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
776 toCreateGroups = fd->IsChecked(0);
777 toFindOutDim = fd->IsChecked(1);
787 if ( !aFilename.isEmpty() ) {
788 // Check whether the file already exists and delete it if yes
789 QFile aFile( aFilename );
790 if ( aFile.exists() && toOverwrite )
792 SUIT_OverrideCursor wc;
795 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
796 // bool Renumber = false;
797 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
799 // Renumber= resMgr->booleanValue("renumbering");
801 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
802 // aMeshEditor->RenumberNodes();
803 // aMeshEditor->RenumberElements();
804 // if ( SMESHGUI::automaticUpdate() )
805 // SMESH::UpdateView();
809 aMeshIter = aMeshList.begin();
810 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
812 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
813 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
814 if ( aMeshOrGroup->_is_equivalent( aMeshItem ))
815 aMeshItem->ExportToMEDX( aFilename.toLatin1().data(), toCreateGroups,
816 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
818 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups,
819 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
824 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
826 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
827 if( !aMeshItem->_is_nil() )
828 aMeshItem->ExportSAUV( aFilename.toLatin1().data(), toCreateGroups );
833 if ( aMeshOrGroup->_is_equivalent( aMesh ))
834 aMesh->ExportDAT( aFilename.toLatin1().data() );
836 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toLatin1().data() );
840 if ( aMeshOrGroup->_is_equivalent( aMesh ))
841 aMesh->ExportUNV( aFilename.toLatin1().data() );
843 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toLatin1().data() );
847 if ( aMeshOrGroup->_is_equivalent( aMesh ))
848 aMesh->ExportSTL( aFilename.toLatin1().data(), aIsASCII_STL );
850 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toLatin1().data(), aIsASCII_STL );
854 aMeshIter = aMeshList.begin();
855 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
857 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
858 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
859 aMeshItem->ExportCGNS( aMeshOrGroup,
860 aFilename.toLatin1().data(),
861 toOverwrite && aMeshIndex == 0 );
866 toCreateGroups = true;
867 aMesh->ExportGMF( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups );
870 catch (const SALOME::SALOME_Exception& S_ex){
872 SUIT_MessageBox::warning(SMESHGUI::desktop(),
873 QObject::tr("SMESH_WRN_WARNING"),
874 QObject::tr("SMESH_EXPORT_FAILED"));
880 inline void InverseEntityMode(unsigned int& theOutputMode,
881 unsigned int theMode)
883 bool anIsNotPresent = ~theOutputMode & theMode;
885 theOutputMode |= theMode;
887 theOutputMode &= ~theMode;
890 void SetDisplayEntity(int theCommandID){
891 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
892 SALOME_ListIO selected;
894 aSel->selectedObjects( selected );
896 if(selected.Extent() >= 1){
897 SALOME_ListIteratorOfListIO It( selected );
898 for( ; It.More(); It.Next()){
899 Handle(SALOME_InteractiveObject) IObject = It.Value();
900 if(IObject->hasEntry()){
901 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
902 unsigned int aMode = anActor->GetEntityMode();
903 switch(theCommandID){
905 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
908 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
911 InverseEntityMode(aMode,SMESH_Actor::eEdges);
914 InverseEntityMode(aMode,SMESH_Actor::eFaces);
917 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
920 aMode = SMESH_Actor::eAllEntity;
924 anActor->SetEntityMode(aMode);
932 SALOME_ListIO selected;
933 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
937 LightApp_SelectionMgr* aSel = app->selectionMgr();
938 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
939 if( !aSel || !appStudy )
942 aSel->selectedObjects( selected );
943 if( selected.IsEmpty() )
946 Handle(SALOME_InteractiveObject) anIObject = selected.First();
948 _PTR(Study) aStudy = appStudy->studyDS();
949 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
950 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
951 if( aMainObject->_is_nil() )
954 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
956 QList<SALOMEDS::Color> aReservedColors;
958 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
959 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
961 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
962 //SALOMEDS::Color aColor = aGroupObject->GetColor();
964 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
965 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
966 #else // old algorithm for auto-colors
967 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
968 aReservedColors.append( aColor );
969 #endif // SIMPLE_AUTOCOLOR
971 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
975 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
976 switch ( aGroupObject->GetType ()) {
978 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
980 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
982 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
984 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
986 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
987 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
990 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
991 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
997 SMESH::RepaintCurrentView();
1000 void OverallMeshQuality() {
1001 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1002 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1003 SALOME_ListIO selected;
1005 aSel->selectedObjects( selected );
1007 if ( selected.IsEmpty() ) return;
1008 SALOME_ListIteratorOfListIO It( selected );
1009 for ( ; It.More(); It.Next() ) {
1010 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1011 ctrlDlg->showInfo( It.Value() );
1016 QString functorToString( SMESH::Controls::FunctorPtr f )
1018 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1019 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1020 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1021 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1022 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1023 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1024 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1025 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1026 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1027 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1028 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1029 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1030 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1031 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1032 type = QObject::tr( "WARP_ELEMENTS" );
1033 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1034 type = QObject::tr( "TAPER_ELEMENTS" );
1035 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1036 type = QObject::tr( "SKEW_ELEMENTS" );
1037 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1038 type = QObject::tr( "AREA_ELEMENTS" );
1039 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1040 type = QObject::tr( "LENGTH_EDGES" );
1041 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1042 type = QObject::tr( "LENGTH2D_EDGES" );
1043 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1044 type = QObject::tr( "MULTI_BORDERS" );
1045 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1046 type = QObject::tr( "MULTI2D_BORDERS" );
1047 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1048 type = QObject::tr( "FREE_NODES" );
1049 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1050 type = QObject::tr( "FREE_EDGES" );
1051 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1052 type = QObject::tr( "FREE_BORDERS" );
1053 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1054 type = QObject::tr( "FREE_FACES" );
1055 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1056 type = QObject::tr( "BARE_BORDER_VOLUME" );
1057 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1058 type = QObject::tr( "BARE_BORDER_FACE" );
1059 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1060 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1061 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1062 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1063 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1064 type = QObject::tr( "EQUAL_NODE" );
1065 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1066 type = QObject::tr( "EQUAL_EDGE" );
1067 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1068 type = QObject::tr( "EQUAL_FACE" );
1069 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1070 type = QObject::tr( "EQUAL_VOLUME" );
1074 void SaveDistribution()
1076 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1077 SALOME_ListIO selected;
1079 aSel->selectedObjects( selected );
1081 if ( selected.Extent() == 1 ) {
1082 Handle(SALOME_InteractiveObject) anIO = selected.First();
1083 if ( anIO->hasEntry() ) {
1084 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1085 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1086 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1087 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1088 if ( aScalarBarActor && aFunctor ) {
1089 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1091 std::vector<int> elements;
1092 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1093 if ( mesh->_is_nil() ) {
1094 SMESH::SMESH_IDSource_var idSource =
1095 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1096 if ( !idSource->_is_nil() )
1098 SMESH::long_array_var ids = idSource->GetIDs();
1099 elements.resize( ids->length() );
1100 for ( unsigned i = 0; i < elements.size(); ++i )
1101 elements[i] = ids[i];
1104 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1105 vtkLookupTable* lookupTable =
1106 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1107 double * minmax = lookupTable->GetRange();
1108 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1109 std::vector<int> nbEvents;
1110 std::vector<double> funValues;
1111 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
1112 QString anInitialPath = "";
1113 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1114 anInitialPath = QDir::currentPath();
1115 QString aMeshName = anIO->getName();
1117 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1118 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1119 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1120 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1121 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1124 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1126 if ( !aFilename.isEmpty() ) {
1127 QFile f( aFilename );
1128 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1129 QTextStream out( &f );
1130 out << "# Mesh: " << aMeshName << endl;
1131 out << "# Control: " << functorToString( aFunctor ) << endl;
1133 out.setFieldWidth( 10 );
1134 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1135 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1146 void ShowDistribution() {
1147 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1148 SALOME_ListIO selected;
1150 aSel->selectedObjects( selected );
1152 if ( selected.Extent() == 1 ) {
1153 Handle(SALOME_InteractiveObject) anIO = selected.First();
1154 if ( anIO->hasEntry() ) {
1155 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1156 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1157 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1158 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1164 #ifndef DISABLE_PLOT2DVIEWER
1165 void PlotDistribution() {
1166 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1170 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1171 SALOME_ListIO selected;
1173 aSel->selectedObjects( selected );
1175 if ( selected.Extent() == 1 ) {
1176 Handle(SALOME_InteractiveObject) anIO = selected.First();
1177 if ( anIO->hasEntry() ) {
1178 //Find Actor by entry before getting Plot2d viewer,
1179 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1180 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1182 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1187 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1191 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1195 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1196 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1197 QString functorName = functorToString( anActor->GetFunctor());
1198 QString aHistogramName("%1 : %2");
1199 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1200 aHistogram->setName(aHistogramName);
1201 aHistogram->setHorTitle(functorName);
1202 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1203 aPlot->displayObject(aHistogram, true);
1208 #endif //DISABLE_PLOT2DVIEWER
1210 void DisableAutoColor(){
1211 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1212 SALOME_ListIO selected;
1214 aSel->selectedObjects( selected );
1216 if(selected.Extent()){
1217 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1218 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1219 if ( !aMesh->_is_nil() ) {
1220 aMesh->SetAutoColor( false );
1225 void sortChildren(){
1226 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1227 SALOME_ListIO selected;
1229 aSel->selectedObjects( selected );
1231 if(selected.Extent()){
1232 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1233 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1234 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1236 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1237 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1244 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1246 SALOME_ListIO selected;
1247 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1251 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1252 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1253 if( !aSel || !appStudy )
1256 if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection
1257 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1258 aModule->EmitSignalDeactivateDialog();
1259 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1260 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1265 _PTR(Study) aStudy = appStudy->studyDS();
1267 aSel->selectedObjects( selected );
1269 if(selected.Extent() >= 1){
1270 switch(theCommandID){
1272 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1273 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1278 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1279 QColor orientationColor, outlineColor, volumeColor;
1280 int deltaF = 0, deltaV = 0;
1284 int outlineWidth = 1;
1285 double shrinkCoef = 0.0;
1286 double orientationScale = 0.0;
1287 bool orientation3d = false;
1288 VTK::MarkerType markerType = VTK::MT_NONE;
1289 VTK::MarkerScale markerScale = VTK::MS_NONE;
1291 bool hasNodes = false;
1292 int presentEntities = 0;
1293 bool firstTime = true;
1295 SALOME_ListIteratorOfListIO It( selected );
1296 for ( ; It.More(); It.Next() ) {
1297 Handle(SALOME_InteractiveObject) IObject = It.Value();
1298 if ( !IObject->hasEntry() ) continue;
1299 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1300 if ( !anActor || !anActor->GetObject() ) continue;
1303 // nodes: color, marker
1304 anActor->GetNodeColor( color[0], color[1], color[2] );
1305 nodeColor.setRgbF( color[0], color[1], color[2] );
1306 markerType = anActor->GetMarkerType();
1307 markerScale = anActor->GetMarkerScale();
1308 markerId = anActor->GetMarkerTexture();
1309 // edges: color, width
1310 anActor->GetEdgeColor( color[0], color[1], color[2] );
1311 edgeColor.setRgbF( color[0], color[1], color[2] );
1312 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1313 // faces: front color, back color (delta)
1314 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1315 faceColor.setRgbF( color[0], color[1], color[2] );
1316 // faces: front color, back color (delta)
1317 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1318 volumeColor.setRgbF( color[0], color[1], color[2] );
1319 // 0d elements: color, size
1320 anActor->Get0DColor( color[0], color[1], color[2] );
1321 elem0dColor.setRgbF( color[0], color[1], color[2] );
1322 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1323 // balls: color, size
1324 anActor->GetBallColor( color[0], color[1], color[2] );
1325 ballColor.setRgbF( color[0], color[1], color[2] );
1326 ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1328 anActor->GetOutlineColor( color[0], color[1], color[2] );
1329 outlineColor.setRgbF( color[0], color[1], color[2] );
1330 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1331 // orientation vectors: color, scale, 3d flag
1332 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1333 orientationColor.setRgbF( color[0], color[1], color[2] );
1334 orientationScale = anActor->GetFacesOrientationScale();
1335 orientation3d = anActor->GetFacesOrientation3DVectors();
1337 shrinkCoef = anActor->GetShrinkFactor();
1340 firstTime = false; // we only take properties from first object (for performance reasons)
1343 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1344 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1345 presentEntities = presentEntities | SMESH_Actor::eEdges;
1346 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1347 presentEntities = presentEntities | SMESH_Actor::eFaces;
1348 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1349 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1350 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1351 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1352 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1353 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1355 // as we know that all types of elements are present, we can exit the loop
1356 if ( presentEntities == SMESH_Actor::eAllEntity )
1360 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1361 // nodes: color, marker
1362 dlg.setNodeColor( nodeColor );
1363 if( markerType != VTK::MT_USER )
1364 dlg.setNodeMarker( markerType, markerScale );
1366 dlg.setNodeCustomMarker( markerId );
1367 // edges: color, line width
1368 dlg.setEdgeColor( edgeColor );
1369 dlg.setEdgeWidth( edgeWidth );
1370 // faces: front color, back color
1371 dlg.setFaceColor( faceColor, deltaF );
1372 // volumes: normal color, reversed color
1373 dlg.setVolumeColor( volumeColor, deltaV );
1374 // outlines: color, line width
1375 dlg.setOutlineColor( outlineColor );
1376 dlg.setOutlineWidth( outlineWidth );
1377 // 0d elements: color, size
1378 dlg.setElem0dColor( elem0dColor );
1379 dlg.setElem0dSize( elem0dSize );
1380 // balls: color, size
1381 dlg.setBallColor( ballColor );
1382 dlg.setBallSize( ballSize );
1383 // orientation: color, scale, 3d flag
1384 dlg.setOrientationColor( orientationColor );
1385 dlg.setOrientationSize( int( orientationScale * 100. ) );
1386 dlg.setOrientation3d( orientation3d );
1387 // shrink: scale factor
1388 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1389 // hide unused controls
1390 dlg.showControls( presentEntities, hasNodes );
1393 nodeColor = dlg.nodeColor();
1394 markerType = dlg.nodeMarkerType();
1395 markerScale = dlg.nodeMarkerScale();
1396 markerId = dlg.nodeMarkerId();
1397 edgeColor = dlg.edgeColor();
1398 edgeWidth = dlg.edgeWidth();
1399 faceColor = dlg.faceColor();
1400 deltaF = dlg.faceColorDelta();
1401 volumeColor = dlg.volumeColor();
1402 deltaV = dlg.volumeColorDelta();
1403 outlineColor = dlg.outlineColor();
1404 outlineWidth = dlg.outlineWidth();
1405 elem0dColor = dlg.elem0dColor();
1406 elem0dSize = dlg.elem0dSize();
1407 ballColor = dlg.ballColor();
1408 ballSize = dlg.ballSize();
1409 orientationColor = dlg.orientationColor();
1410 orientationScale = dlg.orientationSize() / 100.;
1411 orientation3d = dlg.orientation3d();
1412 shrinkCoef = dlg.shrinkCoef() / 100.;
1414 // store point markers map that might be changed by the user
1415 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1417 // set properties from dialog box to the presentations
1418 SALOME_ListIteratorOfListIO It( selected );
1419 for ( ; It.More(); It.Next() ) {
1420 Handle(SALOME_InteractiveObject) IObject = It.Value();
1421 if ( !IObject->hasEntry() ) continue;
1422 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1423 if ( !anActor ) continue;
1425 // nodes: color, marker
1426 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1427 if ( markerType != VTK::MT_USER ) {
1428 anActor->SetMarkerStd( markerType, markerScale );
1431 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1432 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1433 if ( iter != markerMap.end() )
1434 anActor->SetMarkerTexture( markerId, iter->second.second );
1436 // volumes: normal color, reversed color (delta)
1437 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1438 // faces: front color, back color (delta)
1439 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1440 // edges: color, width
1441 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1442 anActor->SetLineWidth( edgeWidth );
1444 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1445 anActor->SetOutlineWidth( outlineWidth );
1446 // 0D elements: color, size
1447 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1448 anActor->Set0DSize( elem0dSize );
1449 // balls: color, size
1450 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1451 anActor->SetBallSize( ballSize );
1452 // orientation: color, scale, 3d flag
1453 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1454 anActor->SetFacesOrientationScale( orientationScale );
1455 anActor->SetFacesOrientation3DVectors( orientation3d );
1457 anActor->SetShrinkFactor( shrinkCoef );
1459 // for groups, set also proper color
1460 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1461 if ( !aGroupObject->_is_nil() ) {
1462 SMESH::ElementType anElementType = aGroupObject->GetType();
1464 switch( anElementType ) {
1466 aColor = nodeColor; break;
1468 aColor = edgeColor; break;
1470 aColor = faceColor; break;
1472 aColor = volumeColor; break;
1474 aColor = elem0dColor; break;
1476 aColor = ballColor; break;
1480 if ( aColor.isValid() ) {
1481 SALOMEDS::Color aGroupColor;
1482 aGroupColor.R = aColor.redF();
1483 aGroupColor.G = aColor.greenF();
1484 aGroupColor.B = aColor.blueF();
1485 aGroupObject->SetColor( aGroupColor );
1487 } // if ( !aGroupObject->_is_nil() )
1488 } // for ( ; It.More(); It.Next() )
1489 SMESH::RepaintCurrentView();
1490 } // if ( dlg.exec() )
1493 } // switch(theCommandID)
1494 SALOME_ListIteratorOfListIO It( selected );
1495 for( ; It.More(); It.Next()){
1496 Handle(SALOME_InteractiveObject) IObject = It.Value();
1497 if(IObject->hasEntry()){
1498 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1499 switch(theCommandID){
1501 anActor->SetRepresentation(SMESH_Actor::eEdge);
1504 anActor->SetRepresentation(SMESH_Actor::eSurface);
1507 if(anActor->IsShrunk())
1508 anActor->UnShrink();
1510 anActor->SetShrink();
1513 anActor->SetRepresentation(SMESH_Actor::ePoint);
1516 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1517 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1520 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1521 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1527 SMESH::RepaintCurrentView();
1531 void Control( int theCommandID )
1533 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1534 SALOME_ListIO selected;
1536 aSel->selectedObjects( selected );
1538 if( !selected.IsEmpty() ){
1539 Handle(SALOME_InteractiveObject) anIO = selected.First();
1541 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1542 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1543 switch ( theCommandID ){
1545 aControl = SMESH_Actor::eLength;
1548 aControl = SMESH_Actor::eLength2D;
1551 aControl = SMESH_Actor::eFreeEdges;
1554 aControl = SMESH_Actor::eFreeBorders;
1557 aControl = SMESH_Actor::eMultiConnection;
1560 aControl = SMESH_Actor::eFreeNodes;
1563 aControl = SMESH_Actor::eMultiConnection2D;
1566 aControl = SMESH_Actor::eArea;
1569 aControl = SMESH_Actor::eTaper;
1572 aControl = SMESH_Actor::eAspectRatio;
1575 aControl = SMESH_Actor::eAspectRatio3D;
1578 aControl = SMESH_Actor::eMinimumAngle;
1581 aControl = SMESH_Actor::eWarping;
1584 aControl = SMESH_Actor::eSkew;
1587 aControl = SMESH_Actor::eVolume3D;
1590 aControl = SMESH_Actor::eFreeFaces;
1593 aControl = SMESH_Actor::eMaxElementLength2D;
1596 aControl = SMESH_Actor::eMaxElementLength3D;
1599 aControl = SMESH_Actor::eBareBorderVolume;
1602 aControl = SMESH_Actor::eBareBorderFace;
1605 aControl = SMESH_Actor::eOverConstrainedVolume;
1608 aControl = SMESH_Actor::eOverConstrainedFace;
1611 aControl = SMESH_Actor::eCoincidentNodes;
1614 aControl = SMESH_Actor::eCoincidentElems1D;
1617 aControl = SMESH_Actor:: eCoincidentElems2D;
1620 aControl = SMESH_Actor::eCoincidentElems3D;
1624 anActor->SetControlMode(aControl);
1625 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1626 SMESH::RepaintCurrentView();
1627 #ifndef DISABLE_PLOT2DVIEWER
1628 if(anActor->GetPlot2Histogram()) {
1629 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1630 QString functorName = functorToString( anActor->GetFunctor());
1631 QString aHistogramName("%1 : %2");
1632 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1633 aHistogram->setName(aHistogramName);
1634 aHistogram->setHorTitle(functorName);
1635 SMESH::ProcessIn2DViewers(anActor);
1644 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1645 SMESH::MeshObjectType theType,
1646 const QString theInTypeName,
1647 QString & theOutTypeName)
1649 SMESH_TypeFilter aTypeFilter( theType );
1651 if( !theIO.IsNull() )
1653 entry = theIO->getEntry();
1654 LightApp_DataOwner owner( entry );
1655 if ( aTypeFilter.isOk( &owner )) {
1656 theOutTypeName = theInTypeName;
1664 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1666 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1667 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1669 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1670 CORBA::String_var anID = aSComp->GetID().c_str();
1671 if (!strcmp(anID.in(),theIO->getEntry()))
1677 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1678 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1679 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1680 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1681 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1689 QString CheckHomogeneousSelection()
1691 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1692 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1693 SALOME_ListIO selected;
1695 aSel->selectedObjects( selected );
1697 QString RefType = CheckTypeObject(selected.First());
1698 SALOME_ListIteratorOfListIO It(selected);
1699 for ( ; It.More(); It.Next())
1701 Handle(SALOME_InteractiveObject) IObject = It.Value();
1702 QString Type = CheckTypeObject(IObject);
1703 if (Type.compare(RefType) != 0)
1704 return "Heterogeneous Selection";
1711 void SMESHGUI::OnEditDelete()
1713 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1714 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1715 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1717 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1718 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1719 _PTR(GenericAttribute) anAttr;
1720 _PTR(AttributeIOR) anIOR;
1722 int objectCount = 0;
1724 QString aParentComponent = QString::null;
1725 Handle(SALOME_InteractiveObject) anIO;
1726 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1728 anIO = anIt.Value();
1729 QString cur = anIO->getComponentDataType();
1730 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1732 // check if object is reference
1733 _PTR(SObject) aRefSObj;
1734 aNameList.append("\n - ");
1735 if ( aSO->ReferencedObject( aRefSObj ) ) {
1736 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1737 aNameList.append( aRefName );
1738 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1741 aNameList.append(anIO->getName());
1745 if( aParentComponent.isNull() )
1746 aParentComponent = cur;
1747 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1748 aParentComponent = "";
1751 if ( objectCount == 0 )
1752 return; // No Valid Objects Selected
1754 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1755 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1756 QObject::tr("ERR_ERROR"),
1757 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1760 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1761 if (SUIT_MessageBox::warning
1762 (SMESHGUI::desktop(),
1763 QObject::tr("SMESH_WRN_WARNING"),
1764 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1765 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1766 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1769 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1771 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1772 // then treat them all starting from the deepest objects (at list back)
1773 std::list< _PTR(SObject) > listSO;
1774 SALOME_ListIteratorOfListIO It(selected);
1775 for( ; It.More(); It.Next()) // loop on selected IO's
1777 Handle(SALOME_InteractiveObject) IObject = It.Value();
1778 if(IObject->hasEntry()) {
1779 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1781 // disable removal of "SMESH" component object
1782 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1784 if ( engineIOR() == anIOR->Value().c_str() )
1787 //Check the referenced object
1788 _PTR(SObject) aRefSObject;
1789 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1790 aSO = aRefSObject; // Delete main Object instead of reference
1792 listSO.push_back( aSO );
1793 std::list< _PTR(SObject) >::iterator itSO = listSO.begin();
1794 for ( ; itSO != listSO.end(); ++itSO ) {
1795 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1796 for (it->InitEx(false); it->More(); it->Next())
1797 listSO.push_back( it->Value() );
1801 // Check if none of objects to delete is referred from outside
1802 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1803 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1805 _PTR(SObject) SO = *ritSO;
1806 if ( !SO ) continue;
1807 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1808 for (size_t i = 0; i < aReferences.size(); i++) {
1809 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1810 std::string type = aComponent->ComponentDataType();
1811 if ( type != "SMESH" )
1813 SUIT_MessageBox::warning( anApp->desktop(),
1814 QObject::tr("WRN_WARNING"),
1815 QObject::tr("DEP_OBJECT") );
1816 return; // outside SMESH, there is an object depending on a SMESH object
1821 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1822 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1824 Handle(SALOME_InteractiveObject) IObject = It.Value();
1825 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1826 if ( !mesh->_is_nil() )
1830 // Treat SO's in the list starting from the back
1831 aStudyBuilder->NewCommand(); // There is a transaction
1832 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1834 _PTR(SObject) SO = *ritSO;
1835 if ( !SO ) continue;
1836 std::string anEntry = SO->GetID();
1838 /** Erase graphical object **/
1839 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1840 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1841 // ViewManagerList aViewMenegers = anApp->viewManagers();
1842 // ViewManagerList::const_iterator it = aViewMenegers.begin();
1843 // for( ; it != aViewMenegers.end(); it++) {
1844 // SUIT_ViewManager* vm = *it;
1845 // int nbSf = vm ? vm->getViewsCount() : 0;
1847 // QVector<SUIT_ViewWindow*> aViews = vm->getViews();
1848 // for(int i = 0; i < nbSf; i++){
1849 // SUIT_ViewWindow *sf = aViews[i];
1850 // if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
1851 // SMESH::RemoveActor(sf,anActor);
1857 /** Remove an object from data structures **/
1858 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1859 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1860 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1861 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1862 aMesh->RemoveGroup( aGroup );
1864 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1865 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1866 aMesh->RemoveSubMesh( aSubMesh );
1868 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1870 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1873 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1874 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1875 QString objType = CheckTypeObject(IObject);
1876 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1877 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1878 aStudyBuilder->RemoveObjectWithChildren( SO );
1880 else {// default action: remove SObject from the study
1881 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1882 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1884 aStudyBuilder->RemoveObjectWithChildren( SO );
1888 } /* listSO back loop */
1890 aStudyBuilder->CommitCommand();
1892 /* Clear any previous selection */
1894 aSel->setSelectedObjects( l1 );
1896 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1901 SMESHGUI_EXPORT CAM_Module* createModule()
1903 return new SMESHGUI();
1906 SMESHGUI_EXPORT char* getModuleVersion() {
1907 return (char*)SMESH_VERSION_STR;
1911 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1913 //=============================================================================
1917 //=============================================================================
1918 SMESHGUI::SMESHGUI() :
1919 SalomeApp_Module( "SMESH" )
1921 if ( CORBA::is_nil( myComponentSMESH ) )
1923 CORBA::Boolean anIsEmbeddedMode;
1924 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1925 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1927 // 0019923: EDF 765 SMESH : default values of hypothesis
1928 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1929 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1930 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1931 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1932 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1934 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1935 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1936 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1938 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1939 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1943 myActiveDialogBox = 0;
1944 myFilterLibraryDlg = 0;
1948 myEventCallbackCommand = vtkCallbackCommand::New();
1949 myEventCallbackCommand->Delete();
1950 myEventCallbackCommand->SetClientData( this );
1951 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1954 /* load resources for all available meshers */
1955 SMESH::InitAvailableHypotheses();
1958 //=============================================================================
1962 //=============================================================================
1963 SMESHGUI::~SMESHGUI()
1967 //=============================================================================
1971 //=============================================================================
1972 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1974 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1976 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1981 //=============================================================================
1985 //=============================================================================
1986 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1988 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1992 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
1993 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1994 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
1995 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
1996 return autoUpdate && !exceeded;
1999 //=============================================================================
2003 //=============================================================================
2004 bool SMESHGUI::automaticUpdate( SMESH::SMESH_Mesh_ptr theMesh,
2005 int* entities, bool* limitExceeded )
2007 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2011 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2012 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2013 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2015 long requestedSize = theMesh->NbElements();
2017 *entities = SMESH_Actor::eAllEntity;
2019 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2021 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2023 if ( incrementalLimit ) {
2024 long nbOdElems = theMesh->Nb0DElements();
2025 long nbEdges = theMesh->NbEdges();
2026 long nbFaces = theMesh->NbFaces();
2027 long nbVolumes = theMesh->NbVolumes();
2028 long nbBalls = theMesh->NbBalls();
2031 if ( nbOdElems > 0 ) {
2032 if ( total + nbOdElems > updateLimit )
2033 *entities = *entities & ~SMESH_Actor::e0DElements;
2039 if ( nbEdges > 0 ) {
2040 if ( total + nbEdges > updateLimit )
2041 *entities = *entities & ~SMESH_Actor::eEdges;
2047 if ( nbFaces > 0 ) {
2048 if ( total + nbFaces > updateLimit )
2049 *entities = *entities & ~SMESH_Actor::eFaces;
2055 if ( nbVolumes > 0 ) {
2056 if ( total + nbVolumes > updateLimit )
2057 *entities = *entities & ~SMESH_Actor::eVolumes;
2063 if ( nbBalls > 0 ) {
2064 if ( total + nbBalls > updateLimit )
2065 *entities = *entities & ~SMESH_Actor::eBallElem;
2072 return autoUpdate && !exceeded;
2075 //=============================================================================
2079 //=============================================================================
2080 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2082 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2085 //=============================================================================
2089 //=============================================================================
2090 SMESHGUI* SMESHGUI::GetSMESHGUI()
2092 SMESHGUI* smeshMod = 0;
2093 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2096 CAM_Module* module = app->module( "Mesh" );
2097 smeshMod = dynamic_cast<SMESHGUI*>( module );
2100 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2102 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2105 _PTR(Study) aStudy = study->studyDS();
2107 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2116 Standard_EXPORT SMESHGUI* GetComponentGUI()
2118 return SMESHGUI::GetSMESHGUI();
2122 //=============================================================================
2126 //=============================================================================
2127 void SMESHGUI::SetState(int aState)
2132 //=============================================================================
2136 //=============================================================================
2137 void SMESHGUI::ResetState()
2142 //=============================================================================
2146 //=============================================================================
2147 void SMESHGUI::EmitSignalDeactivateDialog()
2149 emit SignalDeactivateActiveDialog();
2152 //=============================================================================
2156 //=============================================================================
2157 void SMESHGUI::EmitSignalStudyFrameChanged()
2159 emit SignalStudyFrameChanged();
2162 //=============================================================================
2166 //=============================================================================
2167 void SMESHGUI::EmitSignalCloseAllDialogs()
2169 emit SignalCloseAllDialogs();
2172 //=============================================================================
2176 //=============================================================================
2177 void SMESHGUI::EmitSignalVisibilityChanged()
2179 emit SignalVisibilityChanged();
2182 //=============================================================================
2186 //=============================================================================
2187 QDialog *SMESHGUI::GetActiveDialogBox()
2189 return myActiveDialogBox;
2192 //=============================================================================
2196 //=============================================================================
2197 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2199 myActiveDialogBox = (QDialog *) aDlg;
2203 //=============================================================================
2207 //=============================================================================
2208 SUIT_Desktop* SMESHGUI::desktop()
2210 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2212 return app->desktop();
2217 //=============================================================================
2221 //=============================================================================
2222 SalomeApp_Study* SMESHGUI::activeStudy()
2224 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2226 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2231 //=============================================================================
2235 //=============================================================================
2236 void SMESHGUI::Modified( bool theIsUpdateActions )
2238 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2239 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2240 appStudy->Modified();
2241 if( theIsUpdateActions )
2242 app->updateActions();
2247 //=============================================================================
2251 //=============================================================================
2252 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2254 /* Here the position is on the bottom right corner - 10 */
2255 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2257 SUIT_Desktop *PP = desktop();
2258 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2259 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2263 //=============================================================================
2267 //=============================================================================
2268 static int isStudyLocked(_PTR(Study) theStudy){
2269 return theStudy->GetProperties()->IsLocked();
2272 static bool checkLock(_PTR(Study) theStudy) {
2273 if (isStudyLocked(theStudy)) {
2274 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2275 QObject::tr("WRN_WARNING"),
2276 QObject::tr("WRN_STUDY_LOCKED") );
2282 //=======================================================================
2283 //function : CheckActiveStudyLocked
2285 //=======================================================================
2287 bool SMESHGUI::isActiveStudyLocked()
2289 _PTR(Study) aStudy = activeStudy()->studyDS();
2290 return checkLock( aStudy );
2293 //=============================================================================
2297 //=============================================================================
2298 bool SMESHGUI::OnGUIEvent( int theCommandID )
2300 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2304 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2305 SUIT_ResourceMgr* mgr = resourceMgr();
2309 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2310 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2313 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2314 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2316 //QAction* act = action( theCommandID );
2318 switch (theCommandID) {
2320 if(checkLock(aStudy)) break;
2332 if(checkLock(aStudy)) break;
2333 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2337 case 150: //MED FILE INFORMATION
2339 SALOME_ListIO selected;
2340 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2342 aSel->selectedObjects( selected );
2343 if( selected.Extent() )
2345 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2346 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2347 if ( !aMesh->_is_nil() )
2349 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2356 case 122: // EXPORT MED
2371 ::ExportMeshToFile(theCommandID);
2375 case 200: // SCALAR BAR
2377 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2378 SALOME_ListIO selected;
2380 aSel->selectedObjects( selected );
2382 if( selected.Extent() ) {
2383 Handle(SALOME_InteractiveObject) anIO = selected.First();
2384 if( anIO->hasEntry() ) {
2385 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2386 anActor->SetControlMode( SMESH_Actor::eNone );
2387 #ifndef DISABLE_PLOT2DVIEWER
2388 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2397 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2402 // dump control distribution data to the text file
2403 ::SaveDistribution();
2409 // show/ distribution
2410 ::ShowDistribution();
2414 #ifndef DISABLE_PLOT2DVIEWER
2417 // plot distribution
2418 ::PlotDistribution();
2429 ::DisableAutoColor();
2432 case 1134: // Clipping
2433 case 1133: // Tranparency
2434 case 1132: // Display preferences (colors, shrink size, line width, ...)
2441 ::SetDisplayMode(theCommandID, myMarkerMap);
2444 //2D quadratic representation
2447 ::SetDisplayMode(theCommandID, myMarkerMap);
2451 case 216: // 0D elements
2454 case 219: // Volumes
2455 case 220: // All Entity
2457 ::SetDisplayEntity(theCommandID);
2460 case 221: // Orientation of faces
2462 LightApp_SelectionMgr* mgr = selectionMgr();
2463 SALOME_ListIO selected; mgr->selectedObjects( selected );
2465 SALOME_ListIteratorOfListIO it(selected);
2466 for( ; it.More(); it.Next()) {
2467 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2468 if(anIObject->hasEntry()) {
2469 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2470 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2479 if(checkLock(aStudy)) break;
2480 SUIT_OverrideCursor wc;
2482 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2485 SMESH::UpdateView();
2487 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2488 SMESH::OnVisuException();
2490 catch (...) { // PAL16774 (Crash after display of many groups)
2491 SMESH::OnVisuException();
2495 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2496 aSel->selectedObjects( l );
2497 aSel->setSelectedObjects( l );
2502 case 301: // DISPLAY
2503 case 302: // DISPLAY ONLY
2505 SMESH::EDisplaing anAction;
2506 switch (theCommandID) {
2507 case 300: anAction = SMESH::eErase; break;
2508 case 301: anAction = SMESH::eDisplay; break;
2509 case 302: anAction = SMESH::eDisplayOnly; break;
2512 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2513 SALOME_ListIO sel_objects, to_process;
2515 aSel->selectedObjects( sel_objects );
2517 if( theCommandID==302 )
2519 MESSAGE("anAction = SMESH::eDisplayOnly");
2520 startOperation( myEraseAll );
2523 extractContainers( sel_objects, to_process );
2526 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2530 SALOME_ListIteratorOfListIO It( to_process );
2531 for ( ; It.More(); It.Next()) {
2533 Handle(SALOME_InteractiveObject) IOS = It.Value();
2534 if (IOS->hasEntry()) {
2536 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2537 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2538 break; // PAL16774 (Crash after display of many groups)
2540 if (anAction == SMESH::eDisplayOnly)
2542 MESSAGE("anAction = SMESH::eDisplayOnly");
2543 anAction = SMESH::eDisplay;
2549 // PAL13338 + PAL15161 -->
2550 if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2551 MESSAGE("anAction = SMESH::eDisplayOnly");
2552 SMESH::UpdateView();
2553 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2555 // PAL13338 + PAL15161 <--
2557 catch (...) { // PAL16774 (Crash after display of many groups)
2558 SMESH::OnVisuException();
2561 if (anAction == SMESH::eErase) {
2562 MESSAGE("anAction == SMESH::eErase");
2564 aSel->setSelectedObjects( l1 );
2567 aSel->setSelectedObjects( to_process );
2574 if(checkLock(aStudy)) break;
2577 EmitSignalDeactivateDialog();
2579 ( new SMESHGUI_NodesDlg( this ) )->show();
2582 SUIT_MessageBox::warning(desktop(),
2583 tr("SMESH_WRN_WARNING"),
2584 tr("SMESH_WRN_VIEWER_VTK"));
2589 case 2151: // FILTER
2593 EmitSignalDeactivateDialog();
2594 ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2599 case 701: // COMPUTE MESH
2600 case 711: // PRECOMPUTE MESH
2601 case 712: // EVALUATE MESH
2602 case 713: // MESH ORDER
2603 case 702: // Create mesh
2604 case 703: // Create sub-mesh
2605 case 704: // Edit mesh/sub-mesh
2606 startOperation( theCommandID );
2608 case 705: // copy mesh
2610 if (checkLock(aStudy)) break;
2611 EmitSignalDeactivateDialog();
2612 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2615 case 710: // Build compound mesh
2617 if (checkLock(aStudy)) break;
2618 EmitSignalDeactivateDialog();
2619 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2623 case 407: // DIAGONAL INVERSION
2624 case 408: // Delete diagonal
2628 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2629 tr( "NOT_A_VTK_VIEWER" ) );
2633 if ( checkLock( aStudy ) )
2636 /*Standard_Boolean aRes;
2637 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2638 if ( aMesh->_is_nil() )
2640 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2641 tr( "SMESH_BAD_SELECTION" ) );
2645 EmitSignalDeactivateDialog();
2646 if ( theCommandID == 407 )
2647 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2649 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2652 case 409: // Change orientation
2653 case 410: // Union of triangles
2654 case 411: // Cutting of quadrangles
2655 case 419: // Splitting volumes into tetrahedra
2659 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2660 tr( "NOT_A_VTK_VIEWER" ) );
2664 if ( checkLock( aStudy ) )
2667 EmitSignalDeactivateDialog();
2668 SMESHGUI_MultiEditDlg* aDlg = NULL;
2669 if ( theCommandID == 409 )
2670 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2671 else if ( theCommandID == 410 )
2672 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2673 else if ( theCommandID == 419 )
2674 aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2676 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2681 case 412: // Smoothing
2683 if(checkLock(aStudy)) break;
2685 EmitSignalDeactivateDialog();
2686 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2689 SUIT_MessageBox::warning(desktop(),
2690 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2694 case 413: // Extrusion
2696 if (checkLock(aStudy)) break;
2698 EmitSignalDeactivateDialog();
2699 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2701 SUIT_MessageBox::warning(desktop(),
2702 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2706 case 414: // Revolution
2708 if(checkLock(aStudy)) break;
2710 EmitSignalDeactivateDialog();
2711 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2714 SUIT_MessageBox::warning(desktop(),
2715 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2719 case 415: // Pattern mapping
2721 if ( checkLock( aStudy ) )
2725 EmitSignalDeactivateDialog();
2726 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2729 SUIT_MessageBox::warning(desktop(),
2730 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2734 case 416: // Extrusion along a path
2736 if (checkLock(aStudy)) break;
2738 EmitSignalDeactivateDialog();
2739 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2741 SUIT_MessageBox::warning(desktop(),
2742 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2746 case 417: // Convert mesh to quadratic
2747 case 418: // create 2D mesh from 3D
2748 case 420: // Reorient faces
2749 case 806: // CREATE GEO GROUP
2751 startOperation( theCommandID );
2754 case 801: // CREATE GROUP
2758 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2759 tr( "NOT_A_VTK_VIEWER" ) );
2763 if(checkLock(aStudy)) break;
2764 EmitSignalDeactivateDialog();
2765 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2767 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2768 SALOME_ListIO selected;
2770 aSel->selectedObjects( selected );
2772 int nbSel = selected.Extent();
2774 // check if mesh is selected
2775 aMesh = SMESH::GetMeshByIO( selected.First() );
2777 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2782 case 802: // CONSTRUCT GROUP
2786 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2787 tr( "NOT_A_VTK_VIEWER" ) );
2791 if(checkLock(aStudy)) break;
2792 EmitSignalDeactivateDialog();
2794 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2795 SALOME_ListIO selected;
2797 aSel->selectedObjects( selected );
2799 int nbSel = selected.Extent();
2801 // check if submesh is selected
2802 Handle(SALOME_InteractiveObject) IObject = selected.First();
2803 if (IObject->hasEntry()) {
2804 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2806 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2807 if (!aSubMesh->_is_nil()) {
2809 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2810 // get submesh elements list by types
2811 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2812 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2813 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2814 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2815 // create group for each type o elements
2816 QString aName = IObject->getName();
2817 QStringList anEntryList;
2818 if (aNodes->length() > 0) {
2819 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2820 aGroup->Add(aNodes.inout());
2821 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2822 anEntryList.append( aSObject->GetID().c_str() );
2824 if (aEdges->length() > 0) {
2825 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2826 aGroup->Add(aEdges.inout());
2827 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2828 anEntryList.append( aSObject->GetID().c_str() );
2830 if (aFaces->length() > 0) {
2831 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2832 aGroup->Add(aFaces.inout());
2833 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2834 anEntryList.append( aSObject->GetID().c_str() );
2836 if (aVolumes->length() > 0) {
2837 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2838 aGroup->Add(aVolumes.inout());
2839 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2840 anEntryList.append( aSObject->GetID().c_str() );
2843 anApp->browseObjects( anEntryList );
2845 catch(const SALOME::SALOME_Exception & S_ex){
2846 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2853 SUIT_MessageBox::warning(desktop(),
2854 tr("SMESH_WRN_WARNING"),
2855 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2860 case 803: // EDIT GROUP
2864 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2865 tr( "NOT_A_VTK_VIEWER" ) );
2869 if(checkLock(aStudy)) break;
2870 EmitSignalDeactivateDialog();
2872 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2873 SALOME_ListIO selected;
2875 aSel->selectedObjects( selected );
2877 SALOME_ListIteratorOfListIO It (selected);
2878 int nbSelectedGroups = 0;
2879 for ( ; It.More(); It.Next() )
2881 SMESH::SMESH_GroupBase_var aGroup =
2882 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2883 if (!aGroup->_is_nil()) {
2885 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2889 if (nbSelectedGroups == 0)
2891 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2897 case 804: // Add elements to group
2899 if(checkLock(aStudy)) break;
2900 if (myState == 800) {
2901 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2902 if (aDlg) aDlg->onAdd();
2907 case 805: // Remove elements from group
2909 if(checkLock(aStudy)) break;
2910 if (myState == 800) {
2911 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2912 if (aDlg) aDlg->onRemove();
2917 case 815: // Edit GEOM GROUP as standalone
2921 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2922 tr( "NOT_A_VTK_VIEWER" ) );
2926 if(checkLock(aStudy)) break;
2927 EmitSignalDeactivateDialog();
2929 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2930 SALOME_ListIO selected;
2932 aSel->selectedObjects( selected );
2934 SALOME_ListIteratorOfListIO It (selected);
2935 for ( ; It.More(); It.Next() )
2937 SMESH::SMESH_GroupOnGeom_var aGroup =
2938 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2939 if (!aGroup->_is_nil()) {
2940 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2945 SMESH::SMESH_GroupOnFilter_var aGroup =
2946 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2947 if (!aGroup->_is_nil()) {
2948 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2956 case 810: // Union Groups
2957 case 811: // Intersect groups
2958 case 812: // Cut groups
2962 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2963 tr( "NOT_A_VTK_VIEWER" ) );
2967 if ( checkLock( aStudy ) )
2970 EmitSignalDeactivateDialog();
2972 SMESHGUI_GroupOpDlg* aDlg = 0;
2973 if ( theCommandID == 810 )
2974 aDlg = new SMESHGUI_UnionGroupsDlg( this );
2975 else if ( theCommandID == 811 )
2976 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2978 aDlg = new SMESHGUI_CutGroupsDlg( this );
2985 case 814: // Create groups of entities from existing groups of superior dimensions
2987 if ( checkLock( aStudy ) )
2990 EmitSignalDeactivateDialog();
2991 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2997 case 813: // Delete groups with their contents
3001 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3002 tr( "NOT_A_VTK_VIEWER" ) );
3006 if ( checkLock( aStudy ) )
3009 EmitSignalDeactivateDialog();
3011 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3015 case 900: // MESH INFOS
3016 case 903: // WHAT IS
3018 int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3019 EmitSignalDeactivateDialog();
3020 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3021 SALOME_ListIO selected;
3023 aSel->selectedObjects( selected );
3025 if ( selected.Extent() > 1 ) { // a dlg for each IO
3026 SALOME_ListIteratorOfListIO It( selected );
3027 for ( ; It.More(); It.Next() ) {
3028 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3029 dlg->showInfo( It.Value() );
3034 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3040 case 904: // FIND ELEM
3042 startOperation( theCommandID );
3046 case 1100: // EDIT HYPOTHESIS
3048 if(checkLock(aStudy)) break;
3050 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3051 SALOME_ListIO selected;
3053 aSel->selectedObjects( selected );
3055 int nbSel = selected.Extent();
3058 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3059 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3061 /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
3062 /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects */
3063 /* Warning : however by internal mechanism all subMeshes icons are changed ! */
3064 if ( !aHypothesis->_is_nil() )
3067 //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
3068 SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
3070 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3080 case 1102: // REMOVE HYPOTHESIS / ALGORITHMS
3082 if(checkLock(aStudy)) break;
3083 SUIT_OverrideCursor wc;
3085 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3086 SALOME_ListIO selected;
3088 aSel->selectedObjects( selected, QString::null, false );
3090 SALOME_ListIteratorOfListIO It(selected);
3091 for (int i = 0; It.More(); It.Next(), i++) {
3092 Handle(SALOME_InteractiveObject) IObject = It.Value();
3093 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3096 aSel->setSelectedObjects( l1 );
3102 case 4009: // ELEM0D
3104 case 4021: // TRIANGLE
3106 case 4023: // POLYGON
3110 case 4134: // PYRAMID
3111 case 4135: // OCTA12
3113 if(checkLock(aStudy)) break;
3115 EmitSignalDeactivateDialog();
3116 SMDSAbs_EntityType type = SMDSEntity_Edge;
3117 switch (theCommandID) {
3118 case 4008: type = SMDSEntity_Ball; break;
3119 case 4009: type = SMDSEntity_0D; break;
3120 case 4021: type = SMDSEntity_Triangle; break;
3121 case 4022: type = SMDSEntity_Quadrangle; break;
3122 case 4031: type = SMDSEntity_Tetra; break;
3123 case 4023: type = SMDSEntity_Polygon; break;
3124 case 4032: type = SMDSEntity_Hexa; break;
3125 case 4133: type = SMDSEntity_Penta; break;
3126 case 4134: type = SMDSEntity_Pyramid; break;
3127 case 4135: type = SMDSEntity_Hexagonal_Prism; break;
3130 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3133 SUIT_MessageBox::warning(desktop(),
3134 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3138 case 4033: // POLYHEDRON
3140 if(checkLock(aStudy)) break;
3142 EmitSignalDeactivateDialog();
3143 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3146 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3147 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3151 case 4034: // QUADRATIC EDGE
3152 case 4035: // QUADRATIC TRIANGLE
3153 case 4036: // QUADRATIC QUADRANGLE
3154 case 4136: // BIQUADRATIC QUADRANGLE
3155 case 4137: // BIQUADRATIC TRIANGLE
3156 case 4037: // QUADRATIC TETRAHEDRON
3157 case 4038: // QUADRATIC PYRAMID
3158 case 4039: // QUADRATIC PENTAHEDRON
3159 case 4040: // QUADRATIC HEXAHEDRON
3160 case 4140: // TRIQUADRATIC HEXAHEDRON
3162 if(checkLock(aStudy)) break;
3164 EmitSignalDeactivateDialog();
3165 SMDSAbs_EntityType type = SMDSEntity_Last;
3167 switch (theCommandID) {
3168 case 4034: type = SMDSEntity_Quad_Edge; break;
3169 case 4035: type = SMDSEntity_Quad_Triangle; break;
3170 case 4036: type = SMDSEntity_Quad_Quadrangle; break;
3171 case 4136: type = SMDSEntity_BiQuad_Quadrangle; break;
3172 case 4137: type = SMDSEntity_BiQuad_Triangle; break;
3173 case 4037: type = SMDSEntity_Quad_Tetra; break;
3174 case 4038: type = SMDSEntity_Quad_Pyramid; break;
3175 case 4039: type = SMDSEntity_Quad_Penta; break;
3176 case 4040: type = SMDSEntity_Quad_Hexa; break;
3177 case 4140: type = SMDSEntity_TriQuad_Hexa; break;
3180 if ( type != SMDSEntity_Last )
3181 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3184 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3185 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3189 case 4041: // REMOVES NODES
3191 if(checkLock(aStudy)) break;
3193 EmitSignalDeactivateDialog();
3194 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3197 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3198 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3202 case 4042: // REMOVES ELEMENTS
3204 if(checkLock(aStudy)) break;
3206 EmitSignalDeactivateDialog();
3207 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3211 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3212 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3216 case 4043: { // CLEAR_MESH
3218 if(checkLock(aStudy)) break;
3220 SALOME_ListIO selected;
3221 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3222 aSel->selectedObjects( selected );
3224 SUIT_OverrideCursor wc;
3225 SALOME_ListIteratorOfListIO It (selected);
3226 for ( ; It.More(); It.Next() )
3228 Handle(SALOME_InteractiveObject) IOS = It.Value();
3229 SMESH::SMESH_Mesh_var aMesh =
3230 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3231 if ( aMesh->_is_nil()) continue;
3233 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3235 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3236 SMESH::ModifiedMesh( aMeshSObj, false, true);
3237 // hide groups and submeshes
3238 _PTR(ChildIterator) anIter =
3239 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3240 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3242 _PTR(SObject) so = anIter->Value();
3243 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3246 catch (const SALOME::SALOME_Exception& S_ex){
3248 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3252 SMESH::UpdateView();
3256 case 4044: // REMOVE ORPHAN NODES
3258 if(checkLock(aStudy)) break;
3259 SALOME_ListIO selected;
3260 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3261 aSel->selectedObjects( selected );
3262 if ( selected.Extent() == 1 ) {
3263 Handle(SALOME_InteractiveObject) anIO = selected.First();
3264 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3265 if ( !aMesh->_is_nil() ) {
3266 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3267 tr( "SMESH_WARNING" ),
3268 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3269 SUIT_MessageBox::Yes |
3270 SUIT_MessageBox::No,
3271 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3274 SUIT_OverrideCursor wc;
3275 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3276 int removed = aMeshEditor->RemoveOrphanNodes();
3277 SUIT_MessageBox::information(SMESHGUI::desktop(),
3278 tr("SMESH_INFORMATION"),
3279 tr("NB_NODES_REMOVED").arg(removed));
3280 if ( removed > 0 ) {
3281 SMESH::UpdateView();
3282 SMESHGUI::Modified();
3285 catch (const SALOME::SALOME_Exception& S_ex) {
3286 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3295 case 4051: // RENUMBERING NODES
3297 if(checkLock(aStudy)) break;
3299 EmitSignalDeactivateDialog();
3300 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3304 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3305 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3309 case 4052: // RENUMBERING ELEMENTS
3311 if(checkLock(aStudy)) break;
3313 EmitSignalDeactivateDialog();
3314 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3318 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3319 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3323 case 4061: // TRANSLATION
3325 if(checkLock(aStudy)) break;
3327 EmitSignalDeactivateDialog();
3328 ( new SMESHGUI_TranslationDlg( this ) )->show();
3331 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3332 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3336 case 4062: // ROTATION
3338 if(checkLock(aStudy)) break;
3340 EmitSignalDeactivateDialog();
3341 ( new SMESHGUI_RotationDlg( this ) )->show();
3344 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3345 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3349 case 4063: // SYMMETRY
3351 if(checkLock(aStudy)) break;
3353 EmitSignalDeactivateDialog();
3354 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3357 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3358 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3362 case 4064: // SEWING
3364 if(checkLock(aStudy)) break;
3366 EmitSignalDeactivateDialog();
3367 ( new SMESHGUI_SewingDlg( this ) )->show();
3370 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3371 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3375 case 4065: // MERGE NODES
3377 if(checkLock(aStudy)) break;
3379 EmitSignalDeactivateDialog();
3380 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3383 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3384 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3388 case 4066: // MERGE EQUAL ELEMENTS
3390 if (checkLock(aStudy)) break;
3392 EmitSignalDeactivateDialog();
3393 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3395 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3396 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3401 case 4067: // MAKE MESH PASS THROUGH POINT
3402 startOperation( 4067 );
3407 if(checkLock(aStudy)) break;
3409 EmitSignalDeactivateDialog();
3410 ( new SMESHGUI_ScaleDlg( this ) )->show();
3413 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3414 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3419 case 4069: // DUPLICATE NODES
3421 if(checkLock(aStudy)) break;
3423 EmitSignalDeactivateDialog();
3424 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3427 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3428 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3433 case 4070: // 0D_ON_ALL_NODES
3434 startOperation( 4070 );
3437 case 5105: // Library of selection filters
3439 static QList<int> aTypes;
3440 if ( aTypes.isEmpty() )
3442 aTypes.append( SMESH::NODE );
3443 aTypes.append( SMESH::EDGE );
3444 aTypes.append( SMESH::FACE );
3445 aTypes.append( SMESH::VOLUME );
3447 if (!myFilterLibraryDlg)
3448 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3449 else if (myFilterLibraryDlg->isHidden())
3450 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3451 myFilterLibraryDlg->raise();
3455 case 6017: // CONTROLS
3483 LightApp_SelectionMgr* mgr = selectionMgr();
3484 SALOME_ListIO selected; mgr->selectedObjects( selected );
3486 if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3487 _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3489 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3490 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
3491 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3492 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
3493 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3494 SUIT_OverrideCursor wc;
3495 ::Control( theCommandID );
3500 SUIT_MessageBox::warning(desktop(),
3501 tr( "SMESH_WRN_WARNING" ),
3502 tr( "SMESH_BAD_SELECTION" ) );
3506 SUIT_MessageBox::warning(desktop(),
3507 tr( "SMESH_WRN_WARNING" ),
3508 tr( "NOT_A_VTK_VIEWER" ) );
3512 OverallMeshQuality();
3516 SUIT_OverrideCursor wc;
3517 LightApp_SelectionMgr* mgr = selectionMgr();
3518 SALOME_ListIO selected; mgr->selectedObjects( selected );
3520 SALOME_ListIteratorOfListIO it(selected);
3521 for( ; it.More(); it.Next()) {
3522 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3523 if(anIObject->hasEntry()) {
3524 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3525 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3533 SUIT_OverrideCursor wc;
3534 LightApp_SelectionMgr* mgr = selectionMgr();
3535 SALOME_ListIO selected; mgr->selectedObjects( selected );
3537 SALOME_ListIteratorOfListIO it(selected);
3538 for( ; it.More(); it.Next()) {
3539 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3540 if(anIObject->hasEntry())
3541 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3542 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3550 int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3551 EmitSignalDeactivateDialog();
3552 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3562 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3563 //updateObjBrowser();
3567 //=============================================================================
3571 //=============================================================================
3572 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3577 //=============================================================================
3581 //=============================================================================
3582 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3587 //=============================================================================
3591 //=============================================================================
3592 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3597 //=============================================================================
3598 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3599 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3601 //=============================================================================
3602 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3603 SUIT_ViewWindow* wnd )
3605 if(theIO->hasEntry()){
3606 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3607 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3611 //=======================================================================
3612 // function : createSMESHAction
3614 //=======================================================================
3615 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3616 const int key, const bool toggle, const QString& shortcutAction )
3619 QWidget* parent = application()->desktop();
3620 SUIT_ResourceMgr* resMgr = resourceMgr();
3622 if ( !icon_id.isEmpty() )
3623 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3625 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3626 if ( !pix.isNull() )
3627 icon = QIcon( pix );
3629 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3630 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3631 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3633 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3634 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3637 //=======================================================================
3638 // function : createPopupItem
3640 //=======================================================================
3641 void SMESHGUI::createPopupItem( const int id,
3642 const QString& clients,
3643 const QString& types,
3644 const QString& theRule,
3647 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3648 popupMgr()->insert( action( id ), pId, 0 );
3650 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3651 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3652 QString rule = "(%1) and (%2) and (%3)";
3653 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3654 if( clients.isEmpty() )
3655 rule = rule.arg( QString( "true" ) );
3657 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3658 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3661 bool cont = myRules.contains( id );
3663 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3665 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3666 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3669 //=======================================================================
3670 // function : initialize
3672 //=======================================================================
3673 void SMESHGUI::initialize( CAM_Application* app )
3675 SalomeApp_Module::initialize( app );
3677 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3679 /* Automatic Update flag */
3680 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3682 // ----- create actions --------------
3684 //createSMESHAction( 111, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3685 createSMESHAction( 112, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3686 createSMESHAction( 113, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3687 createSMESHAction( 114, "NUM" );
3688 createSMESHAction( 115, "IMPORT_STL" );
3689 createSMESHAction( 116, "IMPORT_CGNS" );
3690 createSMESHAction( 117, "IMPORT_SAUV" );
3691 createSMESHAction( 118, "IMPORT_GMF" );
3692 createSMESHAction( 121, "DAT" );
3693 createSMESHAction( 122, "MED" );
3694 createSMESHAction( 123, "UNV" );
3695 createSMESHAction( 140, "STL" );
3696 createSMESHAction( 142, "CGNS");
3697 createSMESHAction( 144, "SAUV");
3698 createSMESHAction( 146, "GMF" );
3699 createSMESHAction( 124, "DAT" );
3700 createSMESHAction( 125, "MED" );
3701 createSMESHAction( 126, "UNV" );
3702 createSMESHAction( 141, "STL" );
3703 createSMESHAction( 143, "CGNS");
3704 createSMESHAction( 145, "SAUV");
3705 createSMESHAction( 147, "GMF" );
3706 createSMESHAction( 150, "FILE_INFO" );
3707 createSMESHAction( 33, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3708 createSMESHAction( 5105, "SEL_FILTER_LIB" );
3709 createSMESHAction( 701, "COMPUTE", "ICON_COMPUTE" );
3710 createSMESHAction( 702, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3711 createSMESHAction( 703, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3712 createSMESHAction( 704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3713 createSMESHAction( 705, "COPY_MESH", "ICON_COPY_MESH" );
3714 createSMESHAction( 710, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3715 createSMESHAction( 711, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3716 createSMESHAction( 712, "EVALUATE", "ICON_COMPUTE" );
3717 createSMESHAction( 713, "MESH_ORDER", "ICON_COMPUTE" );
3718 createSMESHAction( 806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3719 createSMESHAction( 801, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3720 createSMESHAction( 802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3721 createSMESHAction( 803, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3722 createSMESHAction( 815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3723 createSMESHAction( 804, "ADD" );
3724 createSMESHAction( 805, "REMOVE" );
3725 createSMESHAction( 810, "UN_GROUP", "ICON_UNION" );
3726 createSMESHAction( 811, "INT_GROUP", "ICON_INTERSECT" );
3727 createSMESHAction( 812, "CUT_GROUP", "ICON_CUT" );
3728 createSMESHAction( 814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3729 createSMESHAction( 813, "DEL_GROUP", "ICON_DEL_GROUP" );
3730 createSMESHAction( 900, "ADV_INFO", "ICON_ADV_INFO" );
3731 //createSMESHAction( 902, "STD_INFO", "ICON_STD_INFO" );
3732 //createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3733 createSMESHAction( 904, "FIND_ELEM", "ICON_FIND_ELEM" );
3734 createSMESHAction( 6001, "LENGTH", "ICON_LENGTH", 0, true );
3735 createSMESHAction( 6002, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3736 createSMESHAction( 6021, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3737 createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3738 createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3739 createSMESHAction( 6024, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3740 createSMESHAction( 6025, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3741 createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3742 createSMESHAction( 6027, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3743 createSMESHAction( 6028, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3744 createSMESHAction( 6029, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3745 createSMESHAction( 6030, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3746 createSMESHAction( 6031, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3747 createSMESHAction( 6032, "OVERALL_MESH_QUALITY" );
3748 createSMESHAction( 6003, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3749 createSMESHAction( 6004, "CONNECTION", "ICON_CONNECTION", 0, true );
3750 createSMESHAction( 6005, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3751 createSMESHAction( 6011, "AREA", "ICON_AREA", 0, true );
3752 createSMESHAction( 6012, "TAPER", "ICON_TAPER", 0, true );
3753 createSMESHAction( 6013, "ASPECT", "ICON_ASPECT", 0, true );
3754 createSMESHAction( 6014, "MIN_ANG", "ICON_ANGLE", 0, true );
3755 createSMESHAction( 6015, "WARP", "ICON_WARP", 0, true );
3756 createSMESHAction( 6016, "SKEW", "ICON_SKEW", 0, true );
3757 createSMESHAction( 6017, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3758 createSMESHAction( 6018, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3759 createSMESHAction( 6019, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3760 createSMESHAction( 6009, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3761 createSMESHAction( 4000, "NODE", "ICON_DLG_NODE" );
3762 createSMESHAction( 4009, "ELEM0D", "ICON_DLG_ELEM0D" );
3763 createSMESHAction( 4008, "BALL", "ICON_DLG_BALL" );
3764 createSMESHAction( 4010, "EDGE", "ICON_DLG_EDGE" );
3765 createSMESHAction( 4021, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3766 createSMESHAction( 4022, "QUAD", "ICON_DLG_QUADRANGLE" );
3767 createSMESHAction( 4023, "POLYGON", "ICON_DLG_POLYGON" );
3768 createSMESHAction( 4031, "TETRA", "ICON_DLG_TETRAS" );
3769 createSMESHAction( 4032, "HEXA", "ICON_DLG_HEXAS" );
3770 createSMESHAction( 4133, "PENTA", "ICON_DLG_PENTA" );
3771 createSMESHAction( 4134, "PYRAMID", "ICON_DLG_PYRAMID" );
3772 createSMESHAction( 4135, "OCTA", "ICON_DLG_OCTA" );
3773 createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3774 createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3775 createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3776 createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3777 createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3778 createSMESHAction( 4137, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3779 createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3780 createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3781 createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3782 createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3783 createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3784 createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3785 createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3786 createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3787 createSMESHAction( 4043, "CLEAR_MESH" , "ICON_CLEAR_MESH" );
3788 createSMESHAction( 4051, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3789 createSMESHAction( 4052, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3790 createSMESHAction( 4061, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3791 createSMESHAction( 4062, "ROT", "ICON_DLG_MESH_ROTATION" );
3792 createSMESHAction( 4063, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3793 createSMESHAction( 4064, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3794 createSMESHAction( 4065, "MERGE", "ICON_SMESH_MERGE_NODES" );
3795 createSMESHAction( 4066, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3796 createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3797 createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" );
3798 createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3799 createSMESHAction( 4070, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3800 createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" );
3801 createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" );
3802 createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3803 createSMESHAction( 410, "UNION", "ICON_UNIONTRI" );
3804 createSMESHAction( 411, "CUT", "ICON_CUTQUAD" );
3805 createSMESHAction( 412, "SMOOTH", "ICON_DLG_SMOOTHING" );
3806 createSMESHAction( 413, "EXTRUSION", "ICON_EXTRUSION" );
3807 createSMESHAction( 414, "REVOLUTION", "ICON_REVOLUTION" );
3808 createSMESHAction( 415, "MAP", "ICON_MAP" );
3809 createSMESHAction( 416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3810 createSMESHAction( 417, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3811 createSMESHAction( 418, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3812 createSMESHAction( 419, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3813 createSMESHAction( 420, "REORIENT_2D", "ICON_REORIENT_2D" );
3814 createSMESHAction( 200, "RESET" );
3815 createSMESHAction( 201, "SCALAR_BAR_PROP" );
3816 createSMESHAction( 2021, "SAVE_DISTRIBUTION" );
3817 createSMESHAction( 2022, "SHOW_DISTRIBUTION","",0, true );
3818 #ifndef DISABLE_PLOT2DVIEWER
3819 createSMESHAction( 2023, "PLOT_DISTRIBUTION" );
3821 createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true );
3822 createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true );
3823 createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true );
3824 createSMESHAction( 214, "UPDATE", "ICON_UPDATE" );
3825 createSMESHAction( 215, "NODES", "ICON_POINTS", 0, true );
3826 createSMESHAction( 222, "BALLS", "ICON_DLG_BALL", 0, true );
3827 createSMESHAction( 216, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3828 createSMESHAction( 217, "EDGES", "ICON_DLG_EDGE", 0, true );
3829 createSMESHAction( 218, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3830 createSMESHAction( 219, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3831 createSMESHAction( 220, "ALL" );
3832 createSMESHAction( 221, "FACE_ORIENTATION", "", 0, true );
3834 createSMESHAction( 231, "LINE_REPRESENTATION", "", 0, true );
3835 createSMESHAction( 232, "ARC_REPRESENTATION", "", 0, true );
3837 createSMESHAction( 1100, "EDIT_HYPO" );
3838 createSMESHAction( 1102, "UNASSIGN" );
3839 createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3840 createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3841 createSMESHAction( 1131, "DISPMODE" );
3842 createSMESHAction( 1132, "COLORS" );
3843 createSMESHAction( 1133, "TRANSP" );
3844 createSMESHAction( 1134, "CLIP" );
3845 createSMESHAction( 1135, "DISP_ENT" );
3846 createSMESHAction( 1136, "AUTO_COLOR" );
3847 createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3848 createSMESHAction( 2000, "CTRL" );
3850 createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3851 createSMESHAction( 502, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3853 createSMESHAction( 300, "HIDE" );
3854 createSMESHAction( 301, "SHOW" );
3855 createSMESHAction( 302, "DISPLAY_ONLY" );
3857 createSMESHAction( 41, "SORT_CHILD_ITEMS" );
3859 // ----- create menu --------------
3860 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3861 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3862 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3863 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3864 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3865 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3866 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3867 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3869 createMenu( separator(), fileId );
3871 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3872 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3873 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3874 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3875 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3876 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3877 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3878 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3879 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3880 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3882 //createMenu( 111, importId, -1 );
3883 createMenu( 112, importId, -1 );
3884 createMenu( 113, importId, -1 );
3885 createMenu( 115, importId, -1 );
3887 createMenu( 116, importId, -1 );
3889 createMenu( 117, importId, -1 );
3890 createMenu( 118, importId, -1 );
3891 createMenu( 121, exportId, -1 );
3892 createMenu( 122, exportId, -1 );
3893 createMenu( 123, exportId, -1 );
3894 createMenu( 140, exportId, -1 ); // export to STL
3896 createMenu( 142, exportId, -1 ); // export to CGNS
3898 createMenu( 144, exportId, -1 ); // export to SAUV
3899 createMenu( 146, exportId, -1 ); // export to GMF
3900 createMenu( separator(), fileId, 10 );
3902 createMenu( 33, editId, -1 );
3904 createMenu( 5105, toolsId, -1 );
3906 createMenu( 702, meshId, -1 ); // "Mesh" menu
3907 createMenu( 703, meshId, -1 );
3908 createMenu( 704, meshId, -1 );
3909 createMenu( 710, meshId, -1 );
3910 createMenu( 705, meshId, -1 );
3911 createMenu( separator(), meshId, -1 );
3912 createMenu( 701, meshId, -1 );
3913 createMenu( 711, meshId, -1 );
3914 createMenu( 712, meshId, -1 );
3915 createMenu( 713, meshId, -1 );
3916 createMenu( separator(), meshId, -1 );
3917 createMenu( 801, meshId, -1 );
3918 createMenu( 806, meshId, -1 );
3919 createMenu( 802, meshId, -1 );
3920 createMenu( 803, meshId, -1 );
3921 createMenu( 815, meshId, -1 );
3922 createMenu( separator(), meshId, -1 );
3923 createMenu( 810, meshId, -1 );
3924 createMenu( 811, meshId, -1 );
3925 createMenu( 812, meshId, -1 );
3926 createMenu( separator(), meshId, -1 );
3927 createMenu( 814, meshId, -1 );
3928 createMenu( separator(), meshId, -1 );
3929 createMenu( 900, meshId, -1 );
3930 //createMenu( 902, meshId, -1 );
3931 //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3932 createMenu( 904, meshId, -1 );
3933 createMenu( separator(), meshId, -1 );
3935 createMenu( 6005, nodeId, -1 );
3936 createMenu( 6028, nodeId, -1 );
3937 createMenu( 6002, edgeId, -1 );
3938 createMenu( 6003, edgeId, -1 );
3939 createMenu( 6001, edgeId, -1 );
3940 createMenu( 6004, edgeId, -1 );
3941 createMenu( 6029, edgeId, -1 );
3942 createMenu( 6021, faceId, -1 );
3943 createMenu( 6025, faceId, -1 );
3944 createMenu( 6027, faceId, -1 );
3945 createMenu( 6018, faceId, -1 );
3946 createMenu( 6019, faceId, -1 );
3947 createMenu( 6011, faceId, -1 );
3948 createMenu( 6012, faceId, -1 );
3949 createMenu( 6013, faceId, -1 );
3950 createMenu( 6014, faceId, -1 );
3951 createMenu( 6015, faceId, -1 );
3952 createMenu( 6016, faceId, -1 );
3953 createMenu( 6022, faceId, -1 );
3954 createMenu( 6030, faceId, -1 );
3955 createMenu( 6017, volumeId, -1 );
3956 createMenu( 6009, volumeId, -1 );
3957 createMenu( 6023, volumeId, -1 );
3958 createMenu( 6024, volumeId, -1 );
3959 createMenu( 6026, volumeId, -1 );
3960 createMenu( 6031, volumeId, -1 );
3961 createMenu( separator(), ctrlId, -1 );
3962 createMenu( 6032, ctrlId, -1 );
3964 createMenu( 4000, addId, -1 );
3965 createMenu( 4009, addId, -1 );
3966 createMenu( 4070, addId, -1 );
3967 createMenu( 4008, addId, -1 );
3968 createMenu( 4010, addId, -1 );
3969 createMenu( 4021, addId, -1 );
3970 createMenu( 4022, addId, -1 );
3971 createMenu( 4023, addId, -1 );
3972 createMenu( 4031, addId, -1 );
3973 createMenu( 4032, addId, -1 );
3974 createMenu( 4133, addId, -1 );
3975 createMenu( 4134, addId, -1 );
3976 createMenu( 4135, addId, -1 );
3977 createMenu( 4033, addId, -1 );
3978 createMenu( separator(), addId, -1 );
3979 createMenu( 4034, addId, -1 );
3980 createMenu( 4035, addId, -1 );
3981 createMenu( 4137, addId, -1 );
3982 createMenu( 4036, addId, -1 );
3983 createMenu( 4136, addId, -1 );
3984 createMenu( 4037, addId, -1 );
3985 createMenu( 4038, addId, -1 );
3986 createMenu( 4039, addId, -1 );
3987 createMenu( 4040, addId, -1 );
3988 createMenu( 4140, addId, -1 );
3990 createMenu( 4041, removeId, -1 );
3991 createMenu( 4042, removeId, -1 );
3992 createMenu( 4044, removeId, -1 );
3993 createMenu( separator(), removeId, -1 );
3994 createMenu( 813, removeId, -1 );
3995 createMenu( separator(), removeId, -1 );
3996 createMenu( 4043, removeId, -1 );
3998 createMenu( 4051, renumId, -1 );
3999 createMenu( 4052, renumId, -1 );
4001 createMenu( 4061, transfId, -1 );
4002 createMenu( 4062, transfId, -1 );
4003 createMenu( 4063, transfId, -1 );
4004 createMenu( 4068, transfId, -1 );
4005 createMenu( 4064, transfId, -1 );
4006 createMenu( 4065, transfId, -1 );
4007 createMenu( 4066, transfId, -1 );
4008 createMenu( 4069, transfId, -1 );
4010 createMenu( 4067,modifyId, -1 );
4011 createMenu( 407, modifyId, -1 );
4012 createMenu( 408, modifyId, -1 );
4013 createMenu( 409, modifyId, -1 );
4014 createMenu( 420, modifyId, -1 );
4015 createMenu( 410, modifyId, -1 );
4016 createMenu( 411, modifyId, -1 );
4017 createMenu( 419, modifyId, -1 );
4018 createMenu( 412, modifyId, -1 );
4019 createMenu( 413, modifyId, -1 );
4020 createMenu( 416, modifyId, -1 );
4021 createMenu( 414, modifyId, -1 );
4022 createMenu( 415, modifyId, -1 );
4023 createMenu( 417, modifyId, -1 );
4024 createMenu( 418, modifyId, -1 );
4026 createMenu( 501, measureId, -1 );
4027 createMenu( 502, measureId, -1 );
4028 createMenu( 214, viewId, -1 );
4030 // ----- create toolbars --------------
4031 int meshTb = createTool( tr( "TB_MESH" ) ),
4032 ctrlTb = createTool( tr( "TB_CTRL" ) ),
4033 addRemTb = createTool( tr( "TB_ADD_REMOVE" ) ),
4034 modifyTb = createTool( tr( "TB_MODIFY" ) ),
4035 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
4037 createTool( 702, meshTb );
4038 createTool( 703, meshTb );
4039 createTool( 704, meshTb );
4040 createTool( 710, meshTb );
4041 createTool( 705, meshTb );
4042 createTool( separator(), meshTb );
4043 createTool( 701, meshTb );
4044 createTool( 711, meshTb );
4045 createTool( 712, meshTb );
4046 createTool( 713, meshTb );
4047 createTool( separator(), meshTb );
4048 createTool( 801, meshTb );
4049 createTool( 806, meshTb );
4050 createTool( 802, meshTb );
4051 createTool( 803, meshTb );
4052 //createTool( 815, meshTb );
4053 createTool( separator(), meshTb );
4054 createTool( 900, meshTb );
4055 //createTool( 902, meshTb );
4056 //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4057 createTool( 904, meshTb );
4058 createTool( separator(), meshTb );
4060 createTool( 6005, ctrlTb );
4061 createTool( 6028, ctrlTb );
4062 createTool( separator(), ctrlTb );
4063 createTool( 6002, ctrlTb );
4064 createTool( 6003, ctrlTb );
4065 createTool( 6001, ctrlTb );
4066 createTool( 6004, ctrlTb );
4067 createTool( 6029, ctrlTb );
4068 createTool( separator(), ctrlTb );
4069 createTool( 6021, ctrlTb );
4070 createTool( 6025, ctrlTb );
4071 createTool( 6027, ctrlTb );
4072 createTool( 6018, ctrlTb );
4073 createTool( 6019, ctrlTb );
4074 createTool( 6011, ctrlTb );
4075 createTool( 6012, ctrlTb );
4076 createTool( 6013, ctrlTb );
4077 createTool( 6014, ctrlTb );
4078 createTool( 6015, ctrlTb );
4079 createTool( 6016, ctrlTb );
4080 createTool( 6022, ctrlTb );
4081 createTool( 6030, ctrlTb );
4082 createTool( separator(), ctrlTb );
4083 createTool( 6017, ctrlTb );
4084 createTool( 6009, ctrlTb );
4085 createTool( 6023, ctrlTb );
4086 createTool( 6024, ctrlTb );
4087 createTool( 6026, ctrlTb );
4088 createTool( 6031, ctrlTb );
4089 createTool( separator(), ctrlTb );
4091 createTool( 4000, addRemTb );
4092 createTool( 4009, addRemTb );
4093 createTool( 4070, addRemTb );
4094 createTool( 4008, addRemTb );
4095 createTool( 4010, addRemTb );
4096 createTool( 4021, addRemTb );
4097 createTool( 4022, addRemTb );
4098 createTool( 4023, addRemTb );
4099 createTool( 4031, addRemTb );
4100 createTool( 4032, addRemTb );
4101 createTool( 4133, addRemTb );
4102 createTool( 4134, addRemTb );
4103 createTool( 4135, addRemTb );
4104 createTool( 4033, addRemTb );
4105 createTool( separator(), addRemTb );
4106 createTool( 4034, addRemTb );
4107 createTool( 4035, addRemTb );
4108 createTool( 4137, addRemTb );
4109 createTool( 4036, addRemTb );
4110 createTool( 4136, addRemTb );
4111 createTool( 4037, addRemTb );
4112 createTool( 4038, addRemTb );
4113 createTool( 4039, addRemTb );
4114 createTool( 4040, addRemTb );
4115 createTool( 4140, addRemTb );
4116 createTool( separator(), addRemTb );
4117 createTool( 4041, addRemTb );
4118 createTool( 4042, addRemTb );
4119 createTool( 4044, addRemTb );
4120 createTool( 4043, addRemTb );
4121 createTool( separator(), addRemTb );
4122 createTool( 4051, addRemTb );
4123 createTool( 4052, addRemTb );
4124 createTool( separator(), addRemTb );
4125 createTool( 4061, addRemTb );
4126 createTool( 4062, addRemTb );
4127 createTool( 4063, addRemTb );
4128 createTool( 4068, addRemTb );
4129 createTool( 4064, addRemTb );
4130 createTool( 4065, addRemTb );
4131 createTool( 4066, addRemTb );
4132 createTool( 4069, addRemTb );
4133 createTool( separator(), addRemTb );
4135 createTool( 4067,modifyTb );
4136 createTool( 407, modifyTb );
4137 createTool( 408, modifyTb );
4138 createTool( 409, modifyTb );
4139 createTool( 420, modifyTb );
4140 createTool( 410, modifyTb );
4141 createTool( 411, modifyTb );
4142 createTool( 419, modifyTb );
4143 createTool( 412, modifyTb );
4144 createTool( 413, modifyTb );
4145 createTool( 416, modifyTb );
4146 createTool( 414, modifyTb );
4147 createTool( 415, modifyTb );
4148 createTool( 417, modifyTb );
4149 createTool( 418, modifyTb );
4151 createTool( 214, dispModeTb );
4153 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4154 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4157 QString OB = "'ObjectBrowser'",
4158 View = "'" + SVTK_Viewer::Type() + "'",
4160 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4161 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4162 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4163 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4164 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4165 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4166 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4167 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4168 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4169 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4170 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4172 mesh_part = mesh + " " + subMesh + " " + group,
4173 mesh_group = mesh + " " + group,
4174 hyp_alg = hypo + " " + algo;
4176 // popup for object browser
4178 isInvisible("not( isVisible )"),
4179 isEmpty("numberOfNodes = 0"),
4180 isNotEmpty("numberOfNodes <> 0"),
4182 // has nodes, edges, etc in VISIBLE! actor
4183 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4184 hasElems("(count( elemTypes ) > 0)"),
4185 hasDifferentElems("(count( elemTypes ) > 1)"),
4186 hasBalls("({'BallElem'} in elemTypes)"),
4187 hasElems0d("({'Elem0d'} in elemTypes)"),
4188 hasEdges("({'Edge'} in elemTypes)"),
4189 hasFaces("({'Face'} in elemTypes)"),
4190 hasVolumes("({'Volume'} in elemTypes)");
4192 createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
4193 createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
4194 createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
4195 createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
4196 createPopupItem( 803, OB, group ); // EDIT_GROUP
4197 createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
4199 popupMgr()->insert( separator(), -1, 0 );
4200 createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
4201 createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
4202 createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
4203 createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
4204 createPopupItem( 214, OB, mesh_part ); // UPDATE
4205 createPopupItem( 900, OB, mesh_part ); // ADV_INFO
4206 createPopupItem( 904, OB, mesh_group ); // FIND_ELEM
4207 createPopupItem( 6032, OB, mesh_part ); // CTRL_INFO
4208 popupMgr()->insert( separator(), -1, 0 );
4209 createPopupItem( 801, OB, mesh ); // CREATE_GROUP
4210 createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
4211 createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
4212 popupMgr()->insert( separator(), -1, 0 );
4213 createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
4214 createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4215 popupMgr()->insert( separator(), -1, 0 );
4216 createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
4217 popupMgr()->insert( separator(), -1, 0 );
4218 createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
4219 createPopupItem( 418, OB, mesh + " " + group, // create 2D mesh from 3D
4221 popupMgr()->insert( separator(), -1, 0 );
4223 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4224 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4225 QString only_one_2D = only_one_non_empty + " && dim>1";
4227 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4228 createPopupItem( 125, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_MED
4229 createPopupItem( 126, OB, mesh_group, only_one_non_empty, anId ); // EXPORT_UNV
4230 createPopupItem( 141, OB, mesh_group, only_one_2D, anId ); // EXPORT_STL
4232 createPopupItem( 143, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_CGNS
4234 createPopupItem( 145, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_SAUV
4235 createPopupItem( 147, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_GMF
4236 createPopupItem( 124, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_DAT
4237 createPopupItem( 33, OB, mesh_part + " " + hyp_alg ); // DELETE
4238 createPopupItem( 813, OB, group ); // DEL_GROUP with contents
4239 popupMgr()->insert( separator(), -1, 0 );
4242 createPopupItem( 803, View, group ); // EDIT_GROUP
4243 createPopupItem( 804, View, elems ); // ADD
4244 createPopupItem( 805, View, elems ); // REMOVE
4246 popupMgr()->insert( separator(), -1, 0 );
4247 createPopupItem( 214, View, mesh_part ); // UPDATE
4248 createPopupItem( 900, View, mesh_part ); // ADV_INFO
4249 createPopupItem( 6032,View, mesh_part ); // CTRL_INFO
4250 createPopupItem( 904, View, mesh ); // FIND_ELEM
4251 popupMgr()->insert( separator(), -1, 0 );
4253 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
4254 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
4255 popupMgr()->insert( separator(), -1, 0 );
4257 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4258 QString aType = QString( "%1type in {%2}" ).arg( lc );
4259 aType = aType.arg( mesh_part );
4260 QString aMeshInVTK = aClient + "&&" + aType;
4262 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4263 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4264 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4266 //-------------------------------------------------
4268 //-------------------------------------------------
4269 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4271 popupMgr()->insert( action( 9010 ), anId, -1 );
4272 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4273 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4275 popupMgr()->insert( action( 9011 ), anId, -1 );
4276 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4277 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4279 popupMgr()->insert( separator(), -1, -1 );
4281 //-------------------------------------------------
4283 //-------------------------------------------------
4284 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4286 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4287 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4288 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4290 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4291 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4292 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4294 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4295 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4296 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4298 popupMgr()->insert( separator(), anId, -1 );
4300 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4301 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4302 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4304 //-------------------------------------------------
4306 //-------------------------------------------------
4307 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4309 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4311 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4312 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4313 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4315 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4316 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4317 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4319 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4320 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4321 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4323 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4324 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4325 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4327 popupMgr()->insert( action( 222 ), anId, -1 ); // BALLS
4328 popupMgr()->setRule( action( 222 ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4329 popupMgr()->setRule( action( 222 ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4331 popupMgr()->insert( separator(), anId, -1 );
4333 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4334 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4337 //-------------------------------------------------
4338 // Representation of the 2D Quadratic elements
4339 //-------------------------------------------------
4340 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4341 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4342 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4343 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4345 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4346 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4347 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4349 //-------------------------------------------------
4350 // Orientation of faces
4351 //-------------------------------------------------
4352 popupMgr()->insert( action( 221 ), -1, -1 );
4353 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4354 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4356 //-------------------------------------------------
4358 //-------------------------------------------------
4359 popupMgr()->insert( action( 1132 ), -1, -1 );
4360 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4362 //-------------------------------------------------
4364 //-------------------------------------------------
4365 popupMgr()->insert( action( 1133 ), -1, -1 );
4366 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4368 //-------------------------------------------------
4370 //-------------------------------------------------
4372 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4373 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4374 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4375 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4377 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4379 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4380 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4382 popupMgr()->insert( separator(), anId, -1 );
4384 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4386 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4387 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4388 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4390 popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4391 popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4392 popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4394 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4396 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4397 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4398 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4400 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4401 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4402 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4404 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4405 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4406 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4408 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4409 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4410 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4411 popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4412 popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4413 popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4415 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4417 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4418 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4419 QtxPopupMgr::VisibleRule );
4420 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4422 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4423 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4424 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4426 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4427 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4428 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4430 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4431 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4432 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4434 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4435 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4436 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4438 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4439 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4440 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4442 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4443 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4444 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4446 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4447 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4448 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4450 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4451 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4452 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4454 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4455 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4456 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4458 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4459 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4460 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4462 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4463 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4464 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4465 popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4466 popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4467 popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4469 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4471 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4472 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4473 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4475 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4476 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4477 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4479 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4480 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4481 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4483 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4484 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4485 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4487 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4488 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4489 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4491 popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4492 popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4493 popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4495 popupMgr()->insert( separator(), anId, -1 );
4497 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4498 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4500 popupMgr()->insert( separator(), anId, -1 );
4502 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4504 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4505 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4507 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4508 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4509 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4511 #ifndef DISABLE_PLOT2DVIEWER
4512 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4513 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4516 //-------------------------------------------------
4518 //-------------------------------------------------
4519 popupMgr()->insert( separator(), -1, -1 );
4520 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4521 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4522 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4523 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4525 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4526 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4528 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4529 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4531 popupMgr()->insert( separator(), -1, -1 );
4533 //-------------------------------------------------
4535 //-------------------------------------------------
4536 popupMgr()->insert( action( 1134 ), -1, -1 );
4537 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4539 popupMgr()->insert( separator(), -1, -1 );
4541 popupMgr()->insert( action( 41 ), -1, -1 );
4542 popupMgr()->setRule( action( 41 ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4543 popupMgr()->insert( separator(), -1, -1 );
4545 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4546 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4548 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4549 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4552 //================================================================================
4554 * \brief Return true if SMESH or GEOM objects are selected.
4555 * Is called form LightApp_Module::activateModule() which clear selection if
4556 * not isSelectionCompatible()
4558 //================================================================================
4560 bool SMESHGUI::isSelectionCompatible()
4562 bool isCompatible = true;
4563 SALOME_ListIO selected;
4564 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4565 Sel->selectedObjects( selected );
4567 SALOME_ListIteratorOfListIO It( selected );
4568 for ( ; isCompatible && It.More(); It.Next())
4570 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4571 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4573 return isCompatible;
4577 bool SMESHGUI::reusableOperation( const int id )
4579 // compute, evaluate and precompute are not reusable operations
4580 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4583 bool SMESHGUI::activateModule( SUIT_Study* study )
4585 bool res = SalomeApp_Module::activateModule( study );
4587 setMenuShown( true );
4588 setToolShown( true );
4590 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4591 PyGILState_STATE gstate = PyGILState_Ensure();
4592 PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4593 if(pluginsmanager==NULL)
4597 PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4602 PyGILState_Release(gstate);
4603 // end of GEOM plugins loading
4605 // Reset actions accelerator keys
4606 //action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4607 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4608 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4610 action( 33)->setEnabled(true); // Delete: Key_Delete
4612 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4613 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4614 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4615 if ( _PTR(Study) aStudy = s->studyDS()) {
4616 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4617 updateObjBrowser(); // objects can be removed
4620 // get all view currently opened in the study and connect their signals to
4621 // the corresponding slots of the class.
4622 SUIT_Desktop* aDesk = study->application()->desktop();
4624 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4625 SUIT_ViewWindow* wnd;
4626 foreach ( wnd, wndList )
4633 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4635 setMenuShown( false );
4636 setToolShown( false );
4638 EmitSignalCloseAllDialogs();
4640 // Unset actions accelerator keys
4641 //action(111)->setShortcut(QKeySequence()); // Import DAT
4642 action(112)->setShortcut(QKeySequence()); // Import UNV
4643 action(113)->setShortcut(QKeySequence()); // Import MED
4645 action( 33)->setEnabled(false); // Delete: Key_Delete
4647 return SalomeApp_Module::deactivateModule( study );
4650 void SMESHGUI::studyClosed( SUIT_Study* s )
4652 SMESH::RemoveVisuData( s->id() );
4653 SalomeApp_Module::studyClosed( s );
4656 void SMESHGUI::OnGUIEvent()
4658 const QObject* obj = sender();
4659 if ( !obj || !obj->inherits( "QAction" ) )
4661 int id = actionId((QAction*)obj);
4666 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4668 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4669 if ( CORBA::is_nil( myComponentSMESH ) )
4671 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4673 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4674 return aGUI.myComponentSMESH;
4677 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4678 return myComponentSMESH;
4681 QString SMESHGUI::engineIOR() const
4683 CORBA::ORB_var anORB = getApp()->orb();
4684 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4685 return QString( anIOR.in() );
4688 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4690 SalomeApp_Module::contextMenuPopup( client, menu, title );
4692 selectionMgr()->selectedObjects( lst );
4693 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4694 Handle(SALOME_InteractiveObject) io = lst.First();
4695 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4696 _PTR(Study) study = appStudy->studyDS();
4697 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4699 QString aName = QString( obj->GetName().c_str() );
4700 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4701 aName.remove( (aName.length() - 1), 1 );
4707 LightApp_Selection* SMESHGUI::createSelection() const
4709 return new SMESHGUI_Selection();
4712 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4714 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4715 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4718 void SMESHGUI::viewManagers( QStringList& list ) const
4720 list.append( SVTK_Viewer::Type() );
4723 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4725 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4726 SMESH::UpdateSelectionProp( this );
4728 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4729 for(int i = 0; i < aViews.count() ; i++){
4730 SUIT_ViewWindow *sf = aViews[i];
4736 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4738 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4739 myClippingPlaneInfoMap.erase( theViewManager );
4742 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4744 theActor->AddObserver( SMESH::DeleteActorEvent,
4745 myEventCallbackCommand.GetPointer(),
4749 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4750 unsigned long theEvent,
4751 void* theClientData,
4754 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4755 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4756 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4757 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4758 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4759 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4760 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4761 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4762 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4763 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4764 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4765 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4766 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4767 if( anActor == *anIter3 ) {
4768 anActorList.erase( anIter3 );
4779 void SMESHGUI::createPreferences()
4781 // General tab ------------------------------------------------------------------------
4782 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4784 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4785 setPreferenceProperty( autoUpdate, "columns", 2 );
4786 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4787 setPreferenceProperty( lim, "min", 0 );
4788 setPreferenceProperty( lim, "max", 100000000 );
4789 setPreferenceProperty( lim, "step", 1000 );
4790 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4791 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4793 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4794 setPreferenceProperty( qaGroup, "columns", 2 );
4795 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4796 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4797 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4798 setPreferenceProperty( prec, "min", 0 );
4799 setPreferenceProperty( prec, "max", 16 );
4800 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4801 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4802 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4803 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4804 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4806 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4807 setPreferenceProperty( dispgroup, "columns", 2 );
4808 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4810 modes.append( tr("MEN_WIRE") );
4811 modes.append( tr("MEN_SHADE") );
4812 modes.append( tr("MEN_NODES") );
4813 modes.append( tr("MEN_SHRINK") );
4814 QList<QVariant> indices;
4815 indices.append( 0 );
4816 indices.append( 1 );
4817 indices.append( 2 );
4818 indices.append( 3 );
4819 setPreferenceProperty( dispmode, "strings", modes );
4820 setPreferenceProperty( dispmode, "indexes", indices );
4822 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4823 setPreferenceProperty( arcgroup, "columns", 2 );
4824 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4825 QStringList quadraticModes;
4826 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4827 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4829 indices.append( 0 );
4830 indices.append( 1 );
4831 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4832 setPreferenceProperty( quadraticmode, "indexes", indices );
4834 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4835 "SMESH", "max_angle" );
4836 setPreferenceProperty( maxAngle, "min", 1 );
4837 setPreferenceProperty( maxAngle, "max", 90 );
4841 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4842 setPreferenceProperty( exportgroup, "columns", 2 );
4843 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4844 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4846 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4847 setPreferenceProperty( computeGroup, "columns", 2 );
4848 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4850 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4851 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4852 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4854 indices.append( 0 );
4855 indices.append( 1 );
4856 indices.append( 2 );
4857 setPreferenceProperty( notifyMode, "strings", modes );
4858 setPreferenceProperty( notifyMode, "indexes", indices );
4860 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4861 setPreferenceProperty( infoGroup, "columns", 2 );
4862 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4864 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4865 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4867 indices.append( 0 );
4868 indices.append( 1 );
4869 setPreferenceProperty( elemInfo, "strings", modes );
4870 setPreferenceProperty( elemInfo, "indexes", indices );
4871 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4872 setPreferenceProperty( nodesLim, "min", 0 );
4873 setPreferenceProperty( nodesLim, "max", 10000000 );
4874 setPreferenceProperty( nodesLim, "step", 10000 );
4875 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4876 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
4877 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4878 setPreferenceProperty( ctrlLim, "min", 0 );
4879 setPreferenceProperty( ctrlLim, "max", 10000000 );
4880 setPreferenceProperty( ctrlLim, "step", 1000 );
4881 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
4882 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
4883 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
4884 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
4885 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
4887 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4888 setPreferenceProperty( segGroup, "columns", 2 );
4889 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4890 "SMESH", "segmentation" );
4891 setPreferenceProperty( segLen, "min", 1 );
4892 setPreferenceProperty( segLen, "max", 10000000 );
4893 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4894 "SMESH", "nb_segments_per_edge" );
4895 setPreferenceProperty( nbSeg, "min", 1 );
4896 setPreferenceProperty( nbSeg, "max", 10000000 );
4898 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4899 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4900 "SMESH", "forget_mesh_on_hyp_modif" );
4903 // Quantities with individual precision settings
4904 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4905 setPreferenceProperty( precGroup, "columns", 2 );
4907 const int nbQuantities = 6;
4908 int precs[nbQuantities], ii = 0;
4909 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4910 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4911 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4912 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4913 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4914 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4915 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4916 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4917 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4918 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4919 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4920 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4922 // Set property for precision value for spinboxes
4923 for ( ii = 0; ii < nbQuantities; ii++ ){
4924 setPreferenceProperty( precs[ii], "min", -14 );
4925 setPreferenceProperty( precs[ii], "max", 14 );
4926 setPreferenceProperty( precs[ii], "precision", 2 );
4929 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4930 setPreferenceProperty( previewGroup, "columns", 2 );
4931 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4932 setPreferenceProperty( chunkSize, "min", 1 );
4933 setPreferenceProperty( chunkSize, "max", 1000 );
4934 setPreferenceProperty( chunkSize, "step", 50 );
4936 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4937 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4939 // Mesh tab ------------------------------------------------------------------------
4940 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4941 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4942 setPreferenceProperty( nodeGroup, "columns", 3 );
4944 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4946 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4948 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4949 QList<QVariant> aMarkerTypeIndicesList;
4950 QList<QVariant> aMarkerTypeIconsList;
4951 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4952 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4953 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4954 aMarkerTypeIndicesList << i;
4955 aMarkerTypeIconsList << pixmap;
4957 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4958 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4960 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4962 QList<QVariant> aMarkerScaleIndicesList;
4963 QStringList aMarkerScaleValuesList;
4964 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4965 aMarkerScaleIndicesList << i;
4966 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4968 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4969 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4971 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4972 //setPreferenceProperty( elemGroup, "columns", 2 );
4974 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4975 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4976 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
4977 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
4978 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4979 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
4980 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4981 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4984 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4985 setPreferenceProperty( grpGroup, "columns", 2 );
4987 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4988 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
4990 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4991 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4992 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
4993 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
4994 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4995 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4996 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
4997 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
4998 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4999 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5001 setPreferenceProperty( size0d, "min", 1 );
5002 setPreferenceProperty( size0d, "max", 10 );
5004 setPreferenceProperty( ballSize, "min", 1 );
5005 setPreferenceProperty( ballSize, "max", 10 );
5007 setPreferenceProperty( elemW, "min", 1 );
5008 setPreferenceProperty( elemW, "max", 5 );
5010 setPreferenceProperty( outW, "min", 1 );
5011 setPreferenceProperty( outW, "max", 5 );
5013 setPreferenceProperty( shrink, "min", 0 );
5014 setPreferenceProperty( shrink, "max", 100 );
5016 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5017 setPreferenceProperty( numGroup, "columns", 2 );
5019 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5020 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5022 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5023 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5025 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5026 setPreferenceProperty( orientGroup, "columns", 1 );
5028 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5029 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5031 setPreferenceProperty( orientScale, "min", 0.05 );
5032 setPreferenceProperty( orientScale, "max", 0.5 );
5033 setPreferenceProperty( orientScale, "step", 0.05 );
5035 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5037 // Selection tab ------------------------------------------------------------------------
5038 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5040 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5041 setPreferenceProperty( selGroup, "columns", 2 );
5043 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5044 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5046 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5047 setPreferenceProperty( preGroup, "columns", 2 );
5049 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5051 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5052 setPreferenceProperty( precSelGroup, "columns", 2 );
5054 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5055 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5056 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5058 // Scalar Bar tab ------------------------------------------------------------------------
5059 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5060 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5061 setPreferenceProperty( fontGr, "columns", 2 );
5063 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5064 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5066 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5067 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5069 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5070 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5072 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5073 setPreferenceProperty( numcol, "min", 2 );
5074 setPreferenceProperty( numcol, "max", 256 );
5076 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5077 setPreferenceProperty( numlab, "min", 2 );
5078 setPreferenceProperty( numlab, "max", 65 );
5080 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5081 setPreferenceProperty( orientGr, "columns", 2 );
5082 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5083 QStringList orients;
5084 orients.append( tr( "SMESH_VERTICAL" ) );
5085 orients.append( tr( "SMESH_HORIZONTAL" ) );
5086 indices.clear(); indices.append( 0 ); indices.append( 1 );
5087 setPreferenceProperty( orient, "strings", orients );
5088 setPreferenceProperty( orient, "indexes", indices );
5090 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5091 setPreferenceProperty( posVSizeGr, "columns", 2 );
5092 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5093 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5094 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5095 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5096 setPreferenceProperty( xv, "step", 0.1 );
5097 setPreferenceProperty( xv, "min", 0.0 );
5098 setPreferenceProperty( xv, "max", 1.0 );
5099 setPreferenceProperty( yv, "step", 0.1 );
5100 setPreferenceProperty( yv, "min", 0.0 );
5101 setPreferenceProperty( yv, "max", 1.0 );
5102 setPreferenceProperty( wv, "step", 0.1 );
5103 setPreferenceProperty( wv, "min", 0.0 );
5104 setPreferenceProperty( wv, "max", 1.0 );
5105 setPreferenceProperty( hv, "min", 0.0 );
5106 setPreferenceProperty( hv, "max", 1.0 );
5107 setPreferenceProperty( hv, "step", 0.1 );
5109 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5110 setPreferenceProperty( posHSizeGr, "columns", 2 );
5111 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5112 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5113 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5114 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5115 setPreferenceProperty( xv, "min", 0.0 );
5116 setPreferenceProperty( xv, "max", 1.0 );
5117 setPreferenceProperty( xv, "step", 0.1 );
5118 setPreferenceProperty( xh, "min", 0.0 );
5119 setPreferenceProperty( xh, "max", 1.0 );
5120 setPreferenceProperty( xh, "step", 0.1 );
5121 setPreferenceProperty( yh, "min", 0.0 );
5122 setPreferenceProperty( yh, "max", 1.0 );
5123 setPreferenceProperty( yh, "step", 0.1 );
5124 setPreferenceProperty( wh, "min", 0.0 );
5125 setPreferenceProperty( wh, "max", 1.0 );
5126 setPreferenceProperty( wh, "step", 0.1 );
5127 setPreferenceProperty( hh, "min", 0.0 );
5128 setPreferenceProperty( hh, "max", 1.0 );
5129 setPreferenceProperty( hh, "step", 0.1 );
5131 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5132 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5133 setPreferenceProperty( distributionGr, "columns", 3 );
5135 types.append( tr( "SMESH_MONOCOLOR" ) );
5136 types.append( tr( "SMESH_MULTICOLOR" ) );
5137 indices.clear(); indices.append( 0 ); indices.append( 1 );
5138 setPreferenceProperty( coloringType, "strings", types );
5139 setPreferenceProperty( coloringType, "indexes", indices );
5140 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5144 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5146 if( sect=="SMESH" ) {
5147 float sbX1,sbY1,sbW,sbH;
5148 float aTol = 1.00000009999999;
5149 std::string aWarning;
5150 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5151 if( name=="selection_object_color" || name=="selection_element_color" ||
5152 name=="highlight_color" ||
5153 name=="selection_precision_node" || name=="selection_precision_element" ||
5154 name=="selection_precision_object")
5155 SMESH::UpdateSelectionProp( this );
5156 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5157 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5158 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5159 if(sbX1+sbW > aTol){
5160 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5163 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5164 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5167 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5168 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5169 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5170 if(sbY1+sbH > aTol){
5171 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5172 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5173 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5176 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5177 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5178 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5179 if(sbX1+sbW > aTol){
5180 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5183 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5184 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5187 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5188 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5189 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5190 if(sbY1+sbH > aTol){
5191 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5194 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5195 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5198 else if ( name == "segmentation" ) {
5199 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5200 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5202 else if ( name == "nb_segments_per_edge" ) {
5203 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5204 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5206 else if ( name == "historical_python_dump" ||
5207 name == "forget_mesh_on_hyp_modif") {
5208 QString val = aResourceMgr->stringValue( "SMESH", name );
5209 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5211 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5212 SMESH::UpdateFontProp( this );
5214 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5215 SMESH::UpdateFontProp( this );
5218 if(aWarning.size() != 0){
5219 aWarning += "The default values are applied instead.";
5220 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5221 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5222 QObject::tr(aWarning.c_str()));
5227 //================================================================================
5229 * \brief Update something in accordance with update flags
5230 * \param theFlags - update flags
5232 * Update viewer or/and object browser etc. in accordance with update flags ( see
5233 * LightApp_UpdateFlags enumeration ).
5235 //================================================================================
5236 void SMESHGUI::update( const int flags )
5238 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5239 SMESH::UpdateView();
5241 SalomeApp_Module::update( flags );
5244 //================================================================================
5246 * \brief Set default selection mode
5248 * SLOT called when operation commited. Sets default selection mode
5250 //================================================================================
5251 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5253 SVTK_ViewWindow* vtkWnd =
5254 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5256 vtkWnd->SetSelectionMode( ActorSelection );
5259 //================================================================================
5261 * \brief Set default selection mode
5263 * SLOT called when operation aborted. Sets default selection mode
5265 //================================================================================
5266 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5268 SVTK_ViewWindow* vtkWnd =
5269 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5271 vtkWnd->SetSelectionMode( ActorSelection );
5274 //================================================================================
5276 * \brief Creates operation with given identifier
5277 * \param id - identifier of operation to be started
5278 * \return Pointer on created operation or NULL if operation is not created
5280 * Virtual method redefined from the base class creates operation with given id.
5281 * It is called called automatically from startOperation method of base class.
5283 //================================================================================
5284 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5286 LightApp_Operation* op = 0;
5287 // to do : create operation here
5290 case 417: //convert to quadratic
5291 op = new SMESHGUI_ConvToQuadOp();
5293 case 418: // create 2D mesh as boundary on 3D
5294 op = new SMESHGUI_Make2DFrom3DOp();
5296 case 420: // Reorient faces
5297 op = new SMESHGUI_ReorientFacesOp();
5299 case 701: // Compute mesh
5300 op = new SMESHGUI_ComputeOp();
5302 case 702: // Create mesh
5303 op = new SMESHGUI_MeshOp( true, true );
5305 case 703: // Create sub-mesh
5306 op = new SMESHGUI_MeshOp( true, false );
5308 case 704: // Edit mesh/sub-mesh
5309 op = new SMESHGUI_MeshOp( false );
5311 case 711: // Precompute mesh
5312 op = new SMESHGUI_PrecomputeOp();
5314 case 712: // Evaluate mesh
5315 op = new SMESHGUI_EvaluateOp();
5317 case 713: // Evaluate mesh
5318 op = new SMESHGUI_MeshOrderOp();
5320 case 806: // Create group on geom
5321 op = new SMESHGUI_GroupOnShapeOp();
5323 case 904: // Find element
5324 op = new SMESHGUI_FindElemByPointOp();
5326 case 4067: // Make mesh pass through point
5327 op = new SMESHGUI_MakeNodeAtPointOp();
5329 case 4070: // Create 0D elements on all nodes
5330 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5337 op = SalomeApp_Module::createOperation( id );
5341 //================================================================================
5343 * \brief Stops current operations and starts a given one
5344 * \param id - The id of the operation to start
5346 //================================================================================
5348 void SMESHGUI::switchToOperation(int id)
5350 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5351 activeStudy()->abortAllOperations();
5352 startOperation( id );
5355 LightApp_Displayer* SMESHGUI::displayer()
5358 myDisplayer = new SMESHGUI_Displayer( getApp() );
5362 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5365 int aTolerance = 64;
5366 int anIterations = 0;
5372 if( anIterations % aPeriod == 0 )
5375 if( aTolerance < 1 )
5379 aHue = (int)( 360.0 * rand() / RAND_MAX );
5382 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5383 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5384 for( ; it != itEnd; ++it )
5386 SALOMEDS::Color anAutoColor = *it;
5387 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5390 aQColor.getHsv( &h, &s, &v );
5391 if( abs( h - aHue ) < aTolerance )
5403 aColor.setHsv( aHue, 255, 255 );
5405 SALOMEDS::Color aSColor;
5406 aSColor.R = aColor.redF();
5407 aSColor.G = aColor.greenF();
5408 aSColor.B = aColor.blueF();
5413 const char* gSeparator = "_"; // character used to separate parameter names
5414 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5415 const char* gPathSep = "|"; // character used to separate paths
5418 * \brief Store visual parameters
5420 * This method is called just before the study document is saved.
5421 * Store visual parameters in AttributeParameter attribue(s)
5423 void SMESHGUI::storeVisualParameters (int savePoint)
5426 Kernel_Utils::Localizer loc;
5428 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5429 if (!appStudy || !appStudy->studyDS())
5431 _PTR(Study) studyDS = appStudy->studyDS();
5433 // componentName is used for encoding of entries when storing them in IParameters
5434 std::string componentName = myComponentSMESH->ComponentDataType();
5435 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5436 //if (!aSComponent) return;
5439 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5440 componentName.c_str(),
5442 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5444 // store map of custom markers
5445 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5446 if( !aMarkerMap.empty() )
5448 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5449 for( ; anIter != aMarkerMap.end(); anIter++ )
5451 int anId = anIter->first;
5452 VTK::MarkerData aMarkerData = anIter->second;
5453 std::string aMarkerFileName = aMarkerData.first;
5454 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5455 if( aMarkerTexture.size() < 3 )
5456 continue; // should contain at least width, height and the first value
5458 QString aPropertyName( "texture" );
5459 aPropertyName += gSeparator;
5460 aPropertyName += QString::number( anId );
5462 QString aPropertyValue = aMarkerFileName.c_str();
5463 aPropertyValue += gPathSep;
5465 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5466 ushort aWidth = *aTextureIter++;
5467 ushort aHeight = *aTextureIter++;
5468 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5469 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5470 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5471 aPropertyValue += QString::number( *aTextureIter );
5473 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5477 // viewers counters are used for storing view_numbers in IParameters
5480 // main cycle to store parameters of displayed objects
5481 QList<SUIT_ViewManager*> lst;
5482 QList<SUIT_ViewManager*>::Iterator it;
5483 getApp()->viewManagers(lst);
5484 for (it = lst.begin(); it != lst.end(); it++)
5486 SUIT_ViewManager* vman = *it;
5487 QString vType = vman->getType();
5489 // saving VTK actors properties
5490 if (vType == SVTK_Viewer::Type())
5492 // store the clipping planes attached to the view manager
5493 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5494 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5495 if( anIter != myClippingPlaneInfoMap.end() )
5496 aClippingPlaneInfoList = anIter->second;
5498 if( !aClippingPlaneInfoList.empty() ) {
5499 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5500 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5502 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5503 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5505 QString aPropertyName( "ClippingPlane" );
5506 aPropertyName += gSeparator;
5507 aPropertyName += QString::number( vtkViewers );
5508 aPropertyName += gSeparator;
5509 aPropertyName += QString::number( anId );
5511 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5512 aPropertyValue += gDigitsSep;
5513 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5514 aPropertyValue += gDigitsSep;
5515 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5516 aPropertyValue += gDigitsSep;
5517 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5519 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5523 QVector<SUIT_ViewWindow*> views = vman->getViews();
5524 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5526 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5528 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5529 vtkActorCollection* allActors = aCopy.GetActors();
5530 allActors->InitTraversal();
5531 while (vtkActor* actor = allActors->GetNextActor())
5533 if (actor->GetVisibility()) // store only visible actors
5535 SMESH_Actor* aSmeshActor = 0;
5536 if (actor->IsA("SMESH_Actor"))
5537 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5538 if (aSmeshActor && aSmeshActor->hasIO())
5540 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5543 // entry is "encoded" = it does NOT contain component adress,
5544 // since it is a subject to change on next component loading
5545 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5547 std::string param, vtkParam = vType.toLatin1().data();
5548 vtkParam += gSeparator;
5549 vtkParam += QString::number(vtkViewers).toLatin1().data();
5550 vtkParam += gSeparator;
5553 param = vtkParam + "Visibility";
5554 ip->setParameter(entry, param, "On");
5557 param = vtkParam + "Representation";
5558 ip->setParameter(entry, param, QString::number
5559 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5562 param = vtkParam + "IsShrunk";
5563 ip->setParameter(entry, param, QString::number
5564 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5566 // Displayed entities
5567 unsigned int aMode = aSmeshActor->GetEntityMode();
5568 bool isE = aMode & SMESH_Actor::eEdges;
5569 bool isF = aMode & SMESH_Actor::eFaces;
5570 bool isV = aMode & SMESH_Actor::eVolumes;
5571 bool is0d = aMode & SMESH_Actor::e0DElements;
5572 bool isB = aMode & SMESH_Actor::eBallElem;
5574 QString modeStr ("e");
5575 modeStr += gDigitsSep; modeStr += QString::number(isE);
5576 modeStr += gDigitsSep; modeStr += "f";
5577 modeStr += gDigitsSep; modeStr += QString::number(isF);
5578 modeStr += gDigitsSep; modeStr += "v";
5579 modeStr += gDigitsSep; modeStr += QString::number(isV);
5580 modeStr += gDigitsSep; modeStr += "0d";
5581 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5582 modeStr += gDigitsSep; modeStr += "b";
5583 modeStr += gDigitsSep; modeStr += QString::number(isB);
5585 param = vtkParam + "Entities";
5586 ip->setParameter(entry, param, modeStr.toLatin1().data());
5592 aSmeshActor->GetSufaceColor(r, g, b, delta);
5593 QStringList colorStr;
5594 colorStr << "surface";
5595 colorStr << QString::number(r);
5596 colorStr << QString::number(g);
5597 colorStr << QString::number(b);
5599 colorStr << "backsurface";
5600 colorStr << QString::number(delta);
5602 aSmeshActor->GetVolumeColor(r, g, b, delta);
5603 colorStr << "volume";
5604 colorStr << QString::number(r);
5605 colorStr << QString::number(g);
5606 colorStr << QString::number(b);
5607 colorStr << QString::number(delta);
5609 aSmeshActor->GetEdgeColor(r, g, b);
5611 colorStr << QString::number(r);
5612 colorStr << QString::number(g);
5613 colorStr << QString::number(b);
5615 aSmeshActor->GetNodeColor(r, g, b);
5617 colorStr << QString::number(r);
5618 colorStr << QString::number(g);
5619 colorStr << QString::number(b);
5621 aSmeshActor->GetOutlineColor(r, g, b);
5622 colorStr << "outline";
5623 colorStr << QString::number(r);
5624 colorStr << QString::number(g);
5625 colorStr << QString::number(b);
5627 aSmeshActor->Get0DColor(r, g, b);
5628 colorStr << "elem0d";
5629 colorStr << QString::number(r);
5630 colorStr << QString::number(g);
5631 colorStr << QString::number(b);
5633 aSmeshActor->GetBallColor(r, g, b);
5635 colorStr << QString::number(r);
5636 colorStr << QString::number(g);
5637 colorStr << QString::number(b);
5639 aSmeshActor->GetFacesOrientationColor(r, g, b);
5640 colorStr << "orientation";
5641 colorStr << QString::number(r);
5642 colorStr << QString::number(g);
5643 colorStr << QString::number(b);
5645 param = vtkParam + "Colors";
5646 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5649 QStringList sizeStr;
5651 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5652 sizeStr << "outline";
5653 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5654 sizeStr << "elem0d";
5655 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5657 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5658 sizeStr << "shrink";
5659 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5660 sizeStr << "orientation";
5661 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5662 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5664 param = vtkParam + "Sizes";
5665 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5670 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5671 if( aMarkerType == VTK::MT_USER ) {
5672 markerStr += "custom";
5673 markerStr += gDigitsSep;
5674 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5678 markerStr += gDigitsSep;
5679 markerStr += QString::number( (int)aMarkerType );
5680 markerStr += gDigitsSep;
5681 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5684 param = vtkParam + "PointMarker";
5685 ip->setParameter(entry, param, markerStr.toLatin1().data());
5688 param = vtkParam + "Opacity";
5689 ip->setParameter(entry, param,
5690 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5693 param = vtkParam + "ClippingPlane";
5695 if( !aClippingPlaneInfoList.empty() ) {
5696 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5697 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5699 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5700 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5701 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5702 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5703 if( aSmeshActor == *anIter2 ) {
5704 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5705 QString::number( anId ).toLatin1().constData() );
5712 ip->setParameter( entry, param, "Off" );
5713 } // if (io->hasEntry())
5714 } // SMESH_Actor && hasIO
5716 } // while.. actors traversal
5720 } // if (SVTK view model)
5721 } // for (viewManagers)
5724 // data structures for clipping planes processing
5727 vtkIdType Orientation;
5731 typedef std::list<TPlaneData> TPlaneDataList;
5732 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5734 typedef std::list<vtkActor*> TActorList;
5737 TActorList ActorList;
5738 SUIT_ViewManager* ViewManager;
5740 typedef std::list<TPlaneInfo> TPlaneInfoList;
5741 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5744 * \brief Restore visual parameters
5746 * This method is called after the study document is opened.
5747 * Restore visual parameters from AttributeParameter attribue(s)
5749 void SMESHGUI::restoreVisualParameters (int savePoint)
5752 Kernel_Utils::Localizer loc;
5754 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5755 if (!appStudy || !appStudy->studyDS())
5757 _PTR(Study) studyDS = appStudy->studyDS();
5759 // componentName is used for encoding of entries when storing them in IParameters
5760 std::string componentName = myComponentSMESH->ComponentDataType();
5761 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5762 //if (!aSComponent) return;
5765 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5766 componentName.c_str(),
5768 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5770 // restore map of custom markers and map of clipping planes
5771 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5772 TPlaneDataMap aPlaneDataMap;
5774 std::vector<std::string> properties = ip->getProperties();
5775 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5777 std::string property = *propIt;
5778 QString aPropertyName( property.c_str() );
5779 QString aPropertyValue( ip->getProperty( property ).c_str() );
5781 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5782 if( aPropertyNameList.isEmpty() )
5785 QString aPropertyType = aPropertyNameList[0];
5786 if( aPropertyType == "texture" )
5788 if( aPropertyNameList.size() != 2 )
5792 int anId = aPropertyNameList[1].toInt( &ok );
5793 if( !ok || anId < 1 )
5796 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5797 if( aPropertyValueList.size() != 2 )
5800 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5801 QString aMarkerTextureString = aPropertyValueList[1];
5802 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5803 if( aMarkerTextureStringList.size() != 3 )
5807 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5812 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5816 VTK::MarkerTexture aMarkerTexture;
5817 aMarkerTexture.push_back( aWidth );
5818 aMarkerTexture.push_back( aHeight );
5820 QString aMarkerTextureData = aMarkerTextureStringList[2];
5821 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5823 QChar aChar = aMarkerTextureData.at( i );
5824 if( aChar.isDigit() )
5825 aMarkerTexture.push_back( aChar.digitValue() );
5828 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5830 else if( aPropertyType == "ClippingPlane" )
5832 if( aPropertyNameList.size() != 3 )
5836 int aViewId = aPropertyNameList[1].toInt( &ok );
5837 if( !ok || aViewId < 0 )
5841 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5842 if( !ok || aClippingPlaneId < 0 )
5845 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5846 if( aPropertyValueList.size() != 4 )
5849 TPlaneData aPlaneData;
5850 aPlaneData.Id = aClippingPlaneId;
5853 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5858 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5863 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5868 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5872 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5873 aPlaneDataList.push_back( aPlaneData );
5877 TPlaneInfoMap aPlaneInfoMap;
5879 std::vector<std::string> entries = ip->getEntries();
5881 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5883 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5884 QString entry (ip->decodeEntry(*entIt).c_str());
5886 // Check that the entry corresponds to a real object in the Study
5887 // as the object may be deleted or modified after the visual state is saved.
5888 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5889 if (!so) continue; //Skip the not existent entry
5891 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5892 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5894 std::vector<std::string>::iterator namesIt = paramNames.begin();
5895 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5897 // actors are stored in a map after displaying of them for
5898 // quicker access in the future: map < viewID to actor >
5899 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5901 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5903 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5904 // '_' is used as separator and should not be used in viewer type or parameter names.
5905 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5906 if (lst.size() != 3)
5909 QString viewerTypStr = lst[0];
5910 QString viewIndexStr = lst[1];
5911 QString paramNameStr = lst[2];
5914 int viewIndex = viewIndexStr.toUInt(&ok);
5915 if (!ok) // bad conversion of view index to integer
5919 if (viewerTypStr == SVTK_Viewer::Type())
5921 SMESH_Actor* aSmeshActor = 0;
5922 if (vtkActors.IsBound(viewIndex))
5923 aSmeshActor = vtkActors.Find(viewIndex);
5925 QList<SUIT_ViewManager*> lst;
5926 getApp()->viewManagers(viewerTypStr, lst);
5928 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5929 SUIT_ViewManager* vman = NULL;
5930 if (viewIndex >= 0 && viewIndex < lst.count())
5931 vman = lst.at(viewIndex);
5933 if (paramNameStr == "Visibility")
5935 if (!aSmeshActor && displayer() && vman)
5937 SUIT_ViewModel* vmodel = vman->getViewModel();
5938 // SVTK view model can be casted to SALOME_View
5939 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5941 // store displayed actor in a temporary map for quicker
5942 // access later when restoring other parameters
5943 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5944 vtkRenderer* Renderer = vtkView->getRenderer();
5945 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5946 vtkActorCollection* theActors = aCopy.GetActors();
5947 theActors->InitTraversal();
5948 bool isFound = false;
5949 vtkActor *ac = theActors->GetNextActor();
5950 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5951 if (ac->IsA("SMESH_Actor")) {
5952 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5953 if (aGeomAc->hasIO()) {
5954 Handle(SALOME_InteractiveObject) io =
5955 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5956 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5958 vtkActors.Bind(viewIndex, aGeomAc);
5964 } // if (paramNameStr == "Visibility")
5967 // the rest properties "work" with SMESH_Actor
5970 QString val ((*valuesIt).c_str());
5973 if (paramNameStr == "Representation") {
5974 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5977 else if (paramNameStr == "IsShrunk") {
5979 if (!aSmeshActor->IsShrunk())
5980 aSmeshActor->SetShrink();
5983 if (aSmeshActor->IsShrunk())
5984 aSmeshActor->UnShrink();
5987 // Displayed entities
5988 else if (paramNameStr == "Entities") {
5989 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5990 int aEntityMode = SMESH_Actor::eAllEntity;
5991 for ( int i = 0; i < mode.count(); i+=2 ) {
5992 if ( i < mode.count()-1 ) {
5993 QString type = mode[i];
5994 bool val = mode[i+1].toInt();
5995 if ( type == "e" && !val )
5996 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
5997 else if ( type == "f" && !val )
5998 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
5999 else if ( type == "v" && !val )
6000 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6001 else if ( type == "0d" && !val )
6002 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6003 else if ( type == "b" && !val )
6004 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6007 aSmeshActor->SetEntityMode( aEntityMode );
6010 else if (paramNameStr == "Colors") {
6011 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6018 QColor outlineColor;
6019 QColor orientationColor;
6025 // below lines are required to get default values for delta coefficients
6026 // of backface color for faces and color of reversed volumes
6027 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6028 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6029 for ( int i = 0; i < colors.count(); i++ ) {
6030 QString type = colors[i];
6031 if ( type == "surface" ) {
6032 // face color is set by 3 values r:g:b, where
6033 // - r,g,b - is rgb color components
6034 if ( i+1 >= colors.count() ) break; // format error
6035 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6036 if ( i+2 >= colors.count() ) break; // format error
6037 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6038 if ( i+3 >= colors.count() ) break; // format error
6039 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6040 faceColor.setRgbF( r, g, b );
6043 else if ( type == "backsurface" ) {
6044 // backface color can be defined in several ways
6045 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6046 // - in latest versions, it is set as delta coefficient
6047 bool rgbOk = false, deltaOk;
6048 if ( i+1 >= colors.count() ) break; // format error
6049 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6050 int delta = colors[i+1].toInt( &deltaOk );
6052 if ( i+1 < colors.count() ) // index is shifted to 1
6053 g = colors[i+1].toDouble( &rgbOk );
6054 if ( rgbOk ) i++; // shift index
6055 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6056 b = colors[i+1].toDouble( &rgbOk );
6058 // - as currently there's no way to set directly backsurface color as it was before,
6059 // we ignore old dump where r,g,b triple was set
6060 // - also we check that delta parameter is set properly
6061 if ( !rgbOk && deltaOk )
6064 else if ( type == "volume" ) {
6065 // volume color is set by 4 values r:g:b:delta, where
6066 // - r,g,b - is a normal volume rgb color components
6067 // - delta - is a reversed volume color delta coefficient
6068 if ( i+1 >= colors.count() ) break; // format error
6069 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6070 if ( i+2 >= colors.count() ) break; // format error
6071 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6072 if ( i+3 >= colors.count() ) break; // format error
6073 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6074 if ( i+4 >= colors.count() ) break; // format error
6075 int delta = colors[i+4].toInt( &bOk );
6076 if ( !bOk ) break; // format error
6077 volumeColor.setRgbF( r, g, b );
6081 else if ( type == "edge" ) {
6082 // edge color is set by 3 values r:g:b, where
6083 // - r,g,b - is rgb color components
6084 if ( i+1 >= colors.count() ) break; // format error
6085 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6086 if ( i+2 >= colors.count() ) break; // format error
6087 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6088 if ( i+3 >= colors.count() ) break; // format error
6089 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6090 edgeColor.setRgbF( r, g, b );
6093 else if ( type == "node" ) {
6094 // node color is set by 3 values r:g:b, where
6095 // - r,g,b - is rgb color components
6096 if ( i+1 >= colors.count() ) break; // format error
6097 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6098 if ( i+2 >= colors.count() ) break; // format error
6099 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6100 if ( i+3 >= colors.count() ) break; // format error
6101 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6102 nodeColor.setRgbF( r, g, b );
6105 else if ( type == "elem0d" ) {
6106 // 0d element color is set by 3 values r:g:b, where
6107 // - r,g,b - is rgb color components
6108 if ( i+1 >= colors.count() ) break; // format error
6109 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6110 if ( i+2 >= colors.count() ) break; // format error
6111 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6112 if ( i+3 >= colors.count() ) break; // format error
6113 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6114 elem0dColor.setRgbF( r, g, b );
6117 else if ( type == "ball" ) {
6118 // ball color is set by 3 values r:g:b, where
6119 // - r,g,b - is rgb color components
6120 if ( i+1 >= colors.count() ) break; // format error
6121 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6122 if ( i+2 >= colors.count() ) break; // format error
6123 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6124 if ( i+3 >= colors.count() ) break; // format error
6125 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6126 ballColor.setRgbF( r, g, b );
6129 else if ( type == "outline" ) {
6130 // outline color is set by 3 values r:g:b, where
6131 // - r,g,b - is rgb color components
6132 if ( i+1 >= colors.count() ) break; // format error
6133 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6134 if ( i+2 >= colors.count() ) break; // format error
6135 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6136 if ( i+3 >= colors.count() ) break; // format error
6137 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6138 outlineColor.setRgbF( r, g, b );
6141 else if ( type == "orientation" ) {
6142 // orientation color is set by 3 values r:g:b, where
6143 // - r,g,b - is rgb color components
6144 if ( i+1 >= colors.count() ) break; // format error
6145 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6146 if ( i+2 >= colors.count() ) break; // format error
6147 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6148 if ( i+3 >= colors.count() ) break; // format error
6149 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6150 orientationColor.setRgbF( r, g, b );
6155 if ( nodeColor.isValid() )
6156 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6158 if ( edgeColor.isValid() )
6159 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6161 if ( faceColor.isValid() )
6162 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6164 if ( volumeColor.isValid() )
6165 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6166 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6167 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6169 if ( elem0dColor.isValid() )
6170 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6172 if ( ballColor.isValid() )
6173 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6175 if ( outlineColor.isValid() )
6176 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6177 // orientation color
6178 if ( orientationColor.isValid() )
6179 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6182 else if (paramNameStr == "Sizes") {
6183 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6186 int outlineWidth = -1;
6187 int elem0dSize = -1;
6189 double shrinkSize = -1;
6190 double orientationSize = -1;
6191 bool orientation3d = false;
6192 for ( int i = 0; i < sizes.count(); i++ ) {
6193 QString type = sizes[i];
6194 if ( type == "line" ) {
6195 // line (wireframe) width is given as single integer value
6196 if ( i+1 >= sizes.count() ) break; // format error
6197 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6201 if ( type == "outline" ) {
6202 // outline width is given as single integer value
6203 if ( i+1 >= sizes.count() ) break; // format error
6204 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6208 else if ( type == "elem0d" ) {
6209 // 0d element size is given as single integer value
6210 if ( i+1 >= sizes.count() ) break; // format error
6211 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6215 else if ( type == "ball" ) {
6216 // ball size is given as single integer value
6217 if ( i+1 >= sizes.count() ) break; // format error
6218 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6222 else if ( type == "shrink" ) {
6223 // shrink factor is given as single floating point value
6224 if ( i+1 >= sizes.count() ) break; // format error
6225 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6229 else if ( type == "orientation" ) {
6230 // orientation vectors are specified by two values size:3d, where
6231 // - size - is a floating point value specifying scale factor
6232 // - 3d - is a boolean
6233 if ( i+1 >= sizes.count() ) break; // format error
6234 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6235 if ( i+2 >= sizes.count() ) break; // format error
6236 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6237 orientationSize = v1;
6238 orientation3d = (bool)v2;
6242 // line (wireframe) width
6243 if ( lineWidth > 0 )
6244 aSmeshActor->SetLineWidth( lineWidth );
6246 if ( outlineWidth > 0 )
6247 aSmeshActor->SetOutlineWidth( outlineWidth );
6248 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6249 aSmeshActor->SetOutlineWidth( lineWidth );
6251 if ( elem0dSize > 0 )
6252 aSmeshActor->Set0DSize( elem0dSize );
6255 aSmeshActor->SetBallSize( ballSize );
6257 if ( shrinkSize > 0 )
6258 aSmeshActor->SetShrinkFactor( shrinkSize );
6259 // orientation vectors
6260 if ( orientationSize > 0 ) {
6261 aSmeshActor->SetFacesOrientationScale( orientationSize );
6262 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6266 else if (paramNameStr == "PointMarker") {
6267 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6268 if( data.count() >= 2 ) {
6270 int aParam1 = data[1].toInt( &ok );
6272 if( data[0] == "std" && data.count() == 3 ) {
6273 int aParam2 = data[2].toInt( &ok );
6274 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6276 else if( data[0] == "custom" ) {
6277 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6278 if( markerIt != aMarkerMap.end() ) {
6279 VTK::MarkerData aMarkerData = markerIt->second;
6280 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6287 else if (paramNameStr == "Opacity") {
6288 aSmeshActor->SetOpacity(val.toFloat());
6291 else if (paramNameStr.startsWith("ClippingPlane")) {
6292 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6293 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
6294 // new format - val looks like "Off" or "0" (plane id)
6295 // (note: in new format "Off" value is used only for consistency,
6296 // so it is processed together with values in old format)
6297 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
6298 if( anIsOldFormat ) {
6299 if (paramNameStr == "ClippingPlane1" || val == "Off")
6300 aSmeshActor->RemoveAllClippingPlanes();
6302 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
6303 double aDistance = vals[1].toFloat();
6305 anAngle[0] = vals[2].toFloat();
6306 anAngle[1] = vals[3].toFloat();
6308 QList<SUIT_ViewManager*> lst;
6309 getApp()->viewManagers(viewerTypStr, lst);
6310 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6311 if (viewIndex >= 0 && viewIndex < lst.count()) {
6312 SUIT_ViewManager* vman = lst.at(viewIndex);
6313 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6315 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6317 SMESH::TActorList anActorList;
6318 anActorList.push_back( aSmeshActor );
6319 SMESH::OrientedPlane* aPlane =
6320 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
6322 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6323 aClippingPlaneInfo.Plane = aPlane;
6324 aClippingPlaneInfo.ActorList = anActorList;
6325 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6332 int aPlaneId = val.toInt( &ok );
6333 if( ok && aPlaneId >= 0 ) {
6334 bool anIsDefinedPlane = false;
6335 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6336 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6337 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6338 TPlaneInfo& aPlaneInfo = *anIter;
6339 if( aPlaneInfo.PlaneId == aPlaneId ) {
6340 aPlaneInfo.ActorList.push_back( aSmeshActor );
6341 anIsDefinedPlane = true;
6345 if( !anIsDefinedPlane ) {
6346 TPlaneInfo aPlaneInfo;
6347 aPlaneInfo.PlaneId = aPlaneId;
6348 aPlaneInfo.ActorList.push_back( aSmeshActor );
6349 aPlaneInfo.ViewManager = vman;
6351 // to make the list sorted by plane id
6352 anIter = aPlaneInfoList.begin();
6353 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6354 const TPlaneInfo& aPlaneInfoRef = *anIter;
6355 if( aPlaneInfoRef.PlaneId > aPlaneId )
6358 aPlaneInfoList.insert( anIter, aPlaneInfo );
6363 } // if (aSmeshActor)
6364 } // other parameters than Visibility
6366 } // for names/parameters iterator
6367 } // for entries iterator
6369 // take into account planes with empty list of actors referred to them
6370 QList<SUIT_ViewManager*> aVMList;
6371 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6373 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6374 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6375 int aViewId = aPlaneDataIter->first;
6376 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6377 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6379 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6381 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6382 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6383 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6384 const TPlaneData& aPlaneData = *anIter2;
6385 int aPlaneId = aPlaneData.Id;
6387 bool anIsFound = false;
6388 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6389 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6390 const TPlaneInfo& aPlaneInfo = *anIter3;
6391 if( aPlaneInfo.PlaneId == aPlaneId ) {
6398 TPlaneInfo aPlaneInfo; // ActorList field is empty
6399 aPlaneInfo.PlaneId = aPlaneId;
6400 aPlaneInfo.ViewManager = aViewManager;
6402 // to make the list sorted by plane id
6403 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6404 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6405 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6406 if( aPlaneInfoRef.PlaneId > aPlaneId )
6409 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6415 // add clipping planes to actors according to the restored parameters
6416 // and update the clipping plane map
6417 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6418 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6419 int aViewId = anIter1->first;
6420 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6422 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6423 if( anIter2 == aPlaneDataMap.end() )
6425 const TPlaneDataList& aPlaneDataList = anIter2->second;
6427 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6428 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6429 const TPlaneInfo& aPlaneInfo = *anIter3;
6430 int aPlaneId = aPlaneInfo.PlaneId;
6431 const TActorList& anActorList = aPlaneInfo.ActorList;
6432 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6436 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6440 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6442 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6443 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6444 const TPlaneData& aPlaneData = *anIter4;
6445 if( aPlaneData.Id == aPlaneId ) {
6446 SMESH::OrientedPlane* aPlane =
6447 SMESHGUI_ClippingDlg::AddPlane( anActorList,
6449 (SMESH::Orientation)aPlaneData.Orientation,
6450 aPlaneData.Distance,
6453 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6454 aClippingPlaneInfo.Plane = aPlane;
6455 aClippingPlaneInfo.ActorList = anActorList;
6456 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6464 // update all VTK views
6465 QList<SUIT_ViewManager*> lst;
6466 getApp()->viewManagers(lst);
6467 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6468 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6469 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6470 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6471 vtkView->getRenderer()->ResetCameraClippingRange();
6478 \brief Adds preferences for dfont of VTK viewer
6480 \param pIf group identifier
6481 \param param parameter
6482 \return identifier of preferences
6484 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6486 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6488 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6491 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6492 fam.append( tr( "SMESH_FONT_COURIER" ) );
6493 fam.append( tr( "SMESH_FONT_TIMES" ) );
6495 setPreferenceProperty( tfont, "fonts", fam );
6497 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6498 if ( needSize ) f = f | QtxFontEdit::Size;
6499 setPreferenceProperty( tfont, "features", f );
6505 \brief Actions after hypothesis edition
6506 Updates object browser after hypothesis edition
6508 void SMESHGUI::onHypothesisEdit( int result )
6511 SMESHGUI::Modified();
6512 updateObjBrowser( true );
6517 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6518 \param pview view being closed
6520 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6521 #ifndef DISABLE_PLOT2DVIEWER
6522 //Crear all Plot2d Viewers if need.
6523 SMESH::ClearPlot2Viewers(pview);
6527 void SMESHGUI::message( const QString& msg )
6530 QStringList data = msg.split("/");
6531 if ( data.count() > 0 ) {
6532 if ( data.first() == "mesh_loading" ) {
6534 QString entry = data.count() > 1 ? data[1] : QString();
6535 if ( entry.isEmpty() )
6538 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6540 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6543 name = obj->GetName().c_str();
6544 if ( name.isEmpty() )
6547 if ( data.last() == "stop" )
6548 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6550 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6551 QApplication::processEvents();
6557 \brief Connects or disconnects signals about activating and cloning view on the module slots
6558 \param pview view which is connected/disconnected
6560 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6564 SUIT_ViewManager* viewMgr = pview->getViewManager();
6566 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6567 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6569 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6570 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6575 \brief Return \c true if object can be renamed
6577 bool SMESHGUI::renameAllowed( const QString& entry) const {
6578 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6582 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6586 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6591 if(appStudy->isComponent(entry) || obj->isReference())
6594 // check type to prevent renaming of inappropriate objects
6595 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6596 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6597 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6598 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6599 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6600 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6607 Rename object by entry.
6608 \param entry entry of the object
6609 \param name new name of the object
6610 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6612 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6614 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6618 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6623 _PTR(Study) aStudy = appStudy->studyDS();
6628 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6630 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6635 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6636 _PTR(GenericAttribute) anAttr;
6637 _PTR(AttributeName) aName;
6639 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6641 // check type to prevent renaming of inappropriate objects
6642 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6643 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6644 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6645 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6646 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6647 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6648 if ( !name.isEmpty() ) {
6649 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6651 // update name of group object and its actor
6652 Handle(SALOME_InteractiveObject) IObject =
6653 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6655 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6656 if( !aGroupObject->_is_nil() ) {
6657 aGroupObject->SetName( qPrintable(name) );
6658 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6659 anActor->setName( qPrintable(name) );
6670 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6672 static QList<QColor> colors;
6674 if ( colors.isEmpty() ) {
6676 for (int s = 0; s < 2 ; s++)
6678 for (int v = 100; v >= 40; v = v - 20)
6680 for (int h = 0; h < 359 ; h = h + 60)
6682 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
6687 static int currentColor = 0;
6689 SALOMEDS::Color color;
6690 color.R = (double)colors[currentColor].red() / 255.0;
6691 color.G = (double)colors[currentColor].green() / 255.0;
6692 color.B = (double)colors[currentColor].blue() / 255.0;
6694 currentColor = (currentColor+1) % colors.count();