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 <PyInterp_Interp.h>
121 #include <SUIT_Desktop.h>
122 #include <SUIT_FileDlg.h>
123 #include <SUIT_MessageBox.h>
124 #include <SUIT_OverrideCursor.h>
125 #include <SUIT_ResourceMgr.h>
126 #include <SUIT_Session.h>
128 #include <QtxPopupMgr.h>
129 #include <QtxFontEdit.h>
131 #include <SALOME_ListIO.hxx>
132 #include <SALOME_ListIteratorOfListIO.hxx>
134 #ifndef DISABLE_PLOT2DVIEWER
135 #include <SPlot2d_ViewModel.h>
136 #include <SPlot2d_Histogram.h>
140 #include <SALOMEconfig.h>
141 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
142 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
143 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
146 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
147 #include <QApplication>
149 #include <QTextStream>
152 #include <boost/shared_ptr.hpp>
155 #include <vtkCallbackCommand.h>
156 #include <vtkCamera.h>
157 #include <vtkLookupTable.h>
158 #include <vtkPlane.h>
159 #include <vtkRenderer.h>
161 // SALOME KERNEL includes
162 #include <SALOMEDSClient_ClientFactory.hxx>
163 #include <SALOMEDSClient_IParameters.hxx>
164 #include <SALOMEDSClient_SComponent.hxx>
165 #include <SALOMEDSClient_StudyBuilder.hxx>
166 #include <SALOMEDS_Study.hxx>
167 #include <SALOMEDS_SObject.hxx>
170 #include <Standard_ErrorHandler.hxx>
171 #include <NCollection_DataMap.hxx>
173 #include <Basics_Utils.hxx>
175 //To disable automatic genericobj management, the following line should be commented.
176 //Otherwise, it should be uncommented.
177 //Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
178 #define WITHGENERICOBJ
180 // Below macro, when uncommented, switches on simplified (more performant) algorithm
181 // of auto-color picking up
182 #define SIMPLE_AUTOCOLOR
186 //=============================================================
187 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
190 void ExportMeshToFile(int theCommandID);
192 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
194 void SetDisplayEntity(int theCommandID);
196 void Control( int theCommandID );
200 //=============================================================
201 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
205 std::string myExtension;
207 if ( theCommandID == 113 ) {
208 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
209 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
211 else if ( theCommandID == 112 ) {
212 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
214 else if ( theCommandID == 111 ) {
215 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
217 else if ( theCommandID == 115 ) {
218 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
220 else if ( theCommandID == 116 ) {
221 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
223 else if ( theCommandID == 117 ) {
224 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
225 filter.append( QObject::tr( "All files (*)" ) );
227 else if ( theCommandID == 118 ) {
228 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
229 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
232 QString anInitialPath = "";
233 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
234 anInitialPath = QDir::currentPath();
236 QStringList filenames;
237 bool toCreateGroups = true;
239 // if ( theCommandID == 118 ) { // GMF
240 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
241 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
242 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
243 // fd->setNameFilters( filter );
244 // fd->SetChecked( true );
246 // filenames << fd->selectedFile();
247 // toCreateGroups = fd->IsChecked();
253 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
256 QObject::tr( "SMESH_IMPORT_MESH" ) );
258 if ( filenames.count() > 0 ) {
259 SUIT_OverrideCursor wc;
260 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
263 QStringList anEntryList;
264 bool isEmpty = false;
265 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
266 QString filename = *it;
267 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
269 switch ( theCommandID ) {
272 // DAT format (currently unsupported)
273 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
274 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
280 aMeshes->length( 1 );
281 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
282 if ( aMeshes[0]->_is_nil() )
283 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
284 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
290 SMESH::DriverMED_ReadStatus res;
291 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
292 if ( res != SMESH::DRS_OK ) {
293 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
294 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
301 aMeshes->length( 1 );
302 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
303 if ( aMeshes[0]->_is_nil() ) {
304 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
305 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
312 SMESH::DriverMED_ReadStatus res;
313 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
314 if ( res != SMESH::DRS_OK ) {
315 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
316 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
323 SMESH::DriverMED_ReadStatus res;
324 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
325 if ( res != SMESH::DRS_OK ) {
326 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
327 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
334 SMESH::ComputeError_var res;
335 aMeshes->length( 1 );
336 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
339 if ( res->code != SMESH::DRS_OK ) {
340 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
341 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
342 if ( strlen( res->comment.in() ) > 0 ) {
343 errors.back() += ": ";
344 errors.back() += res->comment.in();
351 catch ( const SALOME::SALOME_Exception& S_ex ) {
352 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
353 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
356 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
357 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
359 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
360 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
361 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
362 if ( theCommandID == 112 ) // mesh names aren't taken from the file for UNV import
363 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
365 anEntryList.append( aMeshSO->GetID().c_str() );
373 // update Object browser
374 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
376 // browse to the published meshes
377 if( LightApp_Application* anApp =
378 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
379 anApp->browseObjects( anEntryList );
381 // show Error message box if there were errors
382 if ( errors.count() > 0 ) {
383 SUIT_MessageBox::critical( SMESHGUI::desktop(),
384 QObject::tr( "SMESH_ERROR" ),
385 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
388 // show warning message box, if some imported mesh is empty
390 SUIT_MessageBox::warning( SMESHGUI::desktop(),
391 QObject::tr( "SMESH_WRN_WARNING" ),
392 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
397 //================================================================================
399 * \brief Export selected meshes or groups into a file
401 //================================================================================
403 void ExportMeshToFile( int theCommandID )
405 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
406 SALOME_ListIO selected;
408 aSel->selectedObjects( selected );
410 const bool isMED = ( theCommandID == 122 || theCommandID == 125 );
411 const bool isDAT = ( theCommandID == 121 || theCommandID == 124 );
412 const bool isUNV = ( theCommandID == 123 || theCommandID == 126 );
413 const bool isSTL = ( theCommandID == 140 || theCommandID == 141 );
414 const bool isCGNS= ( theCommandID == 142 || theCommandID == 143 );
415 const bool isSAUV= ( theCommandID == 144 || theCommandID == 145 );
416 const bool isGMF = ( theCommandID == 146 || theCommandID == 147 );
418 // actually, the following condition can't be met (added for insurance)
419 if( selected.Extent() == 0 ||
420 ( selected.Extent() > 1 && !isMED && !isSTL ))
423 // get mesh object from selection and check duplication of their names
424 bool hasDuplicatedMeshNames = false;
425 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
426 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
427 SALOME_ListIteratorOfListIO It( selected );
428 for( ; It.More(); It.Next() )
430 Handle(SALOME_InteractiveObject) anIObject = It.Value();
431 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
432 if ( aMeshItem->_is_nil() ) {
433 SUIT_MessageBox::warning( SMESHGUI::desktop(),
434 QObject::tr( "SMESH_WRN_WARNING" ),
435 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
439 QString aMeshName = anIObject->getName();
441 // check for name duplications
442 if ( !hasDuplicatedMeshNames )
443 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
444 if( aMeshName == (*aMeshIter).second ) {
445 hasDuplicatedMeshNames = true;
450 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
453 if( hasDuplicatedMeshNames && isMED ) {
454 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
455 QObject::tr("SMESH_WRN_WARNING"),
456 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
457 QObject::tr("SMESH_BUT_YES"),
458 QObject::tr("SMESH_BUT_NO"), 0, 1);
463 aMeshIter = aMeshList.begin();
464 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
465 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
466 QString aMeshName = (*aMeshIter).second;
468 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
470 // check for equal group names within each mesh
471 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
472 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
473 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
474 int aRet = SUIT_MessageBox::warning
475 (SMESHGUI::desktop(),
476 QObject::tr("SMESH_WRN_WARNING"),
477 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
478 QObject::tr("SMESH_BUT_YES"),
479 QObject::tr("SMESH_BUT_NO"), 0, 1);
486 // Warn the user about presence of not supported elements
488 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
492 notSupportedElemTypes.push_back( SMESH::Entity_0D );
493 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
498 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
499 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
500 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
501 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
502 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
503 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
504 notSupportedElemTypes.push_back( SMESH::Entity_0D );
505 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
510 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
511 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
512 notSupportedElemTypes.push_back( SMESH::Entity_0D );
513 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
518 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
519 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
524 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
525 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
526 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
527 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
528 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
529 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
530 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
535 notSupportedElemTypes.push_back( SMESH::Entity_0D );
536 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
537 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
538 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
539 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
540 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
541 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
542 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
543 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
545 if ( ! notSupportedElemTypes.empty() )
547 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
548 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
549 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
550 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
552 if ( !presentNotSupported.empty() )
555 const char* typeMsg[SMESH::Entity_Last] = {
556 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
557 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
558 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
559 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
560 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
561 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
562 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
563 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
565 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
566 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
567 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
568 if ( iType != presentNotSupported.size() - 1 )
569 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
571 int aRet = SUIT_MessageBox::warning
572 (SMESHGUI::desktop(),
573 QObject::tr("SMESH_WRN_WARNING"),
574 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
575 QObject::tr("SMESH_BUT_YES"),
576 QObject::tr("SMESH_BUT_NO"), 0, 1);
581 // Get parameters of export operation
584 SMESH::MED_VERSION aFormat;
585 // Init the parameters with the default values
586 bool aIsASCII_STL = true;
587 bool toCreateGroups = false;
588 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
590 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
591 bool toOverwrite = true;
592 bool toFindOutDim = true;
594 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
595 QString anInitialPath = "";
596 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
597 anInitialPath = QDir::currentPath();
599 // Get a file name to write in and additional otions
600 if ( isUNV || isDAT || isGMF ) // Export w/o options
603 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
605 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
607 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
608 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
609 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
610 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
611 anInitialPath + QString("/") + aMeshName,
612 aFilter, aTitle, false);
614 else if ( isCGNS )// Export to CGNS
616 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
617 fd->setWindowTitle( aTitle );
618 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
619 if ( !anInitialPath.isEmpty() )
620 fd->setDirectory( anInitialPath );
621 fd->selectFile(aMeshName);
622 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
623 fd->setValidator( fv );
626 aFilename = fd->selectedFile();
627 toOverwrite = fv->isOverwrite();
631 else if ( isSTL ) // Export to STL
633 QMap<QString, int> aFilterMap;
634 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
635 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
638 QMap<QString, int>::const_iterator it = aFilterMap.begin();
639 for ( ; it != aFilterMap.end(); ++it )
640 filters.push_back( it.key() );
642 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
643 fd->setWindowTitle( aTitle );
644 fd->setNameFilters( filters );
645 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
646 if ( !anInitialPath.isEmpty() )
647 fd->setDirectory( anInitialPath );
648 fd->selectFile(aMeshName);
652 aFilename = fd->selectedFile();
653 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
658 else if ( isMED || isSAUV ) // Export to MED or SAUV
660 QMap<QString, SMESH::MED_VERSION> aFilterMap;
661 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
663 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
664 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
665 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
668 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
669 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
670 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
674 QString aDefaultFilter;
675 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
676 for ( ; it != aFilterMap.end(); ++it ) {
677 filters.push_back( it.key() );
678 if (it.value() == SMESH::MED_V2_2)
679 aDefaultFilter = it.key();
681 QStringList checkBoxes;
682 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
684 SalomeApp_CheckFileDlg* fd =
685 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
686 fd->setWindowTitle( aTitle );
687 fd->setNameFilters( filters );
688 fd->selectNameFilter(aDefaultFilter);
689 fd->SetChecked(0,toCreateGroups);
690 fd->SetChecked(1,toFindOutDim);
691 if ( !anInitialPath.isEmpty() )
692 fd->setDirectory( anInitialPath );
693 fd->selectFile(aMeshName);
695 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
696 fd->setValidator( fv );
701 aFilename = fd->selectedFile();
703 aFilename = QString::null;
706 aFormat = aFilterMap[fd->selectedNameFilter()];
707 toOverwrite = fv->isOverwrite();
709 if ( !aFilename.isEmpty() ) {
710 // med-2.1 does not support poly elements
711 if ( aFormat==SMESH::MED_V2_1 )
712 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
713 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
714 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
715 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
716 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
718 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
719 QObject::tr("SMESH_WRN_WARNING"),
720 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
721 QObject::tr("SMESH_BUT_YES"),
722 QObject::tr("SMESH_BUT_NO"), 0, 1);
730 // can't append to an existing using other format
731 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
732 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
733 if( !isVersionOk || aVersion != aFormat ) {
734 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
735 QObject::tr("SMESH_WRN_WARNING"),
736 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
737 QObject::tr("SMESH_BUT_YES"),
738 QObject::tr("SMESH_BUT_NO"), 0, 1);
745 QStringList aMeshNamesCollisionList;
746 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
747 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
748 QString anExistingMeshName( aMeshNames[ i ] );
749 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
750 QString anExportMeshName = (*aMeshIter).second;
751 if( anExportMeshName == anExistingMeshName ) {
752 aMeshNamesCollisionList.append( anExportMeshName );
757 if( !aMeshNamesCollisionList.isEmpty() ) {
758 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
759 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
760 QObject::tr("SMESH_WRN_WARNING"),
761 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
762 QObject::tr("SMESH_BUT_YES"),
763 QObject::tr("SMESH_BUT_NO"),
764 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
773 toCreateGroups = fd->IsChecked(0);
774 toFindOutDim = fd->IsChecked(1);
784 if ( !aFilename.isEmpty() ) {
785 // Check whether the file already exists and delete it if yes
786 QFile aFile( aFilename );
787 if ( aFile.exists() && toOverwrite )
789 SUIT_OverrideCursor wc;
792 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
793 // bool Renumber = false;
794 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
796 // Renumber= resMgr->booleanValue("renumbering");
798 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
799 // aMeshEditor->RenumberNodes();
800 // aMeshEditor->RenumberElements();
801 // if ( SMESHGUI::automaticUpdate() )
802 // SMESH::UpdateView();
806 aMeshIter = aMeshList.begin();
807 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
809 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
810 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
811 if ( aMeshOrGroup->_is_equivalent( aMeshItem ))
812 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
813 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
815 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
816 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
821 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
823 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
824 if( !aMeshItem->_is_nil() )
825 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
830 if ( aMeshOrGroup->_is_equivalent( aMesh ))
831 aMesh->ExportDAT( aFilename.toUtf8().data() );
833 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
837 if ( aMeshOrGroup->_is_equivalent( aMesh ))
838 aMesh->ExportUNV( aFilename.toUtf8().data() );
840 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
844 if ( aMeshOrGroup->_is_equivalent( aMesh ))
845 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
847 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
851 aMeshIter = aMeshList.begin();
852 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
854 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
855 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
856 aMeshItem->ExportCGNS( aMeshOrGroup,
857 aFilename.toUtf8().data(),
858 toOverwrite && aMeshIndex == 0 );
863 toCreateGroups = true;
864 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
867 catch (const SALOME::SALOME_Exception& S_ex){
869 SUIT_MessageBox::warning(SMESHGUI::desktop(),
870 QObject::tr("SMESH_WRN_WARNING"),
871 QObject::tr("SMESH_EXPORT_FAILED"));
877 inline void InverseEntityMode(unsigned int& theOutputMode,
878 unsigned int theMode)
880 bool anIsNotPresent = ~theOutputMode & theMode;
882 theOutputMode |= theMode;
884 theOutputMode &= ~theMode;
887 void SetDisplayEntity(int theCommandID){
888 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
889 SALOME_ListIO selected;
891 aSel->selectedObjects( selected );
893 if(selected.Extent() >= 1){
894 SALOME_ListIteratorOfListIO It( selected );
895 for( ; It.More(); It.Next()){
896 Handle(SALOME_InteractiveObject) IObject = It.Value();
897 if(IObject->hasEntry()){
898 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
899 unsigned int aMode = anActor->GetEntityMode();
900 switch(theCommandID){
902 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
905 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
908 InverseEntityMode(aMode,SMESH_Actor::eEdges);
911 InverseEntityMode(aMode,SMESH_Actor::eFaces);
914 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
917 aMode = SMESH_Actor::eAllEntity;
921 anActor->SetEntityMode(aMode);
930 SALOME_ListIO selected;
931 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
935 LightApp_SelectionMgr* aSel = app->selectionMgr();
936 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
937 if( !aSel || !appStudy )
940 aSel->selectedObjects( selected );
941 if( selected.IsEmpty() )
944 Handle(SALOME_InteractiveObject) anIObject = selected.First();
946 _PTR(Study) aStudy = appStudy->studyDS();
947 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
948 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
949 if( aMainObject->_is_nil() )
952 SUIT_OverrideCursor wc;
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
970 aGroupObject->SetColor( aColor );
972 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
976 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
977 switch ( aGroupObject->GetType ()) {
979 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
981 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
983 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
985 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
987 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
988 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
991 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
992 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
998 SMESH::RepaintCurrentView();
1001 void OverallMeshQuality() {
1002 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1003 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1004 SALOME_ListIO selected;
1006 aSel->selectedObjects( selected );
1008 if ( selected.IsEmpty() ) return;
1009 SALOME_ListIteratorOfListIO It( selected );
1010 for ( ; It.More(); It.Next() ) {
1011 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1012 ctrlDlg->showInfo( It.Value() );
1017 QString functorToString( SMESH::Controls::FunctorPtr f )
1019 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1020 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1021 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1022 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1023 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1024 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1025 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1026 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1027 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1028 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1029 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1030 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1031 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1032 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1033 type = QObject::tr( "WARP_ELEMENTS" );
1034 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1035 type = QObject::tr( "TAPER_ELEMENTS" );
1036 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1037 type = QObject::tr( "SKEW_ELEMENTS" );
1038 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1039 type = QObject::tr( "AREA_ELEMENTS" );
1040 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1041 type = QObject::tr( "LENGTH_EDGES" );
1042 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1043 type = QObject::tr( "LENGTH2D_EDGES" );
1044 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1045 type = QObject::tr( "MULTI_BORDERS" );
1046 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1047 type = QObject::tr( "MULTI2D_BORDERS" );
1048 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1049 type = QObject::tr( "FREE_NODES" );
1050 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1051 type = QObject::tr( "FREE_EDGES" );
1052 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1053 type = QObject::tr( "FREE_BORDERS" );
1054 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1055 type = QObject::tr( "FREE_FACES" );
1056 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1057 type = QObject::tr( "BARE_BORDER_VOLUME" );
1058 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1059 type = QObject::tr( "BARE_BORDER_FACE" );
1060 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1061 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1062 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1063 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1064 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1065 type = QObject::tr( "EQUAL_NODE" );
1066 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1067 type = QObject::tr( "EQUAL_EDGE" );
1068 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1069 type = QObject::tr( "EQUAL_FACE" );
1070 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1071 type = QObject::tr( "EQUAL_VOLUME" );
1075 void SaveDistribution()
1077 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1078 SALOME_ListIO selected;
1080 aSel->selectedObjects( selected );
1082 if ( selected.Extent() == 1 ) {
1083 Handle(SALOME_InteractiveObject) anIO = selected.First();
1084 if ( anIO->hasEntry() ) {
1085 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1086 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1087 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1088 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1089 if ( aScalarBarActor && aFunctor ) {
1090 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1092 std::vector<int> elements;
1093 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1094 if ( mesh->_is_nil() ) {
1095 SMESH::SMESH_IDSource_var idSource =
1096 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1097 if ( !idSource->_is_nil() )
1099 SMESH::long_array_var ids = idSource->GetIDs();
1100 elements.resize( ids->length() );
1101 for ( unsigned i = 0; i < elements.size(); ++i )
1102 elements[i] = ids[i];
1105 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1106 vtkLookupTable* lookupTable =
1107 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1108 double * minmax = lookupTable->GetRange();
1109 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1110 std::vector<int> nbEvents;
1111 std::vector<double> funValues;
1112 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
1113 QString anInitialPath = "";
1114 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1115 anInitialPath = QDir::currentPath();
1116 QString aMeshName = anIO->getName();
1118 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1119 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1120 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1121 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1122 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1125 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1127 if ( !aFilename.isEmpty() ) {
1128 QFile f( aFilename );
1129 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1130 QTextStream out( &f );
1131 out << "# Mesh: " << aMeshName << endl;
1132 out << "# Control: " << functorToString( aFunctor ) << endl;
1134 out.setFieldWidth( 10 );
1135 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1136 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1147 void ShowDistribution() {
1148 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1149 SALOME_ListIO selected;
1151 aSel->selectedObjects( selected );
1153 if ( selected.Extent() == 1 ) {
1154 Handle(SALOME_InteractiveObject) anIO = selected.First();
1155 if ( anIO->hasEntry() ) {
1156 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1157 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1158 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1159 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1165 #ifndef DISABLE_PLOT2DVIEWER
1166 void PlotDistribution() {
1167 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1171 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1172 SALOME_ListIO selected;
1174 aSel->selectedObjects( selected );
1176 if ( selected.Extent() == 1 ) {
1177 Handle(SALOME_InteractiveObject) anIO = selected.First();
1178 if ( anIO->hasEntry() ) {
1179 //Find Actor by entry before getting Plot2d viewer,
1180 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1181 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1183 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1188 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1192 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1196 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1197 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1198 QString functorName = functorToString( anActor->GetFunctor());
1199 QString aHistogramName("%1 : %2");
1200 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1201 aHistogram->setName(aHistogramName);
1202 aHistogram->setHorTitle(functorName);
1203 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1204 aPlot->displayObject(aHistogram, true);
1209 #endif //DISABLE_PLOT2DVIEWER
1211 void DisableAutoColor(){
1212 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1213 SALOME_ListIO selected;
1215 aSel->selectedObjects( selected );
1217 if(selected.Extent()){
1218 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1219 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1220 if ( !aMesh->_is_nil() ) {
1221 aMesh->SetAutoColor( false );
1226 void sortChildren(){
1227 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1228 SALOME_ListIO selected;
1230 aSel->selectedObjects( selected );
1232 if(selected.Extent()){
1233 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1234 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1235 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1237 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1238 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1245 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1247 SALOME_ListIO selected;
1248 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1252 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1253 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1254 if( !aSel || !appStudy )
1257 if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection
1258 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1259 aModule->EmitSignalDeactivateDialog();
1260 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1261 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1266 _PTR(Study) aStudy = appStudy->studyDS();
1268 aSel->selectedObjects( selected );
1270 if(selected.Extent() >= 1){
1271 switch(theCommandID){
1273 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1274 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1279 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1280 QColor orientationColor, outlineColor, volumeColor;
1281 int deltaF = 0, deltaV = 0;
1285 int outlineWidth = 1;
1286 double shrinkCoef = 0.0;
1287 double orientationScale = 0.0;
1288 bool orientation3d = false;
1289 VTK::MarkerType markerType = VTK::MT_NONE;
1290 VTK::MarkerScale markerScale = VTK::MS_NONE;
1292 bool hasNodes = false;
1293 int presentEntities = 0;
1294 bool firstTime = true;
1296 SALOME_ListIteratorOfListIO It( selected );
1297 for ( ; It.More(); It.Next() ) {
1298 Handle(SALOME_InteractiveObject) IObject = It.Value();
1299 if ( !IObject->hasEntry() ) continue;
1300 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1301 if ( !anActor || !anActor->GetObject() ) continue;
1304 // nodes: color, marker
1305 anActor->GetNodeColor( color[0], color[1], color[2] );
1306 nodeColor.setRgbF( color[0], color[1], color[2] );
1307 markerType = anActor->GetMarkerType();
1308 markerScale = anActor->GetMarkerScale();
1309 markerId = anActor->GetMarkerTexture();
1310 // edges: color, width
1311 anActor->GetEdgeColor( color[0], color[1], color[2] );
1312 edgeColor.setRgbF( color[0], color[1], color[2] );
1313 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1314 // faces: front color, back color (delta)
1315 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1316 faceColor.setRgbF( color[0], color[1], color[2] );
1317 // faces: front color, back color (delta)
1318 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1319 volumeColor.setRgbF( color[0], color[1], color[2] );
1320 // 0d elements: color, size
1321 anActor->Get0DColor( color[0], color[1], color[2] );
1322 elem0dColor.setRgbF( color[0], color[1], color[2] );
1323 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1324 // balls: color, size
1325 anActor->GetBallColor( color[0], color[1], color[2] );
1326 ballColor.setRgbF( color[0], color[1], color[2] );
1327 ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1329 anActor->GetOutlineColor( color[0], color[1], color[2] );
1330 outlineColor.setRgbF( color[0], color[1], color[2] );
1331 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1332 // orientation vectors: color, scale, 3d flag
1333 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1334 orientationColor.setRgbF( color[0], color[1], color[2] );
1335 orientationScale = anActor->GetFacesOrientationScale();
1336 orientation3d = anActor->GetFacesOrientation3DVectors();
1338 shrinkCoef = anActor->GetShrinkFactor();
1341 firstTime = false; // we only take properties from first object (for performance reasons)
1344 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1345 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1346 presentEntities = presentEntities | SMESH_Actor::eEdges;
1347 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1348 presentEntities = presentEntities | SMESH_Actor::eFaces;
1349 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1350 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1351 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1352 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1353 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1354 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1356 // as we know that all types of elements are present, we can exit the loop
1357 if ( presentEntities == SMESH_Actor::eAllEntity )
1361 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1362 // nodes: color, marker
1363 dlg.setNodeColor( nodeColor );
1364 if( markerType != VTK::MT_USER )
1365 dlg.setNodeMarker( markerType, markerScale );
1367 dlg.setNodeCustomMarker( markerId );
1368 // edges: color, line width
1369 dlg.setEdgeColor( edgeColor );
1370 dlg.setEdgeWidth( edgeWidth );
1371 // faces: front color, back color
1372 dlg.setFaceColor( faceColor, deltaF );
1373 // volumes: normal color, reversed color
1374 dlg.setVolumeColor( volumeColor, deltaV );
1375 // outlines: color, line width
1376 dlg.setOutlineColor( outlineColor );
1377 dlg.setOutlineWidth( outlineWidth );
1378 // 0d elements: color, size
1379 dlg.setElem0dColor( elem0dColor );
1380 dlg.setElem0dSize( elem0dSize );
1381 // balls: color, size
1382 dlg.setBallColor( ballColor );
1383 dlg.setBallSize( ballSize );
1384 // orientation: color, scale, 3d flag
1385 dlg.setOrientationColor( orientationColor );
1386 dlg.setOrientationSize( int( orientationScale * 100. ) );
1387 dlg.setOrientation3d( orientation3d );
1388 // shrink: scale factor
1389 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1390 // hide unused controls
1391 dlg.showControls( presentEntities, hasNodes );
1394 nodeColor = dlg.nodeColor();
1395 markerType = dlg.nodeMarkerType();
1396 markerScale = dlg.nodeMarkerScale();
1397 markerId = dlg.nodeMarkerId();
1398 edgeColor = dlg.edgeColor();
1399 edgeWidth = dlg.edgeWidth();
1400 faceColor = dlg.faceColor();
1401 deltaF = dlg.faceColorDelta();
1402 volumeColor = dlg.volumeColor();
1403 deltaV = dlg.volumeColorDelta();
1404 outlineColor = dlg.outlineColor();
1405 outlineWidth = dlg.outlineWidth();
1406 elem0dColor = dlg.elem0dColor();
1407 elem0dSize = dlg.elem0dSize();
1408 ballColor = dlg.ballColor();
1409 ballSize = dlg.ballSize();
1410 orientationColor = dlg.orientationColor();
1411 orientationScale = dlg.orientationSize() / 100.;
1412 orientation3d = dlg.orientation3d();
1413 shrinkCoef = dlg.shrinkCoef() / 100.;
1415 // store point markers map that might be changed by the user
1416 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1418 // set properties from dialog box to the presentations
1419 SALOME_ListIteratorOfListIO It( selected );
1420 for ( ; It.More(); It.Next() ) {
1421 Handle(SALOME_InteractiveObject) IObject = It.Value();
1422 if ( !IObject->hasEntry() ) continue;
1423 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1424 if ( !anActor ) continue;
1426 // nodes: color, marker
1427 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1428 if ( markerType != VTK::MT_USER ) {
1429 anActor->SetMarkerStd( markerType, markerScale );
1432 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1433 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1434 if ( iter != markerMap.end() )
1435 anActor->SetMarkerTexture( markerId, iter->second.second );
1437 // volumes: normal color, reversed color (delta)
1438 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1439 // faces: front color, back color (delta)
1440 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1441 // edges: color, width
1442 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1443 anActor->SetLineWidth( edgeWidth );
1445 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1446 anActor->SetOutlineWidth( outlineWidth );
1447 // 0D elements: color, size
1448 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1449 anActor->Set0DSize( elem0dSize );
1450 // balls: color, size
1451 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1452 anActor->SetBallSize( ballSize );
1453 // orientation: color, scale, 3d flag
1454 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1455 anActor->SetFacesOrientationScale( orientationScale );
1456 anActor->SetFacesOrientation3DVectors( orientation3d );
1458 anActor->SetShrinkFactor( shrinkCoef );
1460 // for groups, set also proper color
1461 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1462 if ( !aGroupObject->_is_nil() ) {
1463 SMESH::ElementType anElementType = aGroupObject->GetType();
1465 switch( anElementType ) {
1467 aColor = nodeColor; break;
1469 aColor = edgeColor; break;
1471 aColor = faceColor; break;
1473 aColor = volumeColor; break;
1475 aColor = elem0dColor; break;
1477 aColor = ballColor; break;
1481 if ( aColor.isValid() ) {
1482 SALOMEDS::Color aGroupColor;
1483 aGroupColor.R = aColor.redF();
1484 aGroupColor.G = aColor.greenF();
1485 aGroupColor.B = aColor.blueF();
1486 aGroupObject->SetColor( aGroupColor );
1488 } // if ( !aGroupObject->_is_nil() )
1489 } // for ( ; It.More(); It.Next() )
1490 SMESH::RepaintCurrentView();
1491 } // if ( dlg.exec() )
1494 } // switch(theCommandID)
1495 SALOME_ListIteratorOfListIO It( selected );
1496 for( ; It.More(); It.Next()){
1497 Handle(SALOME_InteractiveObject) IObject = It.Value();
1498 if(IObject->hasEntry()){
1499 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1500 switch(theCommandID){
1502 anActor->SetRepresentation(SMESH_Actor::eEdge);
1505 anActor->SetRepresentation(SMESH_Actor::eSurface);
1508 if(anActor->IsShrunk())
1509 anActor->UnShrink();
1511 anActor->SetShrink();
1514 anActor->SetRepresentation(SMESH_Actor::ePoint);
1517 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1518 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1521 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1522 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1528 SMESH::RepaintCurrentView();
1532 void Control( int theCommandID )
1534 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1535 SALOME_ListIO selected;
1537 aSel->selectedObjects( selected );
1539 if( !selected.IsEmpty() ){
1540 Handle(SALOME_InteractiveObject) anIO = selected.First();
1542 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1543 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1544 switch ( theCommandID ){
1546 aControl = SMESH_Actor::eLength;
1549 aControl = SMESH_Actor::eLength2D;
1552 aControl = SMESH_Actor::eFreeEdges;
1555 aControl = SMESH_Actor::eFreeBorders;
1558 aControl = SMESH_Actor::eMultiConnection;
1561 aControl = SMESH_Actor::eFreeNodes;
1564 aControl = SMESH_Actor::eMultiConnection2D;
1567 aControl = SMESH_Actor::eArea;
1570 aControl = SMESH_Actor::eTaper;
1573 aControl = SMESH_Actor::eAspectRatio;
1576 aControl = SMESH_Actor::eAspectRatio3D;
1579 aControl = SMESH_Actor::eMinimumAngle;
1582 aControl = SMESH_Actor::eWarping;
1585 aControl = SMESH_Actor::eSkew;
1588 aControl = SMESH_Actor::eVolume3D;
1591 aControl = SMESH_Actor::eFreeFaces;
1594 aControl = SMESH_Actor::eMaxElementLength2D;
1597 aControl = SMESH_Actor::eMaxElementLength3D;
1600 aControl = SMESH_Actor::eBareBorderVolume;
1603 aControl = SMESH_Actor::eBareBorderFace;
1606 aControl = SMESH_Actor::eOverConstrainedVolume;
1609 aControl = SMESH_Actor::eOverConstrainedFace;
1612 aControl = SMESH_Actor::eCoincidentNodes;
1615 aControl = SMESH_Actor::eCoincidentElems1D;
1618 aControl = SMESH_Actor:: eCoincidentElems2D;
1621 aControl = SMESH_Actor::eCoincidentElems3D;
1625 anActor->SetControlMode(aControl);
1626 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1627 SMESH::RepaintCurrentView();
1628 #ifndef DISABLE_PLOT2DVIEWER
1629 if(anActor->GetPlot2Histogram()) {
1630 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1631 QString functorName = functorToString( anActor->GetFunctor());
1632 QString aHistogramName("%1 : %2");
1633 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1634 aHistogram->setName(aHistogramName);
1635 aHistogram->setHorTitle(functorName);
1636 SMESH::ProcessIn2DViewers(anActor);
1645 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1646 SMESH::MeshObjectType theType,
1647 const QString theInTypeName,
1648 QString & theOutTypeName)
1650 SMESH_TypeFilter aTypeFilter( theType );
1652 if( !theIO.IsNull() )
1654 entry = theIO->getEntry();
1655 LightApp_DataOwner owner( entry );
1656 if ( aTypeFilter.isOk( &owner )) {
1657 theOutTypeName = theInTypeName;
1665 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1667 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1668 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1670 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1671 CORBA::String_var anID = aSComp->GetID().c_str();
1672 if (!strcmp(anID.in(),theIO->getEntry()))
1678 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1679 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1680 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1681 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1682 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1690 QString CheckHomogeneousSelection()
1692 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1693 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1694 SALOME_ListIO selected;
1696 aSel->selectedObjects( selected );
1698 QString RefType = CheckTypeObject(selected.First());
1699 SALOME_ListIteratorOfListIO It(selected);
1700 for ( ; It.More(); It.Next())
1702 Handle(SALOME_InteractiveObject) IObject = It.Value();
1703 QString Type = CheckTypeObject(IObject);
1704 if (Type.compare(RefType) != 0)
1705 return "Heterogeneous Selection";
1712 void SMESHGUI::OnEditDelete()
1714 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1715 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1716 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1718 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1719 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1720 _PTR(GenericAttribute) anAttr;
1721 _PTR(AttributeIOR) anIOR;
1723 int objectCount = 0;
1725 QString aParentComponent = QString::null;
1726 Handle(SALOME_InteractiveObject) anIO;
1727 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1729 anIO = anIt.Value();
1730 QString cur = anIO->getComponentDataType();
1731 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1733 // check if object is reference
1734 _PTR(SObject) aRefSObj;
1735 aNameList.append("\n - ");
1736 if ( aSO->ReferencedObject( aRefSObj ) ) {
1737 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1738 aNameList.append( aRefName );
1739 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1742 aNameList.append(anIO->getName());
1746 if( aParentComponent.isNull() )
1747 aParentComponent = cur;
1748 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1749 aParentComponent = "";
1752 if ( objectCount == 0 )
1753 return; // No Valid Objects Selected
1755 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1756 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1757 QObject::tr("ERR_ERROR"),
1758 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1761 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1762 if (SUIT_MessageBox::warning
1763 (SMESHGUI::desktop(),
1764 QObject::tr("SMESH_WRN_WARNING"),
1765 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1766 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1767 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1770 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1772 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1773 // then treat them all starting from the deepest objects (at list back)
1774 std::list< _PTR(SObject) > listSO;
1775 SALOME_ListIteratorOfListIO It(selected);
1776 for( ; It.More(); It.Next()) // loop on selected IO's
1778 Handle(SALOME_InteractiveObject) IObject = It.Value();
1779 if(IObject->hasEntry()) {
1780 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1782 // disable removal of "SMESH" component object
1783 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1785 if ( engineIOR() == anIOR->Value().c_str() )
1788 //Check the referenced object
1789 _PTR(SObject) aRefSObject;
1790 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1791 aSO = aRefSObject; // Delete main Object instead of reference
1793 listSO.push_back( aSO );
1794 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1795 for ( ; itSO != listSO.end(); ++itSO ) {
1796 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1797 for (it->InitEx(false); it->More(); it->Next())
1798 listSO.push_back( it->Value() );
1802 // Check if none of objects to delete is referred from outside
1803 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1804 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1806 _PTR(SObject) SO = *ritSO;
1807 if ( !SO ) continue;
1808 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1809 for (size_t i = 0; i < aReferences.size(); i++) {
1810 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1811 std::string type = aComponent->ComponentDataType();
1812 if ( type != "SMESH" )
1814 SUIT_MessageBox::warning( anApp->desktop(),
1815 QObject::tr("WRN_WARNING"),
1816 QObject::tr("DEP_OBJECT") );
1817 return; // outside SMESH, there is an object depending on a SMESH object
1822 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1823 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1825 Handle(SALOME_InteractiveObject) IObject = It.Value();
1826 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1827 if ( !mesh->_is_nil() )
1831 // Treat SO's in the list starting from the back
1832 aStudyBuilder->NewCommand(); // There is a transaction
1833 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1835 _PTR(SObject) SO = *ritSO;
1836 if ( !SO ) continue;
1837 std::string anEntry = SO->GetID();
1839 /** Erase graphical object and remove all its data **/
1840 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1841 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1843 /** Remove an object from data structures **/
1844 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1845 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1846 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1847 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1848 aMesh->RemoveGroup( aGroup );
1850 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1851 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1852 aMesh->RemoveSubMesh( aSubMesh );
1854 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1856 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1859 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1860 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1861 QString objType = CheckTypeObject(IObject);
1862 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1863 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1864 aStudyBuilder->RemoveObjectWithChildren( SO );
1866 else {// default action: remove SObject from the study
1867 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1868 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1870 aStudyBuilder->RemoveObjectWithChildren( SO );
1874 } /* listSO back loop */
1876 aStudyBuilder->CommitCommand();
1878 /* Clear any previous selection */
1880 aSel->setSelectedObjects( l1 );
1882 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1887 SMESHGUI_EXPORT CAM_Module* createModule()
1889 return new SMESHGUI();
1892 SMESHGUI_EXPORT char* getModuleVersion() {
1893 return (char*)SMESH_VERSION_STR;
1897 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1899 //=============================================================================
1903 //=============================================================================
1904 SMESHGUI::SMESHGUI() :
1905 SalomeApp_Module( "SMESH" )
1907 if ( CORBA::is_nil( myComponentSMESH ) )
1909 CORBA::Boolean anIsEmbeddedMode;
1910 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1911 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1913 // 0019923: EDF 765 SMESH : default values of hypothesis
1914 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1915 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1916 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1917 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1918 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1920 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1921 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1922 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1924 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1925 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1929 myActiveDialogBox = 0;
1930 myFilterLibraryDlg = 0;
1934 myEventCallbackCommand = vtkCallbackCommand::New();
1935 myEventCallbackCommand->Delete();
1936 myEventCallbackCommand->SetClientData( this );
1937 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1940 /* load resources for all available meshers */
1941 SMESH::InitAvailableHypotheses();
1944 //=============================================================================
1948 //=============================================================================
1949 SMESHGUI::~SMESHGUI()
1953 //=============================================================================
1957 //=============================================================================
1958 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1960 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1962 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1967 //=============================================================================
1971 //=============================================================================
1972 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1974 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1978 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
1979 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1980 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
1981 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
1982 return autoUpdate && !exceeded;
1985 //=============================================================================
1989 //=============================================================================
1990 bool SMESHGUI::automaticUpdate( SMESH::SMESH_Mesh_ptr theMesh,
1991 int* entities, bool* limitExceeded, int* hidden )
1993 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1997 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
1998 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1999 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2001 long requestedSize = theMesh->NbElements();
2003 *entities = SMESH_Actor::eAllEntity;
2006 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2008 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2010 if ( incrementalLimit ) {
2011 long nbOdElems = theMesh->Nb0DElements();
2012 long nbEdges = theMesh->NbEdges();
2013 long nbFaces = theMesh->NbFaces();
2014 long nbVolumes = theMesh->NbVolumes();
2015 long nbBalls = theMesh->NbBalls();
2018 if ( nbOdElems > 0 ) {
2019 if ( total + nbOdElems > updateLimit ) {
2020 *entities = *entities & ~SMESH_Actor::e0DElements;
2021 *hidden = *hidden | SMESH_Actor::e0DElements;
2028 if ( nbEdges > 0 ) {
2029 if ( total + nbEdges > updateLimit ) {
2030 *entities = *entities & ~SMESH_Actor::eEdges;
2031 *hidden = *hidden | SMESH_Actor::eEdges;
2038 if ( nbFaces > 0 ) {
2039 if ( total + nbFaces > updateLimit ) {
2040 *entities = *entities & ~SMESH_Actor::eFaces;
2041 *hidden = *hidden | SMESH_Actor::eFaces;
2048 if ( nbVolumes > 0 ) {
2049 if ( total + nbVolumes > updateLimit ) {
2050 *entities = *entities & ~SMESH_Actor::eVolumes;
2051 *hidden = *hidden | SMESH_Actor::eVolumes;
2058 if ( nbBalls > 0 ) {
2059 if ( total + nbBalls > updateLimit ) {
2060 *entities = *entities & ~SMESH_Actor::eBallElem;
2061 *hidden = *hidden | SMESH_Actor::eBallElem;
2069 return autoUpdate && !exceeded;
2072 //=============================================================================
2076 //=============================================================================
2077 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2079 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2082 //=============================================================================
2086 //=============================================================================
2087 SMESHGUI* SMESHGUI::GetSMESHGUI()
2089 SMESHGUI* smeshMod = 0;
2090 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2093 CAM_Module* module = app->module( "Mesh" );
2094 smeshMod = dynamic_cast<SMESHGUI*>( module );
2097 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2099 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2102 _PTR(Study) aStudy = study->studyDS();
2104 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2113 Standard_EXPORT SMESHGUI* GetComponentGUI()
2115 return SMESHGUI::GetSMESHGUI();
2119 //=============================================================================
2123 //=============================================================================
2124 void SMESHGUI::SetState(int aState)
2129 //=============================================================================
2133 //=============================================================================
2134 void SMESHGUI::ResetState()
2139 //=============================================================================
2143 //=============================================================================
2144 void SMESHGUI::EmitSignalDeactivateDialog()
2146 emit SignalDeactivateActiveDialog();
2149 //=============================================================================
2153 //=============================================================================
2154 void SMESHGUI::EmitSignalStudyFrameChanged()
2156 emit SignalStudyFrameChanged();
2159 //=============================================================================
2163 //=============================================================================
2164 void SMESHGUI::EmitSignalCloseAllDialogs()
2166 emit SignalCloseAllDialogs();
2169 //=============================================================================
2173 //=============================================================================
2174 void SMESHGUI::EmitSignalVisibilityChanged()
2176 emit SignalVisibilityChanged();
2179 //=============================================================================
2183 //=============================================================================
2184 QDialog *SMESHGUI::GetActiveDialogBox()
2186 return myActiveDialogBox;
2189 //=============================================================================
2193 //=============================================================================
2194 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2196 myActiveDialogBox = (QDialog *) aDlg;
2200 //=============================================================================
2204 //=============================================================================
2205 SUIT_Desktop* SMESHGUI::desktop()
2207 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2209 return app->desktop();
2214 //=============================================================================
2218 //=============================================================================
2219 SalomeApp_Study* SMESHGUI::activeStudy()
2221 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2223 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2228 //=============================================================================
2232 //=============================================================================
2233 void SMESHGUI::Modified( bool theIsUpdateActions )
2235 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2236 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2237 appStudy->Modified();
2238 if( theIsUpdateActions )
2239 app->updateActions();
2244 //=============================================================================
2248 //=============================================================================
2249 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2251 /* Here the position is on the bottom right corner - 10 */
2252 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2254 SUIT_Desktop *PP = desktop();
2255 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2256 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2260 //=============================================================================
2264 //=============================================================================
2265 static int isStudyLocked(_PTR(Study) theStudy){
2266 return theStudy->GetProperties()->IsLocked();
2269 static bool checkLock(_PTR(Study) theStudy) {
2270 if (isStudyLocked(theStudy)) {
2271 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2272 QObject::tr("WRN_WARNING"),
2273 QObject::tr("WRN_STUDY_LOCKED") );
2279 //=======================================================================
2280 //function : CheckActiveStudyLocked
2282 //=======================================================================
2284 bool SMESHGUI::isActiveStudyLocked()
2286 _PTR(Study) aStudy = activeStudy()->studyDS();
2287 return checkLock( aStudy );
2290 //=============================================================================
2294 //=============================================================================
2295 bool SMESHGUI::OnGUIEvent( int theCommandID )
2297 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2301 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2302 SUIT_ResourceMgr* mgr = resourceMgr();
2306 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2307 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2310 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2311 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2313 //QAction* act = action( theCommandID );
2315 switch (theCommandID) {
2317 if(checkLock(aStudy)) break;
2329 if(checkLock(aStudy)) break;
2330 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2334 case 150: //MED FILE INFORMATION
2336 SALOME_ListIO selected;
2337 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2339 aSel->selectedObjects( selected );
2340 if( selected.Extent() )
2342 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2343 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2344 if ( !aMesh->_is_nil() )
2346 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2353 case 122: // EXPORT MED
2368 ::ExportMeshToFile(theCommandID);
2372 case 200: // SCALAR BAR
2374 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2375 SALOME_ListIO selected;
2377 aSel->selectedObjects( selected );
2379 if( selected.Extent() ) {
2380 Handle(SALOME_InteractiveObject) anIO = selected.First();
2381 if( anIO->hasEntry() ) {
2382 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2383 anActor->SetControlMode( SMESH_Actor::eNone );
2384 #ifndef DISABLE_PLOT2DVIEWER
2385 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2394 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2399 // dump control distribution data to the text file
2400 ::SaveDistribution();
2406 // show/ distribution
2407 ::ShowDistribution();
2411 #ifndef DISABLE_PLOT2DVIEWER
2414 // plot distribution
2415 ::PlotDistribution();
2426 ::DisableAutoColor();
2429 case 1134: // Clipping
2430 case 1133: // Tranparency
2431 case 1132: // Display preferences (colors, shrink size, line width, ...)
2438 ::SetDisplayMode(theCommandID, myMarkerMap);
2441 //2D quadratic representation
2444 ::SetDisplayMode(theCommandID, myMarkerMap);
2448 case 216: // 0D elements
2451 case 219: // Volumes
2452 case 220: // All Entity
2454 ::SetDisplayEntity(theCommandID);
2457 case 221: // Orientation of faces
2459 LightApp_SelectionMgr* mgr = selectionMgr();
2460 SALOME_ListIO selected; mgr->selectedObjects( selected );
2462 SALOME_ListIteratorOfListIO it(selected);
2463 for( ; it.More(); it.Next()) {
2464 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2465 if(anIObject->hasEntry()) {
2466 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2467 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2476 if(checkLock(aStudy)) break;
2477 SUIT_OverrideCursor wc;
2479 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2482 SMESH::UpdateView();
2484 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2485 SMESH::OnVisuException();
2487 catch (...) { // PAL16774 (Crash after display of many groups)
2488 SMESH::OnVisuException();
2492 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2493 aSel->selectedObjects( l );
2494 aSel->setSelectedObjects( l );
2499 case 301: // DISPLAY
2500 case 302: // DISPLAY ONLY
2502 SMESH::EDisplaing anAction;
2503 switch (theCommandID) {
2504 case 300: anAction = SMESH::eErase; break;
2505 case 301: anAction = SMESH::eDisplay; break;
2506 case 302: anAction = SMESH::eDisplayOnly; break;
2509 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2510 SALOME_ListIO sel_objects, to_process;
2512 aSel->selectedObjects( sel_objects );
2514 if( theCommandID==302 )
2516 MESSAGE("anAction = SMESH::eDisplayOnly");
2517 startOperation( myEraseAll );
2520 extractContainers( sel_objects, to_process );
2523 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2527 SALOME_ListIteratorOfListIO It( to_process );
2528 for ( ; It.More(); It.Next()) {
2530 Handle(SALOME_InteractiveObject) IOS = It.Value();
2531 if (IOS->hasEntry()) {
2533 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2534 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2535 break; // PAL16774 (Crash after display of many groups)
2537 if (anAction == SMESH::eDisplayOnly)
2539 MESSAGE("anAction = SMESH::eDisplayOnly");
2540 anAction = SMESH::eDisplay;
2546 // PAL13338 + PAL15161 -->
2547 if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2548 MESSAGE("anAction = SMESH::eDisplayOnly");
2549 SMESH::UpdateView();
2550 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2552 // PAL13338 + PAL15161 <--
2554 catch (...) { // PAL16774 (Crash after display of many groups)
2555 SMESH::OnVisuException();
2558 if (anAction == SMESH::eErase) {
2559 MESSAGE("anAction == SMESH::eErase");
2561 aSel->setSelectedObjects( l1 );
2564 aSel->setSelectedObjects( to_process );
2571 if(checkLock(aStudy)) break;
2574 EmitSignalDeactivateDialog();
2576 ( new SMESHGUI_NodesDlg( this ) )->show();
2579 SUIT_MessageBox::warning(desktop(),
2580 tr("SMESH_WRN_WARNING"),
2581 tr("SMESH_WRN_VIEWER_VTK"));
2586 case 2151: // FILTER
2590 EmitSignalDeactivateDialog();
2591 ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2596 case 701: // COMPUTE MESH
2597 case 711: // PRECOMPUTE MESH
2598 case 712: // EVALUATE MESH
2599 case 713: // MESH ORDER
2600 case 702: // Create mesh
2601 case 703: // Create sub-mesh
2602 case 704: // Edit mesh/sub-mesh
2603 startOperation( theCommandID );
2605 case 705: // copy mesh
2607 if (checkLock(aStudy)) break;
2608 EmitSignalDeactivateDialog();
2609 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2612 case 710: // Build compound mesh
2614 if (checkLock(aStudy)) break;
2615 EmitSignalDeactivateDialog();
2616 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2620 case 407: // DIAGONAL INVERSION
2621 case 408: // Delete diagonal
2625 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2626 tr( "NOT_A_VTK_VIEWER" ) );
2630 if ( checkLock( aStudy ) )
2633 /*Standard_Boolean aRes;
2634 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2635 if ( aMesh->_is_nil() )
2637 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2638 tr( "SMESH_BAD_SELECTION" ) );
2642 EmitSignalDeactivateDialog();
2643 if ( theCommandID == 407 )
2644 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2646 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2649 case 409: // Change orientation
2650 case 410: // Union of triangles
2651 case 411: // Cutting of quadrangles
2652 case 419: // Splitting volumes into tetrahedra
2656 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2657 tr( "NOT_A_VTK_VIEWER" ) );
2661 if ( checkLock( aStudy ) )
2664 EmitSignalDeactivateDialog();
2665 SMESHGUI_MultiEditDlg* aDlg = NULL;
2666 if ( theCommandID == 409 )
2667 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2668 else if ( theCommandID == 410 )
2669 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2670 else if ( theCommandID == 419 )
2671 aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2673 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2678 case 412: // Smoothing
2680 if(checkLock(aStudy)) break;
2682 EmitSignalDeactivateDialog();
2683 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2686 SUIT_MessageBox::warning(desktop(),
2687 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2691 case 413: // Extrusion
2693 if (checkLock(aStudy)) break;
2695 EmitSignalDeactivateDialog();
2696 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2698 SUIT_MessageBox::warning(desktop(),
2699 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2703 case 414: // Revolution
2705 if(checkLock(aStudy)) break;
2707 EmitSignalDeactivateDialog();
2708 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2711 SUIT_MessageBox::warning(desktop(),
2712 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2716 case 415: // Pattern mapping
2718 if ( checkLock( aStudy ) )
2722 EmitSignalDeactivateDialog();
2723 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2726 SUIT_MessageBox::warning(desktop(),
2727 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2731 case 416: // Extrusion along a path
2733 if (checkLock(aStudy)) break;
2735 EmitSignalDeactivateDialog();
2736 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2738 SUIT_MessageBox::warning(desktop(),
2739 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2743 case 417: // Convert mesh to quadratic
2744 case 418: // create 2D mesh from 3D
2745 case 420: // Reorient faces
2746 case 806: // CREATE GEO GROUP
2748 startOperation( theCommandID );
2751 case 801: // CREATE GROUP
2755 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2756 tr( "NOT_A_VTK_VIEWER" ) );
2760 if(checkLock(aStudy)) break;
2761 EmitSignalDeactivateDialog();
2762 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2764 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2765 SALOME_ListIO selected;
2767 aSel->selectedObjects( selected );
2769 int nbSel = selected.Extent();
2771 // check if mesh is selected
2772 aMesh = SMESH::GetMeshByIO( selected.First() );
2774 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2779 case 802: // CONSTRUCT GROUP
2783 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2784 tr( "NOT_A_VTK_VIEWER" ) );
2788 if(checkLock(aStudy)) break;
2789 EmitSignalDeactivateDialog();
2791 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2792 SALOME_ListIO selected;
2794 aSel->selectedObjects( selected );
2796 int nbSel = selected.Extent();
2798 // check if submesh is selected
2799 Handle(SALOME_InteractiveObject) IObject = selected.First();
2800 if (IObject->hasEntry()) {
2801 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2803 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2804 if (!aSubMesh->_is_nil()) {
2806 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2807 // get submesh elements list by types
2808 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2809 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2810 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2811 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2812 // create group for each type o elements
2813 QString aName = IObject->getName();
2814 QStringList anEntryList;
2815 if (aNodes->length() > 0) {
2816 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2817 aGroup->Add(aNodes.inout());
2818 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2819 anEntryList.append( aSObject->GetID().c_str() );
2821 if (aEdges->length() > 0) {
2822 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2823 aGroup->Add(aEdges.inout());
2824 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2825 anEntryList.append( aSObject->GetID().c_str() );
2827 if (aFaces->length() > 0) {
2828 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2829 aGroup->Add(aFaces.inout());
2830 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2831 anEntryList.append( aSObject->GetID().c_str() );
2833 if (aVolumes->length() > 0) {
2834 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2835 aGroup->Add(aVolumes.inout());
2836 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2837 anEntryList.append( aSObject->GetID().c_str() );
2840 anApp->browseObjects( anEntryList );
2842 catch(const SALOME::SALOME_Exception & S_ex){
2843 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2850 SUIT_MessageBox::warning(desktop(),
2851 tr("SMESH_WRN_WARNING"),
2852 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2857 case 803: // EDIT GROUP
2861 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2862 tr( "NOT_A_VTK_VIEWER" ) );
2866 if(checkLock(aStudy)) break;
2867 EmitSignalDeactivateDialog();
2869 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2870 SALOME_ListIO selected;
2872 aSel->selectedObjects( selected );
2874 SALOME_ListIteratorOfListIO It (selected);
2875 int nbSelectedGroups = 0;
2876 for ( ; It.More(); It.Next() )
2878 SMESH::SMESH_GroupBase_var aGroup =
2879 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2880 if (!aGroup->_is_nil()) {
2882 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2886 if (nbSelectedGroups == 0)
2888 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2894 case 804: // Add elements to group
2896 if(checkLock(aStudy)) break;
2897 if (myState == 800) {
2898 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2899 if (aDlg) aDlg->onAdd();
2904 case 805: // Remove elements from group
2906 if(checkLock(aStudy)) break;
2907 if (myState == 800) {
2908 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2909 if (aDlg) aDlg->onRemove();
2914 case 815: // Edit GEOM GROUP as standalone
2918 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2919 tr( "NOT_A_VTK_VIEWER" ) );
2923 if(checkLock(aStudy)) break;
2924 EmitSignalDeactivateDialog();
2926 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2927 SALOME_ListIO selected;
2929 aSel->selectedObjects( selected );
2931 SALOME_ListIteratorOfListIO It (selected);
2932 for ( ; It.More(); It.Next() )
2934 SMESH::SMESH_GroupOnGeom_var aGroup =
2935 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2936 if (!aGroup->_is_nil()) {
2937 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2942 SMESH::SMESH_GroupOnFilter_var aGroup =
2943 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2944 if (!aGroup->_is_nil()) {
2945 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2953 case 810: // Union Groups
2954 case 811: // Intersect groups
2955 case 812: // Cut groups
2959 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2960 tr( "NOT_A_VTK_VIEWER" ) );
2964 if ( checkLock( aStudy ) )
2967 EmitSignalDeactivateDialog();
2969 SMESHGUI_GroupOpDlg* aDlg = 0;
2970 if ( theCommandID == 810 )
2971 aDlg = new SMESHGUI_UnionGroupsDlg( this );
2972 else if ( theCommandID == 811 )
2973 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2975 aDlg = new SMESHGUI_CutGroupsDlg( this );
2982 case 814: // Create groups of entities from existing groups of superior dimensions
2984 if ( checkLock( aStudy ) )
2987 EmitSignalDeactivateDialog();
2988 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2994 case 813: // Delete groups with their contents
2998 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2999 tr( "NOT_A_VTK_VIEWER" ) );
3003 if ( checkLock( aStudy ) )
3006 EmitSignalDeactivateDialog();
3008 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3012 case 900: // MESH INFOS
3013 case 903: // WHAT IS
3015 int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3016 EmitSignalDeactivateDialog();
3017 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3018 SALOME_ListIO selected;
3020 aSel->selectedObjects( selected );
3022 if ( selected.Extent() > 1 ) { // a dlg for each IO
3023 SALOME_ListIteratorOfListIO It( selected );
3024 for ( ; It.More(); It.Next() ) {
3025 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3026 dlg->showInfo( It.Value() );
3031 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3037 case 904: // FIND ELEM
3039 startOperation( theCommandID );
3043 case 1100: // EDIT HYPOTHESIS
3045 if(checkLock(aStudy)) break;
3047 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3048 SALOME_ListIO selected;
3050 aSel->selectedObjects( selected );
3052 int nbSel = selected.Extent();
3055 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3056 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3058 /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
3059 /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects */
3060 /* Warning : however by internal mechanism all subMeshes icons are changed ! */
3061 if ( !aHypothesis->_is_nil() )
3064 //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
3065 SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
3067 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3077 case 1102: // REMOVE HYPOTHESIS / ALGORITHMS
3079 if(checkLock(aStudy)) break;
3080 SUIT_OverrideCursor wc;
3082 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3083 SALOME_ListIO selected;
3085 aSel->selectedObjects( selected, QString::null, false );
3087 SALOME_ListIteratorOfListIO It(selected);
3088 for (int i = 0; It.More(); It.Next(), i++) {
3089 Handle(SALOME_InteractiveObject) IObject = It.Value();
3090 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3093 aSel->setSelectedObjects( l1 );
3099 case 4009: // ELEM0D
3101 case 4021: // TRIANGLE
3103 case 4023: // POLYGON
3107 case 4134: // PYRAMID
3108 case 4135: // OCTA12
3110 if(checkLock(aStudy)) break;
3112 EmitSignalDeactivateDialog();
3113 SMDSAbs_EntityType type = SMDSEntity_Edge;
3114 switch (theCommandID) {
3115 case 4008: type = SMDSEntity_Ball; break;
3116 case 4009: type = SMDSEntity_0D; break;
3117 case 4021: type = SMDSEntity_Triangle; break;
3118 case 4022: type = SMDSEntity_Quadrangle; break;
3119 case 4031: type = SMDSEntity_Tetra; break;
3120 case 4023: type = SMDSEntity_Polygon; break;
3121 case 4032: type = SMDSEntity_Hexa; break;
3122 case 4133: type = SMDSEntity_Penta; break;
3123 case 4134: type = SMDSEntity_Pyramid; break;
3124 case 4135: type = SMDSEntity_Hexagonal_Prism; break;
3127 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3130 SUIT_MessageBox::warning(desktop(),
3131 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3135 case 4033: // POLYHEDRON
3137 if(checkLock(aStudy)) break;
3139 EmitSignalDeactivateDialog();
3140 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3143 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3144 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3148 case 4034: // QUADRATIC EDGE
3149 case 4035: // QUADRATIC TRIANGLE
3150 case 4036: // QUADRATIC QUADRANGLE
3151 case 4136: // BIQUADRATIC QUADRANGLE
3152 case 4137: // BIQUADRATIC TRIANGLE
3153 case 4037: // QUADRATIC TETRAHEDRON
3154 case 4038: // QUADRATIC PYRAMID
3155 case 4039: // QUADRATIC PENTAHEDRON
3156 case 4040: // QUADRATIC HEXAHEDRON
3157 case 4140: // TRIQUADRATIC HEXAHEDRON
3159 if(checkLock(aStudy)) break;
3161 EmitSignalDeactivateDialog();
3162 SMDSAbs_EntityType type = SMDSEntity_Last;
3164 switch (theCommandID) {
3165 case 4034: type = SMDSEntity_Quad_Edge; break;
3166 case 4035: type = SMDSEntity_Quad_Triangle; break;
3167 case 4036: type = SMDSEntity_Quad_Quadrangle; break;
3168 case 4136: type = SMDSEntity_BiQuad_Quadrangle; break;
3169 case 4137: type = SMDSEntity_BiQuad_Triangle; break;
3170 case 4037: type = SMDSEntity_Quad_Tetra; break;
3171 case 4038: type = SMDSEntity_Quad_Pyramid; break;
3172 case 4039: type = SMDSEntity_Quad_Penta; break;
3173 case 4040: type = SMDSEntity_Quad_Hexa; break;
3174 case 4140: type = SMDSEntity_TriQuad_Hexa; break;
3177 if ( type != SMDSEntity_Last )
3178 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3181 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3182 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3186 case 4041: // REMOVES NODES
3188 if(checkLock(aStudy)) break;
3190 EmitSignalDeactivateDialog();
3191 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3194 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3195 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3199 case 4042: // REMOVES ELEMENTS
3201 if(checkLock(aStudy)) break;
3203 EmitSignalDeactivateDialog();
3204 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3208 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3209 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3213 case 4043: { // CLEAR_MESH
3215 if(checkLock(aStudy)) break;
3217 SALOME_ListIO selected;
3218 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3219 aSel->selectedObjects( selected );
3221 SUIT_OverrideCursor wc;
3222 SALOME_ListIteratorOfListIO It (selected);
3223 for ( ; It.More(); It.Next() )
3225 Handle(SALOME_InteractiveObject) IOS = It.Value();
3226 SMESH::SMESH_Mesh_var aMesh =
3227 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3228 if ( aMesh->_is_nil()) continue;
3230 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3232 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3233 SMESH::ModifiedMesh( aMeshSObj, false, true);
3234 // hide groups and submeshes
3235 _PTR(ChildIterator) anIter =
3236 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3237 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3239 _PTR(SObject) so = anIter->Value();
3240 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3243 catch (const SALOME::SALOME_Exception& S_ex){
3245 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3249 SMESH::UpdateView();
3253 case 4044: // REMOVE ORPHAN NODES
3255 if(checkLock(aStudy)) break;
3256 SALOME_ListIO selected;
3257 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3258 aSel->selectedObjects( selected );
3259 if ( selected.Extent() == 1 ) {
3260 Handle(SALOME_InteractiveObject) anIO = selected.First();
3261 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3262 if ( !aMesh->_is_nil() ) {
3263 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3264 tr( "SMESH_WARNING" ),
3265 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3266 SUIT_MessageBox::Yes |
3267 SUIT_MessageBox::No,
3268 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3271 SUIT_OverrideCursor wc;
3272 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3273 int removed = aMeshEditor->RemoveOrphanNodes();
3274 SUIT_MessageBox::information(SMESHGUI::desktop(),
3275 tr("SMESH_INFORMATION"),
3276 tr("NB_NODES_REMOVED").arg(removed));
3277 if ( removed > 0 ) {
3278 SMESH::UpdateView();
3279 SMESHGUI::Modified();
3282 catch (const SALOME::SALOME_Exception& S_ex) {
3283 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3292 case 4051: // RENUMBERING NODES
3294 if(checkLock(aStudy)) break;
3296 EmitSignalDeactivateDialog();
3297 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3301 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3302 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3306 case 4052: // RENUMBERING ELEMENTS
3308 if(checkLock(aStudy)) break;
3310 EmitSignalDeactivateDialog();
3311 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3315 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3316 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3320 case 4061: // TRANSLATION
3322 if(checkLock(aStudy)) break;
3324 EmitSignalDeactivateDialog();
3325 ( new SMESHGUI_TranslationDlg( this ) )->show();
3328 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3329 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3333 case 4062: // ROTATION
3335 if(checkLock(aStudy)) break;
3337 EmitSignalDeactivateDialog();
3338 ( new SMESHGUI_RotationDlg( this ) )->show();
3341 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3342 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3346 case 4063: // SYMMETRY
3348 if(checkLock(aStudy)) break;
3350 EmitSignalDeactivateDialog();
3351 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3354 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3355 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3359 case 4064: // SEWING
3361 if(checkLock(aStudy)) break;
3363 EmitSignalDeactivateDialog();
3364 ( new SMESHGUI_SewingDlg( this ) )->show();
3367 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3368 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3372 case 4065: // MERGE NODES
3374 if(checkLock(aStudy)) break;
3376 EmitSignalDeactivateDialog();
3377 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3380 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3381 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3385 case 4066: // MERGE EQUAL ELEMENTS
3387 if (checkLock(aStudy)) break;
3389 EmitSignalDeactivateDialog();
3390 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3392 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3393 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3398 case 4067: // MAKE MESH PASS THROUGH POINT
3399 startOperation( 4067 );
3404 if(checkLock(aStudy)) break;
3406 EmitSignalDeactivateDialog();
3407 ( new SMESHGUI_ScaleDlg( this ) )->show();
3410 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3411 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3416 case 4069: // DUPLICATE NODES
3418 if(checkLock(aStudy)) break;
3420 EmitSignalDeactivateDialog();
3421 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3424 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3425 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3430 case 4070: // 0D_ON_ALL_NODES
3431 startOperation( 4070 );
3434 case 5105: // Library of selection filters
3436 static QList<int> aTypes;
3437 if ( aTypes.isEmpty() )
3439 aTypes.append( SMESH::NODE );
3440 aTypes.append( SMESH::EDGE );
3441 aTypes.append( SMESH::FACE );
3442 aTypes.append( SMESH::VOLUME );
3444 if (!myFilterLibraryDlg)
3445 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3446 else if (myFilterLibraryDlg->isHidden())
3447 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3448 myFilterLibraryDlg->raise();
3452 case 6017: // CONTROLS
3480 LightApp_SelectionMgr* mgr = selectionMgr();
3481 SALOME_ListIO selected; mgr->selectedObjects( selected );
3483 if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3484 _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3486 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3487 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
3488 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3489 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
3490 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3491 SUIT_OverrideCursor wc;
3492 ::Control( theCommandID );
3497 SUIT_MessageBox::warning(desktop(),
3498 tr( "SMESH_WRN_WARNING" ),
3499 tr( "SMESH_BAD_SELECTION" ) );
3503 SUIT_MessageBox::warning(desktop(),
3504 tr( "SMESH_WRN_WARNING" ),
3505 tr( "NOT_A_VTK_VIEWER" ) );
3509 OverallMeshQuality();
3513 SUIT_OverrideCursor wc;
3514 LightApp_SelectionMgr* mgr = selectionMgr();
3515 SALOME_ListIO selected; mgr->selectedObjects( selected );
3517 SALOME_ListIteratorOfListIO it(selected);
3518 for( ; it.More(); it.Next()) {
3519 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3520 if(anIObject->hasEntry()) {
3521 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3522 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3530 SUIT_OverrideCursor wc;
3531 LightApp_SelectionMgr* mgr = selectionMgr();
3532 SALOME_ListIO selected; mgr->selectedObjects( selected );
3534 SALOME_ListIteratorOfListIO it(selected);
3535 for( ; it.More(); it.Next()) {
3536 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3537 if(anIObject->hasEntry())
3538 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3539 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3550 int page = SMESHGUI_MeasureDlg::MinDistance;
3551 if ( theCommandID == 502 )
3552 page = SMESHGUI_MeasureDlg::BoundingBox;
3553 else if ( theCommandID == 503 )
3554 page = SMESHGUI_MeasureDlg::Length;
3555 else if ( theCommandID == 504 )
3556 page = SMESHGUI_MeasureDlg::Area;
3557 else if ( theCommandID == 505 )
3558 page = SMESHGUI_MeasureDlg::Volume;
3560 EmitSignalDeactivateDialog();
3561 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3571 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3572 //updateObjBrowser();
3576 //=============================================================================
3580 //=============================================================================
3581 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3586 //=============================================================================
3590 //=============================================================================
3591 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3596 //=============================================================================
3600 //=============================================================================
3601 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3606 //=============================================================================
3607 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3608 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3610 //=============================================================================
3611 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3612 SUIT_ViewWindow* wnd )
3614 if(theIO->hasEntry()){
3615 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3616 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3620 //=======================================================================
3621 // function : createSMESHAction
3623 //=======================================================================
3624 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3625 const int key, const bool toggle, const QString& shortcutAction )
3628 QWidget* parent = application()->desktop();
3629 SUIT_ResourceMgr* resMgr = resourceMgr();
3631 if ( !icon_id.isEmpty() )
3632 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3634 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3635 if ( !pix.isNull() )
3636 icon = QIcon( pix );
3638 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3639 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3640 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3642 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3643 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3646 //=======================================================================
3647 // function : createPopupItem
3649 //=======================================================================
3650 void SMESHGUI::createPopupItem( const int id,
3651 const QString& clients,
3652 const QString& types,
3653 const QString& theRule,
3656 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3657 popupMgr()->insert( action( id ), pId, 0 );
3659 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3660 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3661 QString rule = "(%1) and (%2) and (%3)";
3662 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3663 if( clients.isEmpty() )
3664 rule = rule.arg( QString( "true" ) );
3666 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3667 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3670 bool cont = myRules.contains( id );
3672 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3674 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3675 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3678 //=======================================================================
3679 // function : initialize
3681 //=======================================================================
3682 void SMESHGUI::initialize( CAM_Application* app )
3684 SalomeApp_Module::initialize( app );
3686 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3688 /* Automatic Update flag */
3689 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3691 // ----- create actions --------------
3693 //createSMESHAction( 111, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3694 createSMESHAction( 112, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3695 createSMESHAction( 113, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3696 createSMESHAction( 114, "NUM" );
3697 createSMESHAction( 115, "IMPORT_STL" );
3698 createSMESHAction( 116, "IMPORT_CGNS" );
3699 createSMESHAction( 117, "IMPORT_SAUV" );
3700 createSMESHAction( 118, "IMPORT_GMF" );
3701 createSMESHAction( 121, "DAT" );
3702 createSMESHAction( 122, "MED" );
3703 createSMESHAction( 123, "UNV" );
3704 createSMESHAction( 140, "STL" );
3705 createSMESHAction( 142, "CGNS");
3706 createSMESHAction( 144, "SAUV");
3707 createSMESHAction( 146, "GMF" );
3708 createSMESHAction( 124, "DAT" );
3709 createSMESHAction( 125, "MED" );
3710 createSMESHAction( 126, "UNV" );
3711 createSMESHAction( 141, "STL" );
3712 createSMESHAction( 143, "CGNS");
3713 createSMESHAction( 145, "SAUV");
3714 createSMESHAction( 147, "GMF" );
3715 createSMESHAction( 150, "FILE_INFO" );
3716 createSMESHAction( 33, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3717 createSMESHAction( 5105, "SEL_FILTER_LIB" );
3718 createSMESHAction( 701, "COMPUTE", "ICON_COMPUTE" );
3719 createSMESHAction( 702, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3720 createSMESHAction( 703, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3721 createSMESHAction( 704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3722 createSMESHAction( 705, "COPY_MESH", "ICON_COPY_MESH" );
3723 createSMESHAction( 710, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3724 createSMESHAction( 711, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3725 createSMESHAction( 712, "EVALUATE", "ICON_COMPUTE" );
3726 createSMESHAction( 713, "MESH_ORDER", "ICON_COMPUTE" );
3727 createSMESHAction( 806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3728 createSMESHAction( 801, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3729 createSMESHAction( 802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3730 createSMESHAction( 803, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3731 createSMESHAction( 815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3732 createSMESHAction( 804, "ADD" );
3733 createSMESHAction( 805, "REMOVE" );
3734 createSMESHAction( 810, "UN_GROUP", "ICON_UNION" );
3735 createSMESHAction( 811, "INT_GROUP", "ICON_INTERSECT" );
3736 createSMESHAction( 812, "CUT_GROUP", "ICON_CUT" );
3737 createSMESHAction( 814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3738 createSMESHAction( 813, "DEL_GROUP", "ICON_DEL_GROUP" );
3739 createSMESHAction( 900, "ADV_INFO", "ICON_ADV_INFO" );
3740 //createSMESHAction( 902, "STD_INFO", "ICON_STD_INFO" );
3741 //createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3742 createSMESHAction( 904, "FIND_ELEM", "ICON_FIND_ELEM" );
3743 createSMESHAction( 6001, "LENGTH", "ICON_LENGTH", 0, true );
3744 createSMESHAction( 6002, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3745 createSMESHAction( 6021, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3746 createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3747 createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3748 createSMESHAction( 6024, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3749 createSMESHAction( 6025, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3750 createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3751 createSMESHAction( 6027, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3752 createSMESHAction( 6028, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3753 createSMESHAction( 6029, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3754 createSMESHAction( 6030, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3755 createSMESHAction( 6031, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3756 createSMESHAction( 6032, "OVERALL_MESH_QUALITY" );
3757 createSMESHAction( 6003, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3758 createSMESHAction( 6004, "CONNECTION", "ICON_CONNECTION", 0, true );
3759 createSMESHAction( 6005, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3760 createSMESHAction( 6011, "AREA", "ICON_AREA", 0, true );
3761 createSMESHAction( 6012, "TAPER", "ICON_TAPER", 0, true );
3762 createSMESHAction( 6013, "ASPECT", "ICON_ASPECT", 0, true );
3763 createSMESHAction( 6014, "MIN_ANG", "ICON_ANGLE", 0, true );
3764 createSMESHAction( 6015, "WARP", "ICON_WARP", 0, true );
3765 createSMESHAction( 6016, "SKEW", "ICON_SKEW", 0, true );
3766 createSMESHAction( 6017, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3767 createSMESHAction( 6018, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3768 createSMESHAction( 6019, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3769 createSMESHAction( 6009, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3770 createSMESHAction( 4000, "NODE", "ICON_DLG_NODE" );
3771 createSMESHAction( 4009, "ELEM0D", "ICON_DLG_ELEM0D" );
3772 createSMESHAction( 4008, "BALL", "ICON_DLG_BALL" );
3773 createSMESHAction( 4010, "EDGE", "ICON_DLG_EDGE" );
3774 createSMESHAction( 4021, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3775 createSMESHAction( 4022, "QUAD", "ICON_DLG_QUADRANGLE" );
3776 createSMESHAction( 4023, "POLYGON", "ICON_DLG_POLYGON" );
3777 createSMESHAction( 4031, "TETRA", "ICON_DLG_TETRAS" );
3778 createSMESHAction( 4032, "HEXA", "ICON_DLG_HEXAS" );
3779 createSMESHAction( 4133, "PENTA", "ICON_DLG_PENTA" );
3780 createSMESHAction( 4134, "PYRAMID", "ICON_DLG_PYRAMID" );
3781 createSMESHAction( 4135, "OCTA", "ICON_DLG_OCTA" );
3782 createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3783 createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3784 createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3785 createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3786 createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3787 createSMESHAction( 4137, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3788 createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3789 createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3790 createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3791 createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3792 createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3793 createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3794 createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3795 createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3796 createSMESHAction( 4043, "CLEAR_MESH" , "ICON_CLEAR_MESH" );
3797 createSMESHAction( 4051, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3798 createSMESHAction( 4052, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3799 createSMESHAction( 4061, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3800 createSMESHAction( 4062, "ROT", "ICON_DLG_MESH_ROTATION" );
3801 createSMESHAction( 4063, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3802 createSMESHAction( 4064, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3803 createSMESHAction( 4065, "MERGE", "ICON_SMESH_MERGE_NODES" );
3804 createSMESHAction( 4066, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3805 createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3806 createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" );
3807 createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3808 createSMESHAction( 4070, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3809 createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" );
3810 createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" );
3811 createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3812 createSMESHAction( 410, "UNION", "ICON_UNIONTRI" );
3813 createSMESHAction( 411, "CUT", "ICON_CUTQUAD" );
3814 createSMESHAction( 412, "SMOOTH", "ICON_DLG_SMOOTHING" );
3815 createSMESHAction( 413, "EXTRUSION", "ICON_EXTRUSION" );
3816 createSMESHAction( 414, "REVOLUTION", "ICON_REVOLUTION" );
3817 createSMESHAction( 415, "MAP", "ICON_MAP" );
3818 createSMESHAction( 416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3819 createSMESHAction( 417, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3820 createSMESHAction( 418, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3821 createSMESHAction( 419, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3822 createSMESHAction( 420, "REORIENT_2D", "ICON_REORIENT_2D" );
3823 createSMESHAction( 200, "RESET" );
3824 createSMESHAction( 201, "SCALAR_BAR_PROP" );
3825 createSMESHAction( 2021, "SAVE_DISTRIBUTION" );
3826 createSMESHAction( 2022, "SHOW_DISTRIBUTION","",0, true );
3827 #ifndef DISABLE_PLOT2DVIEWER
3828 createSMESHAction( 2023, "PLOT_DISTRIBUTION" );
3830 createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true );
3831 createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true );
3832 createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true );
3833 createSMESHAction( 214, "UPDATE", "ICON_UPDATE" );
3834 createSMESHAction( 215, "NODES", "ICON_POINTS", 0, true );
3835 createSMESHAction( 222, "BALLS", "ICON_DLG_BALL", 0, true );
3836 createSMESHAction( 216, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3837 createSMESHAction( 217, "EDGES", "ICON_DLG_EDGE", 0, true );
3838 createSMESHAction( 218, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3839 createSMESHAction( 219, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3840 createSMESHAction( 220, "ALL" );
3841 createSMESHAction( 221, "FACE_ORIENTATION", "", 0, true );
3843 createSMESHAction( 231, "LINE_REPRESENTATION", "", 0, true );
3844 createSMESHAction( 232, "ARC_REPRESENTATION", "", 0, true );
3846 createSMESHAction( 1100, "EDIT_HYPO" );
3847 createSMESHAction( 1102, "UNASSIGN" );
3848 createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3849 createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3850 createSMESHAction( 1131, "DISPMODE" );
3851 createSMESHAction( 1132, "COLORS" );
3852 createSMESHAction( 1133, "TRANSP" );
3853 createSMESHAction( 1134, "CLIP" );
3854 createSMESHAction( 1135, "DISP_ENT" );
3855 createSMESHAction( 1136, "AUTO_COLOR" );
3856 createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3857 createSMESHAction( 2000, "CTRL" );
3859 createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3860 createSMESHAction( 502, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3861 createSMESHAction( 503, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3862 createSMESHAction( 504, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3863 createSMESHAction( 505, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
3865 createSMESHAction( 300, "HIDE" );
3866 createSMESHAction( 301, "SHOW" );
3867 createSMESHAction( 302, "DISPLAY_ONLY" );
3869 createSMESHAction( 41, "SORT_CHILD_ITEMS" );
3871 // ----- create menu --------------
3872 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3873 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3874 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3875 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3876 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3877 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3878 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3879 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3881 createMenu( separator(), fileId );
3883 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3884 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3885 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3886 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3887 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3888 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3889 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3890 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3891 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3892 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
3893 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
3895 //createMenu( 111, importId, -1 );
3896 createMenu( 112, importId, -1 );
3897 createMenu( 113, importId, -1 );
3898 createMenu( 115, importId, -1 );
3900 createMenu( 116, importId, -1 );
3902 createMenu( 117, importId, -1 );
3903 createMenu( 118, importId, -1 );
3904 createMenu( 121, exportId, -1 );
3905 createMenu( 122, exportId, -1 );
3906 createMenu( 123, exportId, -1 );
3907 createMenu( 140, exportId, -1 ); // export to STL
3909 createMenu( 142, exportId, -1 ); // export to CGNS
3911 createMenu( 144, exportId, -1 ); // export to SAUV
3912 createMenu( 146, exportId, -1 ); // export to GMF
3913 createMenu( separator(), fileId, 10 );
3915 createMenu( 33, editId, -1 );
3917 createMenu( 5105, toolsId, -1 );
3919 createMenu( 702, meshId, -1 ); // "Mesh" menu
3920 createMenu( 703, meshId, -1 );
3921 createMenu( 704, meshId, -1 );
3922 createMenu( 710, meshId, -1 );
3923 createMenu( 705, meshId, -1 );
3924 createMenu( separator(), meshId, -1 );
3925 createMenu( 701, meshId, -1 );
3926 createMenu( 711, meshId, -1 );
3927 createMenu( 712, meshId, -1 );
3928 createMenu( 713, meshId, -1 );
3929 createMenu( separator(), meshId, -1 );
3930 createMenu( 801, meshId, -1 );
3931 createMenu( 806, meshId, -1 );
3932 createMenu( 802, meshId, -1 );
3933 createMenu( 803, meshId, -1 );
3934 createMenu( 815, meshId, -1 );
3935 createMenu( separator(), meshId, -1 );
3936 createMenu( 810, meshId, -1 );
3937 createMenu( 811, meshId, -1 );
3938 createMenu( 812, meshId, -1 );
3939 createMenu( separator(), meshId, -1 );
3940 createMenu( 814, meshId, -1 );
3941 createMenu( separator(), meshId, -1 );
3942 createMenu( 900, meshId, -1 );
3943 //createMenu( 902, meshId, -1 );
3944 //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3945 createMenu( 904, meshId, -1 );
3946 createMenu( separator(), meshId, -1 );
3948 createMenu( 6005, nodeId, -1 );
3949 createMenu( 6028, nodeId, -1 );
3950 createMenu( 6002, edgeId, -1 );
3951 createMenu( 6003, edgeId, -1 );
3952 createMenu( 6001, edgeId, -1 );
3953 createMenu( 6004, edgeId, -1 );
3954 createMenu( 6029, edgeId, -1 );
3955 createMenu( 6021, faceId, -1 );
3956 createMenu( 6025, faceId, -1 );
3957 createMenu( 6027, faceId, -1 );
3958 createMenu( 6018, faceId, -1 );
3959 createMenu( 6019, faceId, -1 );
3960 createMenu( 6011, faceId, -1 );
3961 createMenu( 6012, faceId, -1 );
3962 createMenu( 6013, faceId, -1 );
3963 createMenu( 6014, faceId, -1 );
3964 createMenu( 6015, faceId, -1 );
3965 createMenu( 6016, faceId, -1 );
3966 createMenu( 6022, faceId, -1 );
3967 createMenu( 6030, faceId, -1 );
3968 createMenu( 6017, volumeId, -1 );
3969 createMenu( 6009, volumeId, -1 );
3970 createMenu( 6023, volumeId, -1 );
3971 createMenu( 6024, volumeId, -1 );
3972 createMenu( 6026, volumeId, -1 );
3973 createMenu( 6031, volumeId, -1 );
3974 createMenu( separator(), ctrlId, -1 );
3975 createMenu( 6032, ctrlId, -1 );
3977 createMenu( 4000, addId, -1 );
3978 createMenu( 4009, addId, -1 );
3979 createMenu( 4070, addId, -1 );
3980 createMenu( 4008, addId, -1 );
3981 createMenu( 4010, addId, -1 );
3982 createMenu( 4021, addId, -1 );
3983 createMenu( 4022, addId, -1 );
3984 createMenu( 4023, addId, -1 );
3985 createMenu( 4031, addId, -1 );
3986 createMenu( 4032, addId, -1 );
3987 createMenu( 4133, addId, -1 );
3988 createMenu( 4134, addId, -1 );
3989 createMenu( 4135, addId, -1 );
3990 createMenu( 4033, addId, -1 );
3991 createMenu( separator(), addId, -1 );
3992 createMenu( 4034, addId, -1 );
3993 createMenu( 4035, addId, -1 );
3994 createMenu( 4137, addId, -1 );
3995 createMenu( 4036, addId, -1 );
3996 createMenu( 4136, addId, -1 );
3997 createMenu( 4037, addId, -1 );
3998 createMenu( 4038, addId, -1 );
3999 createMenu( 4039, addId, -1 );
4000 createMenu( 4040, addId, -1 );
4001 createMenu( 4140, addId, -1 );
4003 createMenu( 4041, removeId, -1 );
4004 createMenu( 4042, removeId, -1 );
4005 createMenu( 4044, removeId, -1 );
4006 createMenu( separator(), removeId, -1 );
4007 createMenu( 813, removeId, -1 );
4008 createMenu( separator(), removeId, -1 );
4009 createMenu( 4043, removeId, -1 );
4011 createMenu( 4051, renumId, -1 );
4012 createMenu( 4052, renumId, -1 );
4014 createMenu( 4061, transfId, -1 );
4015 createMenu( 4062, transfId, -1 );
4016 createMenu( 4063, transfId, -1 );
4017 createMenu( 4068, transfId, -1 );
4018 createMenu( 4064, transfId, -1 );
4019 createMenu( 4065, transfId, -1 );
4020 createMenu( 4066, transfId, -1 );
4021 createMenu( 4069, transfId, -1 );
4023 createMenu( 4067,modifyId, -1 );
4024 createMenu( 407, modifyId, -1 );
4025 createMenu( 408, modifyId, -1 );
4026 createMenu( 409, modifyId, -1 );
4027 createMenu( 420, modifyId, -1 );
4028 createMenu( 410, modifyId, -1 );
4029 createMenu( 411, modifyId, -1 );
4030 createMenu( 419, modifyId, -1 );
4031 createMenu( 412, modifyId, -1 );
4032 createMenu( 413, modifyId, -1 );
4033 createMenu( 416, modifyId, -1 );
4034 createMenu( 414, modifyId, -1 );
4035 createMenu( 415, modifyId, -1 );
4036 createMenu( 417, modifyId, -1 );
4037 createMenu( 418, modifyId, -1 );
4039 createMenu( 501, measureId, -1 );
4040 createMenu( 502, measureId, -1 );
4041 createMenu( 503, basicPropId, -1 );
4042 createMenu( 504, basicPropId, -1 );
4043 createMenu( 505, basicPropId, -1 );
4044 createMenu( 214, viewId, -1 );
4046 // ----- create toolbars --------------
4047 int meshTb = createTool( tr( "TB_MESH" ) ),
4048 ctrlTb = createTool( tr( "TB_CTRL" ) ),
4049 addRemTb = createTool( tr( "TB_ADD_REMOVE" ) ),
4050 modifyTb = createTool( tr( "TB_MODIFY" ) ),
4051 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
4053 createTool( 702, meshTb );
4054 createTool( 703, meshTb );
4055 createTool( 704, meshTb );
4056 createTool( 710, meshTb );
4057 createTool( 705, meshTb );
4058 createTool( separator(), meshTb );
4059 createTool( 701, meshTb );
4060 createTool( 711, meshTb );
4061 createTool( 712, meshTb );
4062 createTool( 713, meshTb );
4063 createTool( separator(), meshTb );
4064 createTool( 801, meshTb );
4065 createTool( 806, meshTb );
4066 createTool( 802, meshTb );
4067 createTool( 803, meshTb );
4068 //createTool( 815, meshTb );
4069 createTool( separator(), meshTb );
4070 createTool( 900, meshTb );
4071 //createTool( 902, meshTb );
4072 //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4073 createTool( 904, meshTb );
4074 createTool( separator(), meshTb );
4076 createTool( 6005, ctrlTb );
4077 createTool( 6028, ctrlTb );
4078 createTool( separator(), ctrlTb );
4079 createTool( 6002, ctrlTb );
4080 createTool( 6003, ctrlTb );
4081 createTool( 6001, ctrlTb );
4082 createTool( 6004, ctrlTb );
4083 createTool( 6029, ctrlTb );
4084 createTool( separator(), ctrlTb );
4085 createTool( 6021, ctrlTb );
4086 createTool( 6025, ctrlTb );
4087 createTool( 6027, ctrlTb );
4088 createTool( 6018, ctrlTb );
4089 createTool( 6019, ctrlTb );
4090 createTool( 6011, ctrlTb );
4091 createTool( 6012, ctrlTb );
4092 createTool( 6013, ctrlTb );
4093 createTool( 6014, ctrlTb );
4094 createTool( 6015, ctrlTb );
4095 createTool( 6016, ctrlTb );
4096 createTool( 6022, ctrlTb );
4097 createTool( 6030, ctrlTb );
4098 createTool( separator(), ctrlTb );
4099 createTool( 6017, ctrlTb );
4100 createTool( 6009, ctrlTb );
4101 createTool( 6023, ctrlTb );
4102 createTool( 6024, ctrlTb );
4103 createTool( 6026, ctrlTb );
4104 createTool( 6031, ctrlTb );
4105 createTool( separator(), ctrlTb );
4107 createTool( 4000, addRemTb );
4108 createTool( 4009, addRemTb );
4109 createTool( 4070, addRemTb );
4110 createTool( 4008, addRemTb );
4111 createTool( 4010, addRemTb );
4112 createTool( 4021, addRemTb );
4113 createTool( 4022, addRemTb );
4114 createTool( 4023, addRemTb );
4115 createTool( 4031, addRemTb );
4116 createTool( 4032, addRemTb );
4117 createTool( 4133, addRemTb );
4118 createTool( 4134, addRemTb );
4119 createTool( 4135, addRemTb );
4120 createTool( 4033, addRemTb );
4121 createTool( separator(), addRemTb );
4122 createTool( 4034, addRemTb );
4123 createTool( 4035, addRemTb );
4124 createTool( 4137, addRemTb );
4125 createTool( 4036, addRemTb );
4126 createTool( 4136, addRemTb );
4127 createTool( 4037, addRemTb );
4128 createTool( 4038, addRemTb );
4129 createTool( 4039, addRemTb );
4130 createTool( 4040, addRemTb );
4131 createTool( 4140, addRemTb );
4132 createTool( separator(), addRemTb );
4133 createTool( 4041, addRemTb );
4134 createTool( 4042, addRemTb );
4135 createTool( 4044, addRemTb );
4136 createTool( 4043, addRemTb );
4137 createTool( separator(), addRemTb );
4138 createTool( 4051, addRemTb );
4139 createTool( 4052, addRemTb );
4140 createTool( separator(), addRemTb );
4141 createTool( 4061, addRemTb );
4142 createTool( 4062, addRemTb );
4143 createTool( 4063, addRemTb );
4144 createTool( 4068, addRemTb );
4145 createTool( 4064, addRemTb );
4146 createTool( 4065, addRemTb );
4147 createTool( 4066, addRemTb );
4148 createTool( 4069, addRemTb );
4149 createTool( separator(), addRemTb );
4151 createTool( 4067,modifyTb );
4152 createTool( 407, modifyTb );
4153 createTool( 408, modifyTb );
4154 createTool( 409, modifyTb );
4155 createTool( 420, modifyTb );
4156 createTool( 410, modifyTb );
4157 createTool( 411, modifyTb );
4158 createTool( 419, modifyTb );
4159 createTool( 412, modifyTb );
4160 createTool( 413, modifyTb );
4161 createTool( 416, modifyTb );
4162 createTool( 414, modifyTb );
4163 createTool( 415, modifyTb );
4164 createTool( 417, modifyTb );
4165 createTool( 418, modifyTb );
4167 createTool( 214, dispModeTb );
4169 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4170 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4173 QString OB = "'ObjectBrowser'",
4174 View = "'" + SVTK_Viewer::Type() + "'",
4176 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4177 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4178 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4179 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4180 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4181 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4182 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4183 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4184 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4185 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4186 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4188 mesh_part = mesh + " " + subMesh + " " + group,
4189 mesh_group = mesh + " " + group,
4190 hyp_alg = hypo + " " + algo;
4192 // popup for object browser
4194 isInvisible("not( isVisible )"),
4195 isEmpty("numberOfNodes = 0"),
4196 isNotEmpty("numberOfNodes <> 0"),
4198 // has nodes, edges, etc in VISIBLE! actor
4199 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4200 hasElems("(count( elemTypes ) > 0)"),
4201 hasDifferentElems("(count( elemTypes ) > 1)"),
4202 hasBalls("({'BallElem'} in elemTypes)"),
4203 hasElems0d("({'Elem0d'} in elemTypes)"),
4204 hasEdges("({'Edge'} in elemTypes)"),
4205 hasFaces("({'Face'} in elemTypes)"),
4206 hasVolumes("({'Volume'} in elemTypes)");
4208 createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
4209 createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
4210 createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
4211 createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
4212 createPopupItem( 803, OB, group ); // EDIT_GROUP
4213 createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
4215 popupMgr()->insert( separator(), -1, 0 );
4216 createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
4217 createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
4218 createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
4219 createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
4220 createPopupItem( 214, OB, mesh_part ); // UPDATE
4221 createPopupItem( 900, OB, mesh_part ); // ADV_INFO
4222 createPopupItem( 904, OB, mesh_group ); // FIND_ELEM
4223 createPopupItem( 6032, OB, mesh_part ); // CTRL_INFO
4224 popupMgr()->insert( separator(), -1, 0 );
4225 createPopupItem( 801, OB, mesh ); // CREATE_GROUP
4226 createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
4227 createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
4228 popupMgr()->insert( separator(), -1, 0 );
4229 createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
4230 createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4231 popupMgr()->insert( separator(), -1, 0 );
4232 createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
4233 popupMgr()->insert( separator(), -1, 0 );
4234 createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
4235 createPopupItem( 418, OB, mesh + " " + group, // create 2D mesh from 3D
4237 popupMgr()->insert( separator(), -1, 0 );
4239 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4240 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4241 QString only_one_2D = only_one_non_empty + " && dim>1";
4243 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4244 createPopupItem( 125, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_MED
4245 createPopupItem( 126, OB, mesh_group, only_one_non_empty, anId ); // EXPORT_UNV
4246 createPopupItem( 141, OB, mesh_group, only_one_2D, anId ); // EXPORT_STL
4248 createPopupItem( 143, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_CGNS
4250 createPopupItem( 145, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_SAUV
4251 createPopupItem( 147, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_GMF
4252 createPopupItem( 124, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_DAT
4253 createPopupItem( 33, OB, mesh_part + " " + hyp_alg ); // DELETE
4254 createPopupItem( 813, OB, group ); // DEL_GROUP with contents
4255 popupMgr()->insert( separator(), -1, 0 );
4258 createPopupItem( 803, View, group ); // EDIT_GROUP
4259 createPopupItem( 804, View, elems ); // ADD
4260 createPopupItem( 805, View, elems ); // REMOVE
4262 popupMgr()->insert( separator(), -1, 0 );
4263 createPopupItem( 214, View, mesh_part ); // UPDATE
4264 createPopupItem( 900, View, mesh_part ); // ADV_INFO
4265 createPopupItem( 6032,View, mesh_part ); // CTRL_INFO
4266 createPopupItem( 904, View, mesh ); // FIND_ELEM
4267 popupMgr()->insert( separator(), -1, 0 );
4269 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
4270 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
4271 popupMgr()->insert( separator(), -1, 0 );
4273 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4274 QString aType = QString( "%1type in {%2}" ).arg( lc );
4275 aType = aType.arg( mesh_part );
4276 QString aMeshInVTK = aClient + "&&" + aType;
4278 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4279 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4280 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4282 //-------------------------------------------------
4284 //-------------------------------------------------
4285 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4287 popupMgr()->insert( action( 9010 ), anId, -1 );
4288 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4289 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4291 popupMgr()->insert( action( 9011 ), anId, -1 );
4292 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4293 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4295 popupMgr()->insert( separator(), -1, -1 );
4297 //-------------------------------------------------
4299 //-------------------------------------------------
4300 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4302 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4303 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4304 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4306 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4307 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4308 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4310 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4311 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4312 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4314 popupMgr()->insert( separator(), anId, -1 );
4316 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4317 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4318 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4320 //-------------------------------------------------
4322 //-------------------------------------------------
4323 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4325 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4327 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4328 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4329 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4331 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4332 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4333 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4335 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4336 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4337 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4339 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4340 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4341 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4343 popupMgr()->insert( action( 222 ), anId, -1 ); // BALLS
4344 popupMgr()->setRule( action( 222 ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4345 popupMgr()->setRule( action( 222 ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4347 popupMgr()->insert( separator(), anId, -1 );
4349 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4350 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4353 //-------------------------------------------------
4354 // Representation of the 2D Quadratic elements
4355 //-------------------------------------------------
4356 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4357 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4358 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4359 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4361 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4362 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4363 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4365 //-------------------------------------------------
4366 // Orientation of faces
4367 //-------------------------------------------------
4368 popupMgr()->insert( action( 221 ), -1, -1 );
4369 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4370 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4372 //-------------------------------------------------
4374 //-------------------------------------------------
4375 popupMgr()->insert( action( 1132 ), -1, -1 );
4376 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4378 //-------------------------------------------------
4380 //-------------------------------------------------
4381 popupMgr()->insert( action( 1133 ), -1, -1 );
4382 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4384 //-------------------------------------------------
4386 //-------------------------------------------------
4388 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4389 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4390 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4391 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4393 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4395 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4396 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4398 popupMgr()->insert( separator(), anId, -1 );
4400 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4402 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4403 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4404 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4406 popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4407 popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4408 popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4410 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4412 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4413 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4414 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4416 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4417 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4418 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4420 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4421 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4422 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4424 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4425 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4426 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4427 popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4428 popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4429 popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4431 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4433 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4434 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4435 QtxPopupMgr::VisibleRule );
4436 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4438 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4439 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4440 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4442 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4443 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4444 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4446 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4447 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4448 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4450 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4451 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4452 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4454 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4455 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4456 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4458 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4459 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4460 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4462 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4463 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4464 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4466 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4467 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4468 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4470 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4471 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4472 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4474 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4475 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4476 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4478 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4479 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4480 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4481 popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4482 popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4483 popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4485 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4487 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4488 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4489 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4491 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4492 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4493 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4495 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4496 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4497 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4499 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4500 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4501 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4503 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4504 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4505 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4507 popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4508 popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4509 popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4511 popupMgr()->insert( separator(), anId, -1 );
4513 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4514 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4516 popupMgr()->insert( separator(), anId, -1 );
4518 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4520 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4521 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4523 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4524 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4525 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4527 #ifndef DISABLE_PLOT2DVIEWER
4528 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4529 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4532 //-------------------------------------------------
4534 //-------------------------------------------------
4535 popupMgr()->insert( separator(), -1, -1 );
4536 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4537 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4538 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4539 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4541 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4542 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4544 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4545 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4547 popupMgr()->insert( separator(), -1, -1 );
4549 //-------------------------------------------------
4551 //-------------------------------------------------
4552 popupMgr()->insert( action( 1134 ), -1, -1 );
4553 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4555 popupMgr()->insert( separator(), -1, -1 );
4557 popupMgr()->insert( action( 41 ), -1, -1 );
4558 popupMgr()->setRule( action( 41 ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4559 popupMgr()->insert( separator(), -1, -1 );
4561 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4562 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4564 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4565 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4568 //================================================================================
4570 * \brief Return true if SMESH or GEOM objects are selected.
4571 * Is called form LightApp_Module::activateModule() which clear selection if
4572 * not isSelectionCompatible()
4574 //================================================================================
4576 bool SMESHGUI::isSelectionCompatible()
4578 bool isCompatible = true;
4579 SALOME_ListIO selected;
4580 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4581 Sel->selectedObjects( selected );
4583 SALOME_ListIteratorOfListIO It( selected );
4584 for ( ; isCompatible && It.More(); It.Next())
4586 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4587 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4589 return isCompatible;
4593 bool SMESHGUI::reusableOperation( const int id )
4595 // compute, evaluate and precompute are not reusable operations
4596 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4599 bool SMESHGUI::activateModule( SUIT_Study* study )
4601 bool res = SalomeApp_Module::activateModule( study );
4603 setMenuShown( true );
4604 setToolShown( true );
4606 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4607 PyGILState_STATE gstate = PyGILState_Ensure();
4608 PyObjWrapper pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4609 if ( !pluginsmanager ) {
4613 PyObjWrapper result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4617 PyGILState_Release(gstate);
4618 // end of SMESH plugins loading
4620 // Reset actions accelerator keys
4621 //action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4622 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4623 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4625 action( 33)->setEnabled(true); // Delete: Key_Delete
4627 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4628 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4629 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4630 if ( _PTR(Study) aStudy = s->studyDS()) {
4631 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4632 updateObjBrowser(); // objects can be removed
4635 // get all view currently opened in the study and connect their signals to
4636 // the corresponding slots of the class.
4637 SUIT_Desktop* aDesk = study->application()->desktop();
4639 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4640 SUIT_ViewWindow* wnd;
4641 foreach ( wnd, wndList )
4648 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4650 setMenuShown( false );
4651 setToolShown( false );
4653 EmitSignalCloseAllDialogs();
4655 // Unset actions accelerator keys
4656 //action(111)->setShortcut(QKeySequence()); // Import DAT
4657 action(112)->setShortcut(QKeySequence()); // Import UNV
4658 action(113)->setShortcut(QKeySequence()); // Import MED
4660 action( 33)->setEnabled(false); // Delete: Key_Delete
4662 return SalomeApp_Module::deactivateModule( study );
4665 void SMESHGUI::studyClosed( SUIT_Study* s )
4667 SMESH::RemoveVisuData( s->id() );
4668 SalomeApp_Module::studyClosed( s );
4671 void SMESHGUI::OnGUIEvent()
4673 const QObject* obj = sender();
4674 if ( !obj || !obj->inherits( "QAction" ) )
4676 int id = actionId((QAction*)obj);
4681 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4683 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4684 if ( CORBA::is_nil( myComponentSMESH ) )
4686 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4688 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4689 return aGUI.myComponentSMESH;
4692 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4693 return myComponentSMESH;
4696 QString SMESHGUI::engineIOR() const
4698 CORBA::ORB_var anORB = getApp()->orb();
4699 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4700 return QString( anIOR.in() );
4703 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4705 SalomeApp_Module::contextMenuPopup( client, menu, title );
4707 selectionMgr()->selectedObjects( lst );
4708 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4709 Handle(SALOME_InteractiveObject) io = lst.First();
4710 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4711 _PTR(Study) study = appStudy->studyDS();
4712 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4714 QString aName = QString( obj->GetName().c_str() );
4715 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4716 aName.remove( (aName.length() - 1), 1 );
4722 LightApp_Selection* SMESHGUI::createSelection() const
4724 return new SMESHGUI_Selection();
4727 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4729 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4730 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4733 void SMESHGUI::viewManagers( QStringList& list ) const
4735 list.append( SVTK_Viewer::Type() );
4738 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4740 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4741 SMESH::UpdateSelectionProp( this );
4743 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4744 for(int i = 0; i < aViews.count() ; i++){
4745 SUIT_ViewWindow *sf = aViews[i];
4751 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4753 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4754 myClippingPlaneInfoMap.erase( theViewManager );
4757 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4759 theActor->AddObserver( SMESH::DeleteActorEvent,
4760 myEventCallbackCommand.GetPointer(),
4764 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4765 unsigned long theEvent,
4766 void* theClientData,
4769 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4770 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4771 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4772 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4773 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4774 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4775 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4776 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4777 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4778 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4779 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4780 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4781 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4782 if( anActor == *anIter3 ) {
4783 anActorList.erase( anIter3 );
4794 void SMESHGUI::createPreferences()
4796 // General tab ------------------------------------------------------------------------
4797 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4799 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4800 setPreferenceProperty( autoUpdate, "columns", 2 );
4801 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4802 setPreferenceProperty( lim, "min", 0 );
4803 setPreferenceProperty( lim, "max", 100000000 );
4804 setPreferenceProperty( lim, "step", 1000 );
4805 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4806 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4808 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4809 setPreferenceProperty( qaGroup, "columns", 2 );
4810 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4811 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4812 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4813 setPreferenceProperty( prec, "min", 0 );
4814 setPreferenceProperty( prec, "max", 16 );
4815 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4816 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4817 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4818 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4819 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4821 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4822 setPreferenceProperty( dispgroup, "columns", 2 );
4823 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4825 modes.append( tr("MEN_WIRE") );
4826 modes.append( tr("MEN_SHADE") );
4827 modes.append( tr("MEN_NODES") );
4828 modes.append( tr("MEN_SHRINK") );
4829 QList<QVariant> indices;
4830 indices.append( 0 );
4831 indices.append( 1 );
4832 indices.append( 2 );
4833 indices.append( 3 );
4834 setPreferenceProperty( dispmode, "strings", modes );
4835 setPreferenceProperty( dispmode, "indexes", indices );
4837 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4838 setPreferenceProperty( arcgroup, "columns", 2 );
4839 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4840 QStringList quadraticModes;
4841 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4842 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4844 indices.append( 0 );
4845 indices.append( 1 );
4846 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4847 setPreferenceProperty( quadraticmode, "indexes", indices );
4849 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4850 "SMESH", "max_angle" );
4851 setPreferenceProperty( maxAngle, "min", 1 );
4852 setPreferenceProperty( maxAngle, "max", 90 );
4856 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4857 setPreferenceProperty( exportgroup, "columns", 2 );
4858 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4859 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4861 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4862 setPreferenceProperty( computeGroup, "columns", 2 );
4863 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4865 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4866 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4867 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4869 indices.append( 0 );
4870 indices.append( 1 );
4871 indices.append( 2 );
4872 setPreferenceProperty( notifyMode, "strings", modes );
4873 setPreferenceProperty( notifyMode, "indexes", indices );
4875 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4876 setPreferenceProperty( infoGroup, "columns", 2 );
4877 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4879 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4880 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4882 indices.append( 0 );
4883 indices.append( 1 );
4884 setPreferenceProperty( elemInfo, "strings", modes );
4885 setPreferenceProperty( elemInfo, "indexes", indices );
4886 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4887 setPreferenceProperty( nodesLim, "min", 0 );
4888 setPreferenceProperty( nodesLim, "max", 10000000 );
4889 setPreferenceProperty( nodesLim, "step", 10000 );
4890 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4891 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
4892 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4893 setPreferenceProperty( ctrlLim, "min", 0 );
4894 setPreferenceProperty( ctrlLim, "max", 10000000 );
4895 setPreferenceProperty( ctrlLim, "step", 1000 );
4896 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
4897 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
4898 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
4899 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
4900 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
4902 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4903 setPreferenceProperty( segGroup, "columns", 2 );
4904 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4905 "SMESH", "segmentation" );
4906 setPreferenceProperty( segLen, "min", 1 );
4907 setPreferenceProperty( segLen, "max", 10000000 );
4908 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4909 "SMESH", "nb_segments_per_edge" );
4910 setPreferenceProperty( nbSeg, "min", 1 );
4911 setPreferenceProperty( nbSeg, "max", 10000000 );
4913 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4914 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4915 "SMESH", "forget_mesh_on_hyp_modif" );
4918 // Quantities with individual precision settings
4919 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4920 setPreferenceProperty( precGroup, "columns", 2 );
4922 const int nbQuantities = 6;
4923 int precs[nbQuantities], ii = 0;
4924 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4925 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4926 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4927 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4928 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4929 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4930 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4931 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4932 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4933 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4934 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4935 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4937 // Set property for precision value for spinboxes
4938 for ( ii = 0; ii < nbQuantities; ii++ ){
4939 setPreferenceProperty( precs[ii], "min", -14 );
4940 setPreferenceProperty( precs[ii], "max", 14 );
4941 setPreferenceProperty( precs[ii], "precision", 2 );
4944 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4945 setPreferenceProperty( previewGroup, "columns", 2 );
4946 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4947 setPreferenceProperty( chunkSize, "min", 1 );
4948 setPreferenceProperty( chunkSize, "max", 1000 );
4949 setPreferenceProperty( chunkSize, "step", 50 );
4951 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4952 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4954 // Mesh tab ------------------------------------------------------------------------
4955 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4956 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4957 setPreferenceProperty( nodeGroup, "columns", 3 );
4959 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4961 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4963 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4964 QList<QVariant> aMarkerTypeIndicesList;
4965 QList<QVariant> aMarkerTypeIconsList;
4966 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4967 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4968 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4969 aMarkerTypeIndicesList << i;
4970 aMarkerTypeIconsList << pixmap;
4972 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4973 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4975 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4977 QList<QVariant> aMarkerScaleIndicesList;
4978 QStringList aMarkerScaleValuesList;
4979 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4980 aMarkerScaleIndicesList << i;
4981 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4983 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4984 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4986 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4987 //setPreferenceProperty( elemGroup, "columns", 2 );
4989 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4990 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4991 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
4992 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
4993 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4994 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
4995 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4996 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4997 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5000 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5001 setPreferenceProperty( grpGroup, "columns", 2 );
5003 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5004 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5006 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5007 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5008 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5009 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
5010 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5011 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5012 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5013 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5014 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5015 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5017 setPreferenceProperty( size0d, "min", 1 );
5018 setPreferenceProperty( size0d, "max", 10 );
5020 setPreferenceProperty( ballSize, "min", 1 );
5021 setPreferenceProperty( ballSize, "max", 10 );
5023 setPreferenceProperty( elemW, "min", 1 );
5024 setPreferenceProperty( elemW, "max", 5 );
5026 setPreferenceProperty( outW, "min", 1 );
5027 setPreferenceProperty( outW, "max", 5 );
5029 setPreferenceProperty( shrink, "min", 0 );
5030 setPreferenceProperty( shrink, "max", 100 );
5032 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5033 setPreferenceProperty( numGroup, "columns", 2 );
5035 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5036 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5038 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5039 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5041 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5042 setPreferenceProperty( orientGroup, "columns", 1 );
5044 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5045 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5047 setPreferenceProperty( orientScale, "min", 0.05 );
5048 setPreferenceProperty( orientScale, "max", 0.5 );
5049 setPreferenceProperty( orientScale, "step", 0.05 );
5051 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5053 // Selection tab ------------------------------------------------------------------------
5054 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5056 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5057 setPreferenceProperty( selGroup, "columns", 2 );
5059 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5060 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5062 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5063 setPreferenceProperty( preGroup, "columns", 2 );
5065 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5067 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5068 setPreferenceProperty( precSelGroup, "columns", 2 );
5070 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5071 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5072 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5074 // Scalar Bar tab ------------------------------------------------------------------------
5075 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5076 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5077 setPreferenceProperty( fontGr, "columns", 2 );
5079 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5080 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5082 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5083 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5085 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5086 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5088 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5089 setPreferenceProperty( numcol, "min", 2 );
5090 setPreferenceProperty( numcol, "max", 256 );
5092 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5093 setPreferenceProperty( numlab, "min", 2 );
5094 setPreferenceProperty( numlab, "max", 65 );
5096 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5097 setPreferenceProperty( orientGr, "columns", 2 );
5098 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5099 QStringList orients;
5100 orients.append( tr( "SMESH_VERTICAL" ) );
5101 orients.append( tr( "SMESH_HORIZONTAL" ) );
5102 indices.clear(); indices.append( 0 ); indices.append( 1 );
5103 setPreferenceProperty( orient, "strings", orients );
5104 setPreferenceProperty( orient, "indexes", indices );
5106 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5107 setPreferenceProperty( posVSizeGr, "columns", 2 );
5108 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5109 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5110 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5111 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5112 setPreferenceProperty( xv, "step", 0.1 );
5113 setPreferenceProperty( xv, "min", 0.0 );
5114 setPreferenceProperty( xv, "max", 1.0 );
5115 setPreferenceProperty( yv, "step", 0.1 );
5116 setPreferenceProperty( yv, "min", 0.0 );
5117 setPreferenceProperty( yv, "max", 1.0 );
5118 setPreferenceProperty( wv, "step", 0.1 );
5119 setPreferenceProperty( wv, "min", 0.0 );
5120 setPreferenceProperty( wv, "max", 1.0 );
5121 setPreferenceProperty( hv, "min", 0.0 );
5122 setPreferenceProperty( hv, "max", 1.0 );
5123 setPreferenceProperty( hv, "step", 0.1 );
5125 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5126 setPreferenceProperty( posHSizeGr, "columns", 2 );
5127 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5128 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5129 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5130 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5131 setPreferenceProperty( xv, "min", 0.0 );
5132 setPreferenceProperty( xv, "max", 1.0 );
5133 setPreferenceProperty( xv, "step", 0.1 );
5134 setPreferenceProperty( xh, "min", 0.0 );
5135 setPreferenceProperty( xh, "max", 1.0 );
5136 setPreferenceProperty( xh, "step", 0.1 );
5137 setPreferenceProperty( yh, "min", 0.0 );
5138 setPreferenceProperty( yh, "max", 1.0 );
5139 setPreferenceProperty( yh, "step", 0.1 );
5140 setPreferenceProperty( wh, "min", 0.0 );
5141 setPreferenceProperty( wh, "max", 1.0 );
5142 setPreferenceProperty( wh, "step", 0.1 );
5143 setPreferenceProperty( hh, "min", 0.0 );
5144 setPreferenceProperty( hh, "max", 1.0 );
5145 setPreferenceProperty( hh, "step", 0.1 );
5147 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5148 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5149 setPreferenceProperty( distributionGr, "columns", 3 );
5151 types.append( tr( "SMESH_MONOCOLOR" ) );
5152 types.append( tr( "SMESH_MULTICOLOR" ) );
5153 indices.clear(); indices.append( 0 ); indices.append( 1 );
5154 setPreferenceProperty( coloringType, "strings", types );
5155 setPreferenceProperty( coloringType, "indexes", indices );
5156 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5160 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5162 if( sect=="SMESH" ) {
5163 float sbX1,sbY1,sbW,sbH;
5164 float aTol = 1.00000009999999;
5165 std::string aWarning;
5166 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5167 if( name=="selection_object_color" || name=="selection_element_color" ||
5168 name=="highlight_color" ||
5169 name=="selection_precision_node" || name=="selection_precision_element" ||
5170 name=="selection_precision_object")
5171 SMESH::UpdateSelectionProp( this );
5172 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5173 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5174 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5175 if(sbX1+sbW > aTol){
5176 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5179 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5180 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5183 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5184 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5185 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5186 if(sbY1+sbH > aTol){
5187 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5188 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5189 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5192 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5193 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5194 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5195 if(sbX1+sbW > aTol){
5196 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5199 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5200 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5203 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5204 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5205 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5206 if(sbY1+sbH > aTol){
5207 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5210 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5211 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5214 else if ( name == "segmentation" ) {
5215 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5216 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5218 else if ( name == "nb_segments_per_edge" ) {
5219 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5220 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5222 else if ( name == "historical_python_dump" ||
5223 name == "forget_mesh_on_hyp_modif") {
5224 QString val = aResourceMgr->stringValue( "SMESH", name );
5225 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5227 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5228 SMESH::UpdateFontProp( this );
5230 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5231 SMESH::UpdateFontProp( this );
5234 if(aWarning.size() != 0){
5235 aWarning += "The default values are applied instead.";
5236 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5237 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5238 QObject::tr(aWarning.c_str()));
5243 //================================================================================
5245 * \brief Update something in accordance with update flags
5246 * \param theFlags - update flags
5248 * Update viewer or/and object browser etc. in accordance with update flags ( see
5249 * LightApp_UpdateFlags enumeration ).
5251 //================================================================================
5252 void SMESHGUI::update( const int flags )
5254 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5255 SMESH::UpdateView();
5257 SalomeApp_Module::update( flags );
5260 //================================================================================
5262 * \brief Set default selection mode
5264 * SLOT called when operation commited. Sets default selection mode
5266 //================================================================================
5267 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5269 SVTK_ViewWindow* vtkWnd =
5270 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5272 vtkWnd->SetSelectionMode( ActorSelection );
5275 //================================================================================
5277 * \brief Set default selection mode
5279 * SLOT called when operation aborted. Sets default selection mode
5281 //================================================================================
5282 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5284 SVTK_ViewWindow* vtkWnd =
5285 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5287 vtkWnd->SetSelectionMode( ActorSelection );
5290 //================================================================================
5292 * \brief Creates operation with given identifier
5293 * \param id - identifier of operation to be started
5294 * \return Pointer on created operation or NULL if operation is not created
5296 * Virtual method redefined from the base class creates operation with given id.
5297 * It is called called automatically from startOperation method of base class.
5299 //================================================================================
5300 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5302 LightApp_Operation* op = 0;
5303 // to do : create operation here
5306 case 417: //convert to quadratic
5307 op = new SMESHGUI_ConvToQuadOp();
5309 case 418: // create 2D mesh as boundary on 3D
5310 op = new SMESHGUI_Make2DFrom3DOp();
5312 case 420: // Reorient faces
5313 op = new SMESHGUI_ReorientFacesOp();
5315 case 701: // Compute mesh
5316 op = new SMESHGUI_ComputeOp();
5318 case 702: // Create mesh
5319 op = new SMESHGUI_MeshOp( true, true );
5321 case 703: // Create sub-mesh
5322 op = new SMESHGUI_MeshOp( true, false );
5324 case 704: // Edit mesh/sub-mesh
5325 op = new SMESHGUI_MeshOp( false );
5327 case 711: // Precompute mesh
5328 op = new SMESHGUI_PrecomputeOp();
5330 case 712: // Evaluate mesh
5331 op = new SMESHGUI_EvaluateOp();
5333 case 713: // Evaluate mesh
5334 op = new SMESHGUI_MeshOrderOp();
5336 case 806: // Create group on geom
5337 op = new SMESHGUI_GroupOnShapeOp();
5339 case 904: // Find element
5340 op = new SMESHGUI_FindElemByPointOp();
5342 case 4067: // Make mesh pass through point
5343 op = new SMESHGUI_MakeNodeAtPointOp();
5345 case 4070: // Create 0D elements on all nodes
5346 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5353 op = SalomeApp_Module::createOperation( id );
5357 //================================================================================
5359 * \brief Stops current operations and starts a given one
5360 * \param id - The id of the operation to start
5362 //================================================================================
5364 void SMESHGUI::switchToOperation(int id)
5366 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5367 activeStudy()->abortAllOperations();
5368 startOperation( id );
5371 LightApp_Displayer* SMESHGUI::displayer()
5374 myDisplayer = new SMESHGUI_Displayer( getApp() );
5378 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5381 int aTolerance = 64;
5382 int anIterations = 0;
5388 if( anIterations % aPeriod == 0 )
5391 if( aTolerance < 1 )
5395 aHue = (int)( 360.0 * rand() / RAND_MAX );
5398 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5399 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5400 for( ; it != itEnd; ++it )
5402 SALOMEDS::Color anAutoColor = *it;
5403 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5406 aQColor.getHsv( &h, &s, &v );
5407 if( abs( h - aHue ) < aTolerance )
5419 aColor.setHsv( aHue, 255, 255 );
5421 SALOMEDS::Color aSColor;
5422 aSColor.R = aColor.redF();
5423 aSColor.G = aColor.greenF();
5424 aSColor.B = aColor.blueF();
5429 const char* gSeparator = "_"; // character used to separate parameter names
5430 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5431 const char* gPathSep = "|"; // character used to separate paths
5434 * \brief Store visual parameters
5436 * This method is called just before the study document is saved.
5437 * Store visual parameters in AttributeParameter attribue(s)
5439 void SMESHGUI::storeVisualParameters (int savePoint)
5442 Kernel_Utils::Localizer loc;
5444 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5445 if (!appStudy || !appStudy->studyDS())
5447 _PTR(Study) studyDS = appStudy->studyDS();
5449 // componentName is used for encoding of entries when storing them in IParameters
5450 std::string componentName = myComponentSMESH->ComponentDataType();
5451 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5452 //if (!aSComponent) return;
5455 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5456 componentName.c_str(),
5458 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5460 // store map of custom markers
5461 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5462 if( !aMarkerMap.empty() )
5464 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5465 for( ; anIter != aMarkerMap.end(); anIter++ )
5467 int anId = anIter->first;
5468 VTK::MarkerData aMarkerData = anIter->second;
5469 std::string aMarkerFileName = aMarkerData.first;
5470 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5471 if( aMarkerTexture.size() < 3 )
5472 continue; // should contain at least width, height and the first value
5474 QString aPropertyName( "texture" );
5475 aPropertyName += gSeparator;
5476 aPropertyName += QString::number( anId );
5478 QString aPropertyValue = aMarkerFileName.c_str();
5479 aPropertyValue += gPathSep;
5481 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5482 ushort aWidth = *aTextureIter++;
5483 ushort aHeight = *aTextureIter++;
5484 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5485 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5486 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5487 aPropertyValue += QString::number( *aTextureIter );
5489 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5493 // viewers counters are used for storing view_numbers in IParameters
5496 // main cycle to store parameters of displayed objects
5497 QList<SUIT_ViewManager*> lst;
5498 QList<SUIT_ViewManager*>::Iterator it;
5499 getApp()->viewManagers(lst);
5500 for (it = lst.begin(); it != lst.end(); it++)
5502 SUIT_ViewManager* vman = *it;
5503 QString vType = vman->getType();
5505 // saving VTK actors properties
5506 if (vType == SVTK_Viewer::Type())
5508 // store the clipping planes attached to the view manager
5509 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5510 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5511 if( anIter != myClippingPlaneInfoMap.end() )
5512 aClippingPlaneInfoList = anIter->second;
5514 if( !aClippingPlaneInfoList.empty() ) {
5515 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5516 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5518 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5519 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5521 QString aPropertyName( "ClippingPlane" );
5522 aPropertyName += gSeparator;
5523 aPropertyName += QString::number( vtkViewers );
5524 aPropertyName += gSeparator;
5525 aPropertyName += QString::number( anId );
5527 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5528 aPropertyValue += gDigitsSep;
5529 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5530 aPropertyValue += gDigitsSep;
5531 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5532 aPropertyValue += gDigitsSep;
5533 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5535 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5539 QVector<SUIT_ViewWindow*> views = vman->getViews();
5540 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5542 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5544 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5545 vtkActorCollection* allActors = aCopy.GetActors();
5546 allActors->InitTraversal();
5547 while (vtkActor* actor = allActors->GetNextActor())
5549 if (actor->GetVisibility()) // store only visible actors
5551 SMESH_Actor* aSmeshActor = 0;
5552 if (actor->IsA("SMESH_Actor"))
5553 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5554 if (aSmeshActor && aSmeshActor->hasIO())
5556 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5559 // entry is "encoded" = it does NOT contain component adress,
5560 // since it is a subject to change on next component loading
5561 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5563 std::string param, vtkParam = vType.toLatin1().data();
5564 vtkParam += gSeparator;
5565 vtkParam += QString::number(vtkViewers).toLatin1().data();
5566 vtkParam += gSeparator;
5569 param = vtkParam + "Visibility";
5570 ip->setParameter(entry, param, "On");
5573 param = vtkParam + "Representation";
5574 ip->setParameter(entry, param, QString::number
5575 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5578 param = vtkParam + "IsShrunk";
5579 ip->setParameter(entry, param, QString::number
5580 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5582 // Displayed entities
5583 unsigned int aMode = aSmeshActor->GetEntityMode();
5584 bool isE = aMode & SMESH_Actor::eEdges;
5585 bool isF = aMode & SMESH_Actor::eFaces;
5586 bool isV = aMode & SMESH_Actor::eVolumes;
5587 bool is0d = aMode & SMESH_Actor::e0DElements;
5588 bool isB = aMode & SMESH_Actor::eBallElem;
5590 QString modeStr ("e");
5591 modeStr += gDigitsSep; modeStr += QString::number(isE);
5592 modeStr += gDigitsSep; modeStr += "f";
5593 modeStr += gDigitsSep; modeStr += QString::number(isF);
5594 modeStr += gDigitsSep; modeStr += "v";
5595 modeStr += gDigitsSep; modeStr += QString::number(isV);
5596 modeStr += gDigitsSep; modeStr += "0d";
5597 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5598 modeStr += gDigitsSep; modeStr += "b";
5599 modeStr += gDigitsSep; modeStr += QString::number(isB);
5601 param = vtkParam + "Entities";
5602 ip->setParameter(entry, param, modeStr.toLatin1().data());
5608 aSmeshActor->GetSufaceColor(r, g, b, delta);
5609 QStringList colorStr;
5610 colorStr << "surface";
5611 colorStr << QString::number(r);
5612 colorStr << QString::number(g);
5613 colorStr << QString::number(b);
5615 colorStr << "backsurface";
5616 colorStr << QString::number(delta);
5618 aSmeshActor->GetVolumeColor(r, g, b, delta);
5619 colorStr << "volume";
5620 colorStr << QString::number(r);
5621 colorStr << QString::number(g);
5622 colorStr << QString::number(b);
5623 colorStr << QString::number(delta);
5625 aSmeshActor->GetEdgeColor(r, g, b);
5627 colorStr << QString::number(r);
5628 colorStr << QString::number(g);
5629 colorStr << QString::number(b);
5631 aSmeshActor->GetNodeColor(r, g, b);
5633 colorStr << QString::number(r);
5634 colorStr << QString::number(g);
5635 colorStr << QString::number(b);
5637 aSmeshActor->GetOutlineColor(r, g, b);
5638 colorStr << "outline";
5639 colorStr << QString::number(r);
5640 colorStr << QString::number(g);
5641 colorStr << QString::number(b);
5643 aSmeshActor->Get0DColor(r, g, b);
5644 colorStr << "elem0d";
5645 colorStr << QString::number(r);
5646 colorStr << QString::number(g);
5647 colorStr << QString::number(b);
5649 aSmeshActor->GetBallColor(r, g, b);
5651 colorStr << QString::number(r);
5652 colorStr << QString::number(g);
5653 colorStr << QString::number(b);
5655 aSmeshActor->GetFacesOrientationColor(r, g, b);
5656 colorStr << "orientation";
5657 colorStr << QString::number(r);
5658 colorStr << QString::number(g);
5659 colorStr << QString::number(b);
5661 param = vtkParam + "Colors";
5662 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5665 QStringList sizeStr;
5667 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5668 sizeStr << "outline";
5669 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5670 sizeStr << "elem0d";
5671 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5673 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5674 sizeStr << "shrink";
5675 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5676 sizeStr << "orientation";
5677 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5678 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5680 param = vtkParam + "Sizes";
5681 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5686 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5687 if( aMarkerType == VTK::MT_USER ) {
5688 markerStr += "custom";
5689 markerStr += gDigitsSep;
5690 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5694 markerStr += gDigitsSep;
5695 markerStr += QString::number( (int)aMarkerType );
5696 markerStr += gDigitsSep;
5697 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5700 param = vtkParam + "PointMarker";
5701 ip->setParameter(entry, param, markerStr.toLatin1().data());
5704 param = vtkParam + "Opacity";
5705 ip->setParameter(entry, param,
5706 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5709 param = vtkParam + "ClippingPlane";
5711 if( !aClippingPlaneInfoList.empty() ) {
5712 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5713 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5715 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5716 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5717 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5718 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5719 if( aSmeshActor == *anIter2 ) {
5720 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5721 QString::number( anId ).toLatin1().constData() );
5728 ip->setParameter( entry, param, "Off" );
5729 } // if (io->hasEntry())
5730 } // SMESH_Actor && hasIO
5732 } // while.. actors traversal
5736 } // if (SVTK view model)
5737 } // for (viewManagers)
5740 // data structures for clipping planes processing
5743 vtkIdType Orientation;
5747 typedef std::list<TPlaneData> TPlaneDataList;
5748 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5750 typedef std::list<vtkActor*> TActorList;
5753 TActorList ActorList;
5754 SUIT_ViewManager* ViewManager;
5756 typedef std::list<TPlaneInfo> TPlaneInfoList;
5757 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5760 * \brief Restore visual parameters
5762 * This method is called after the study document is opened.
5763 * Restore visual parameters from AttributeParameter attribue(s)
5765 void SMESHGUI::restoreVisualParameters (int savePoint)
5768 Kernel_Utils::Localizer loc;
5770 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5771 if (!appStudy || !appStudy->studyDS())
5773 _PTR(Study) studyDS = appStudy->studyDS();
5775 // componentName is used for encoding of entries when storing them in IParameters
5776 std::string componentName = myComponentSMESH->ComponentDataType();
5777 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5778 //if (!aSComponent) return;
5781 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5782 componentName.c_str(),
5784 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5786 // restore map of custom markers and map of clipping planes
5787 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5788 TPlaneDataMap aPlaneDataMap;
5790 std::vector<std::string> properties = ip->getProperties();
5791 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5793 std::string property = *propIt;
5794 QString aPropertyName( property.c_str() );
5795 QString aPropertyValue( ip->getProperty( property ).c_str() );
5797 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5798 if( aPropertyNameList.isEmpty() )
5801 QString aPropertyType = aPropertyNameList[0];
5802 if( aPropertyType == "texture" )
5804 if( aPropertyNameList.size() != 2 )
5808 int anId = aPropertyNameList[1].toInt( &ok );
5809 if( !ok || anId < 1 )
5812 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5813 if( aPropertyValueList.size() != 2 )
5816 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5817 QString aMarkerTextureString = aPropertyValueList[1];
5818 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5819 if( aMarkerTextureStringList.size() != 3 )
5823 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5828 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5832 VTK::MarkerTexture aMarkerTexture;
5833 aMarkerTexture.push_back( aWidth );
5834 aMarkerTexture.push_back( aHeight );
5836 QString aMarkerTextureData = aMarkerTextureStringList[2];
5837 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5839 QChar aChar = aMarkerTextureData.at( i );
5840 if( aChar.isDigit() )
5841 aMarkerTexture.push_back( aChar.digitValue() );
5844 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5846 else if( aPropertyType == "ClippingPlane" )
5848 if( aPropertyNameList.size() != 3 )
5852 int aViewId = aPropertyNameList[1].toInt( &ok );
5853 if( !ok || aViewId < 0 )
5857 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5858 if( !ok || aClippingPlaneId < 0 )
5861 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5862 if( aPropertyValueList.size() != 4 )
5865 TPlaneData aPlaneData;
5866 aPlaneData.Id = aClippingPlaneId;
5869 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5874 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5879 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5884 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5888 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5889 aPlaneDataList.push_back( aPlaneData );
5893 TPlaneInfoMap aPlaneInfoMap;
5895 std::vector<std::string> entries = ip->getEntries();
5897 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5899 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5900 QString entry (ip->decodeEntry(*entIt).c_str());
5902 // Check that the entry corresponds to a real object in the Study
5903 // as the object may be deleted or modified after the visual state is saved.
5904 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5905 if (!so) continue; //Skip the not existent entry
5907 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5908 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5910 std::vector<std::string>::iterator namesIt = paramNames.begin();
5911 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5913 // actors are stored in a map after displaying of them for
5914 // quicker access in the future: map < viewID to actor >
5915 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5917 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5919 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5920 // '_' is used as separator and should not be used in viewer type or parameter names.
5921 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5922 if (lst.size() != 3)
5925 QString viewerTypStr = lst[0];
5926 QString viewIndexStr = lst[1];
5927 QString paramNameStr = lst[2];
5930 int viewIndex = viewIndexStr.toUInt(&ok);
5931 if (!ok) // bad conversion of view index to integer
5935 if (viewerTypStr == SVTK_Viewer::Type())
5937 SMESH_Actor* aSmeshActor = 0;
5938 if (vtkActors.IsBound(viewIndex))
5939 aSmeshActor = vtkActors.Find(viewIndex);
5941 QList<SUIT_ViewManager*> lst;
5942 getApp()->viewManagers(viewerTypStr, lst);
5944 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5945 SUIT_ViewManager* vman = NULL;
5946 if (viewIndex >= 0 && viewIndex < lst.count())
5947 vman = lst.at(viewIndex);
5949 if (paramNameStr == "Visibility")
5951 if (!aSmeshActor && displayer() && vman)
5953 SUIT_ViewModel* vmodel = vman->getViewModel();
5954 // SVTK view model can be casted to SALOME_View
5955 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5957 // store displayed actor in a temporary map for quicker
5958 // access later when restoring other parameters
5959 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5960 vtkRenderer* Renderer = vtkView->getRenderer();
5961 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5962 vtkActorCollection* theActors = aCopy.GetActors();
5963 theActors->InitTraversal();
5964 bool isFound = false;
5965 vtkActor *ac = theActors->GetNextActor();
5966 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5967 if (ac->IsA("SMESH_Actor")) {
5968 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5969 if (aGeomAc->hasIO()) {
5970 Handle(SALOME_InteractiveObject) io =
5971 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5972 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5974 vtkActors.Bind(viewIndex, aGeomAc);
5980 } // if (paramNameStr == "Visibility")
5983 // the rest properties "work" with SMESH_Actor
5986 QString val ((*valuesIt).c_str());
5989 if (paramNameStr == "Representation") {
5990 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5993 else if (paramNameStr == "IsShrunk") {
5995 if (!aSmeshActor->IsShrunk())
5996 aSmeshActor->SetShrink();
5999 if (aSmeshActor->IsShrunk())
6000 aSmeshActor->UnShrink();
6003 // Displayed entities
6004 else if (paramNameStr == "Entities") {
6005 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6006 int aEntityMode = SMESH_Actor::eAllEntity;
6007 for ( int i = 0; i < mode.count(); i+=2 ) {
6008 if ( i < mode.count()-1 ) {
6009 QString type = mode[i];
6010 bool val = mode[i+1].toInt();
6011 if ( type == "e" && !val )
6012 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6013 else if ( type == "f" && !val )
6014 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6015 else if ( type == "v" && !val )
6016 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6017 else if ( type == "0d" && !val )
6018 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6019 else if ( type == "b" && !val )
6020 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6023 aSmeshActor->SetEntityMode( aEntityMode );
6026 else if (paramNameStr == "Colors") {
6027 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6034 QColor outlineColor;
6035 QColor orientationColor;
6041 // below lines are required to get default values for delta coefficients
6042 // of backface color for faces and color of reversed volumes
6043 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6044 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6045 for ( int i = 0; i < colors.count(); i++ ) {
6046 QString type = colors[i];
6047 if ( type == "surface" ) {
6048 // face color is set by 3 values r:g:b, where
6049 // - r,g,b - is rgb color components
6050 if ( i+1 >= colors.count() ) break; // format error
6051 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6052 if ( i+2 >= colors.count() ) break; // format error
6053 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6054 if ( i+3 >= colors.count() ) break; // format error
6055 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6056 faceColor.setRgbF( r, g, b );
6059 else if ( type == "backsurface" ) {
6060 // backface color can be defined in several ways
6061 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6062 // - in latest versions, it is set as delta coefficient
6063 bool rgbOk = false, deltaOk;
6064 if ( i+1 >= colors.count() ) break; // format error
6065 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6066 int delta = colors[i+1].toInt( &deltaOk );
6068 if ( i+1 < colors.count() ) // index is shifted to 1
6069 g = colors[i+1].toDouble( &rgbOk );
6070 if ( rgbOk ) i++; // shift index
6071 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6072 b = colors[i+1].toDouble( &rgbOk );
6074 // - as currently there's no way to set directly backsurface color as it was before,
6075 // we ignore old dump where r,g,b triple was set
6076 // - also we check that delta parameter is set properly
6077 if ( !rgbOk && deltaOk )
6080 else if ( type == "volume" ) {
6081 // volume color is set by 4 values r:g:b:delta, where
6082 // - r,g,b - is a normal volume rgb color components
6083 // - delta - is a reversed volume color delta coefficient
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 if ( i+4 >= colors.count() ) break; // format error
6091 int delta = colors[i+4].toInt( &bOk );
6092 if ( !bOk ) break; // format error
6093 volumeColor.setRgbF( r, g, b );
6097 else if ( type == "edge" ) {
6098 // edge color is set by 3 values r:g:b, where
6099 // - r,g,b - is rgb color components
6100 if ( i+1 >= colors.count() ) break; // format error
6101 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6102 if ( i+2 >= colors.count() ) break; // format error
6103 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6104 if ( i+3 >= colors.count() ) break; // format error
6105 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6106 edgeColor.setRgbF( r, g, b );
6109 else if ( type == "node" ) {
6110 // node color is set by 3 values r:g:b, where
6111 // - r,g,b - is rgb color components
6112 if ( i+1 >= colors.count() ) break; // format error
6113 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6114 if ( i+2 >= colors.count() ) break; // format error
6115 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6116 if ( i+3 >= colors.count() ) break; // format error
6117 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6118 nodeColor.setRgbF( r, g, b );
6121 else if ( type == "elem0d" ) {
6122 // 0d element color is set by 3 values r:g:b, where
6123 // - r,g,b - is rgb color components
6124 if ( i+1 >= colors.count() ) break; // format error
6125 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6126 if ( i+2 >= colors.count() ) break; // format error
6127 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6128 if ( i+3 >= colors.count() ) break; // format error
6129 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6130 elem0dColor.setRgbF( r, g, b );
6133 else if ( type == "ball" ) {
6134 // ball color is set by 3 values r:g:b, where
6135 // - r,g,b - is rgb color components
6136 if ( i+1 >= colors.count() ) break; // format error
6137 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6138 if ( i+2 >= colors.count() ) break; // format error
6139 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6140 if ( i+3 >= colors.count() ) break; // format error
6141 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6142 ballColor.setRgbF( r, g, b );
6145 else if ( type == "outline" ) {
6146 // outline color is set by 3 values r:g:b, where
6147 // - r,g,b - is rgb color components
6148 if ( i+1 >= colors.count() ) break; // format error
6149 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6150 if ( i+2 >= colors.count() ) break; // format error
6151 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6152 if ( i+3 >= colors.count() ) break; // format error
6153 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6154 outlineColor.setRgbF( r, g, b );
6157 else if ( type == "orientation" ) {
6158 // orientation color is set by 3 values r:g:b, where
6159 // - r,g,b - is rgb color components
6160 if ( i+1 >= colors.count() ) break; // format error
6161 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6162 if ( i+2 >= colors.count() ) break; // format error
6163 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6164 if ( i+3 >= colors.count() ) break; // format error
6165 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6166 orientationColor.setRgbF( r, g, b );
6171 if ( nodeColor.isValid() )
6172 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6174 if ( edgeColor.isValid() )
6175 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6177 if ( faceColor.isValid() )
6178 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6180 if ( volumeColor.isValid() )
6181 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6182 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6183 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6185 if ( elem0dColor.isValid() )
6186 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6188 if ( ballColor.isValid() )
6189 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6191 if ( outlineColor.isValid() )
6192 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6193 // orientation color
6194 if ( orientationColor.isValid() )
6195 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6198 else if (paramNameStr == "Sizes") {
6199 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6202 int outlineWidth = -1;
6203 int elem0dSize = -1;
6205 double shrinkSize = -1;
6206 double orientationSize = -1;
6207 bool orientation3d = false;
6208 for ( int i = 0; i < sizes.count(); i++ ) {
6209 QString type = sizes[i];
6210 if ( type == "line" ) {
6211 // line (wireframe) width is given as single integer value
6212 if ( i+1 >= sizes.count() ) break; // format error
6213 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6217 if ( type == "outline" ) {
6218 // outline width is given as single integer value
6219 if ( i+1 >= sizes.count() ) break; // format error
6220 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6224 else if ( type == "elem0d" ) {
6225 // 0d element size is given as single integer value
6226 if ( i+1 >= sizes.count() ) break; // format error
6227 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6231 else if ( type == "ball" ) {
6232 // ball size is given as single integer value
6233 if ( i+1 >= sizes.count() ) break; // format error
6234 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6238 else if ( type == "shrink" ) {
6239 // shrink factor is given as single floating point value
6240 if ( i+1 >= sizes.count() ) break; // format error
6241 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6245 else if ( type == "orientation" ) {
6246 // orientation vectors are specified by two values size:3d, where
6247 // - size - is a floating point value specifying scale factor
6248 // - 3d - is a boolean
6249 if ( i+1 >= sizes.count() ) break; // format error
6250 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6251 if ( i+2 >= sizes.count() ) break; // format error
6252 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6253 orientationSize = v1;
6254 orientation3d = (bool)v2;
6258 // line (wireframe) width
6259 if ( lineWidth > 0 )
6260 aSmeshActor->SetLineWidth( lineWidth );
6262 if ( outlineWidth > 0 )
6263 aSmeshActor->SetOutlineWidth( outlineWidth );
6264 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6265 aSmeshActor->SetOutlineWidth( lineWidth );
6267 if ( elem0dSize > 0 )
6268 aSmeshActor->Set0DSize( elem0dSize );
6271 aSmeshActor->SetBallSize( ballSize );
6273 if ( shrinkSize > 0 )
6274 aSmeshActor->SetShrinkFactor( shrinkSize );
6275 // orientation vectors
6276 if ( orientationSize > 0 ) {
6277 aSmeshActor->SetFacesOrientationScale( orientationSize );
6278 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6282 else if (paramNameStr == "PointMarker") {
6283 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6284 if( data.count() >= 2 ) {
6286 int aParam1 = data[1].toInt( &ok );
6288 if( data[0] == "std" && data.count() == 3 ) {
6289 int aParam2 = data[2].toInt( &ok );
6290 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6292 else if( data[0] == "custom" ) {
6293 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6294 if( markerIt != aMarkerMap.end() ) {
6295 VTK::MarkerData aMarkerData = markerIt->second;
6296 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6303 else if (paramNameStr == "Opacity") {
6304 aSmeshActor->SetOpacity(val.toFloat());
6307 else if (paramNameStr.startsWith("ClippingPlane")) {
6308 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6309 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
6310 // new format - val looks like "Off" or "0" (plane id)
6311 // (note: in new format "Off" value is used only for consistency,
6312 // so it is processed together with values in old format)
6313 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
6314 if( anIsOldFormat ) {
6315 if (paramNameStr == "ClippingPlane1" || val == "Off")
6316 aSmeshActor->RemoveAllClippingPlanes();
6318 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
6319 double aDistance = vals[1].toFloat();
6321 anAngle[0] = vals[2].toFloat();
6322 anAngle[1] = vals[3].toFloat();
6324 QList<SUIT_ViewManager*> lst;
6325 getApp()->viewManagers(viewerTypStr, lst);
6326 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6327 if (viewIndex >= 0 && viewIndex < lst.count()) {
6328 SUIT_ViewManager* vman = lst.at(viewIndex);
6329 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6331 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6333 SMESH::TActorList anActorList;
6334 anActorList.push_back( aSmeshActor );
6335 SMESH::OrientedPlane* aPlane =
6336 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
6338 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6339 aClippingPlaneInfo.Plane = aPlane;
6340 aClippingPlaneInfo.ActorList = anActorList;
6341 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6348 int aPlaneId = val.toInt( &ok );
6349 if( ok && aPlaneId >= 0 ) {
6350 bool anIsDefinedPlane = false;
6351 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6352 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6353 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6354 TPlaneInfo& aPlaneInfo = *anIter;
6355 if( aPlaneInfo.PlaneId == aPlaneId ) {
6356 aPlaneInfo.ActorList.push_back( aSmeshActor );
6357 anIsDefinedPlane = true;
6361 if( !anIsDefinedPlane ) {
6362 TPlaneInfo aPlaneInfo;
6363 aPlaneInfo.PlaneId = aPlaneId;
6364 aPlaneInfo.ActorList.push_back( aSmeshActor );
6365 aPlaneInfo.ViewManager = vman;
6367 // to make the list sorted by plane id
6368 anIter = aPlaneInfoList.begin();
6369 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6370 const TPlaneInfo& aPlaneInfoRef = *anIter;
6371 if( aPlaneInfoRef.PlaneId > aPlaneId )
6374 aPlaneInfoList.insert( anIter, aPlaneInfo );
6379 } // if (aSmeshActor)
6380 } // other parameters than Visibility
6382 } // for names/parameters iterator
6383 } // for entries iterator
6385 // take into account planes with empty list of actors referred to them
6386 QList<SUIT_ViewManager*> aVMList;
6387 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6389 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6390 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6391 int aViewId = aPlaneDataIter->first;
6392 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6393 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6395 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6397 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6398 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6399 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6400 const TPlaneData& aPlaneData = *anIter2;
6401 int aPlaneId = aPlaneData.Id;
6403 bool anIsFound = false;
6404 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6405 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6406 const TPlaneInfo& aPlaneInfo = *anIter3;
6407 if( aPlaneInfo.PlaneId == aPlaneId ) {
6414 TPlaneInfo aPlaneInfo; // ActorList field is empty
6415 aPlaneInfo.PlaneId = aPlaneId;
6416 aPlaneInfo.ViewManager = aViewManager;
6418 // to make the list sorted by plane id
6419 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6420 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6421 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6422 if( aPlaneInfoRef.PlaneId > aPlaneId )
6425 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6431 // add clipping planes to actors according to the restored parameters
6432 // and update the clipping plane map
6433 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6434 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6435 int aViewId = anIter1->first;
6436 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6438 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6439 if( anIter2 == aPlaneDataMap.end() )
6441 const TPlaneDataList& aPlaneDataList = anIter2->second;
6443 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6444 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6445 const TPlaneInfo& aPlaneInfo = *anIter3;
6446 int aPlaneId = aPlaneInfo.PlaneId;
6447 const TActorList& anActorList = aPlaneInfo.ActorList;
6448 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6452 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6456 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6458 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6459 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6460 const TPlaneData& aPlaneData = *anIter4;
6461 if( aPlaneData.Id == aPlaneId ) {
6462 SMESH::OrientedPlane* aPlane =
6463 SMESHGUI_ClippingDlg::AddPlane( anActorList,
6465 (SMESH::Orientation)aPlaneData.Orientation,
6466 aPlaneData.Distance,
6469 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6470 aClippingPlaneInfo.Plane = aPlane;
6471 aClippingPlaneInfo.ActorList = anActorList;
6472 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6480 // update all VTK views
6481 QList<SUIT_ViewManager*> lst;
6482 getApp()->viewManagers(lst);
6483 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6484 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6485 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6486 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6487 vtkView->getRenderer()->ResetCameraClippingRange();
6494 \brief Adds preferences for dfont of VTK viewer
6496 \param pIf group identifier
6497 \param param parameter
6498 \return identifier of preferences
6500 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6502 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6504 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6507 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6508 fam.append( tr( "SMESH_FONT_COURIER" ) );
6509 fam.append( tr( "SMESH_FONT_TIMES" ) );
6511 setPreferenceProperty( tfont, "fonts", fam );
6513 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6514 if ( needSize ) f = f | QtxFontEdit::Size;
6515 setPreferenceProperty( tfont, "features", f );
6521 \brief Actions after hypothesis edition
6522 Updates object browser after hypothesis edition
6524 void SMESHGUI::onHypothesisEdit( int result )
6527 SMESHGUI::Modified();
6528 updateObjBrowser( true );
6533 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6534 \param pview view being closed
6536 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6537 #ifndef DISABLE_PLOT2DVIEWER
6538 //Crear all Plot2d Viewers if need.
6539 SMESH::ClearPlot2Viewers(pview);
6543 void SMESHGUI::message( const QString& msg )
6546 QStringList data = msg.split("/");
6547 if ( data.count() > 0 ) {
6548 if ( data.first() == "mesh_loading" ) {
6550 QString entry = data.count() > 1 ? data[1] : QString();
6551 if ( entry.isEmpty() )
6554 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6556 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6559 name = obj->GetName().c_str();
6560 if ( name.isEmpty() )
6563 if ( data.last() == "stop" )
6564 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6566 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6567 QApplication::processEvents();
6573 \brief Connects or disconnects signals about activating and cloning view on the module slots
6574 \param pview view which is connected/disconnected
6576 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6580 SUIT_ViewManager* viewMgr = pview->getViewManager();
6582 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6583 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6585 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6586 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6591 \brief Return \c true if object can be renamed
6593 bool SMESHGUI::renameAllowed( const QString& entry) const {
6594 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6598 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6602 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6607 if(appStudy->isComponent(entry) || obj->isReference())
6610 // check type to prevent renaming of inappropriate objects
6611 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6612 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6613 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6614 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6615 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6616 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6623 Rename object by entry.
6624 \param entry entry of the object
6625 \param name new name of the object
6626 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6628 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6630 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6634 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6639 _PTR(Study) aStudy = appStudy->studyDS();
6644 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6646 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6651 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6652 _PTR(GenericAttribute) anAttr;
6653 _PTR(AttributeName) aName;
6655 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6657 // check type to prevent renaming of inappropriate objects
6658 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6659 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6660 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6661 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6662 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6663 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6664 if ( !name.isEmpty() ) {
6665 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6667 // update name of group object and its actor
6668 Handle(SALOME_InteractiveObject) IObject =
6669 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6671 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6672 if( !aGroupObject->_is_nil() ) {
6673 aGroupObject->SetName( qPrintable(name) );
6674 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6675 anActor->setName( qPrintable(name) );
6686 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6688 static QList<QColor> colors;
6690 if ( colors.isEmpty() ) {
6692 for (int s = 0; s < 2 ; s++)
6694 for (int v = 100; v >= 40; v = v - 20)
6696 for (int h = 0; h < 359 ; h = h + 60)
6698 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
6703 static int currentColor = 0;
6705 SALOMEDS::Color color;
6706 color.R = (double)colors[currentColor].red() / 255.0;
6707 color.G = (double)colors[currentColor].green() / 255.0;
6708 color.B = (double)colors[currentColor].blue() / 255.0;
6710 currentColor = (currentColor+1) % colors.count();