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( toCreateGroups, 0 );
690 fd->SetChecked( toFindOutDim, 1 );
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_SplitVolumesDlg(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 info = createTool( tr( "TB_INFO" ) ),
4049 groupTb = createTool( tr( "TB_GROUP" ) ),
4050 ctrl0dTb = createTool( tr( "TB_CTRL0D" ) ),
4051 ctrl1dTb = createTool( tr( "TB_CTRL1D" ) ),
4052 ctrl2dTb = createTool( tr( "TB_CTRL2D" ) ),
4053 ctrl3dTb = createTool( tr( "TB_CTRL3D" ) ),
4054 addElemTb = createTool( tr( "TB_ADD" ) ),
4055 addNonElemTb = createTool( tr( "TB_ADDNON" ) ),
4056 remTb = createTool( tr( "TB_REM" ) ),
4057 renumbTb = createTool( tr( "TB_RENUMBER" ) ),
4058 transformTb = createTool( tr( "TB_TRANSFORM" ) ),
4059 modifyTb = createTool( tr( "TB_MODIFY" ) ),
4060 measuremTb = createTool( tr( "TB_MEASUREM" ) ),
4061 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
4063 createTool( 702, meshTb );
4064 createTool( 703, meshTb );
4065 createTool( 704, meshTb );
4066 createTool( 710, meshTb );
4067 createTool( 705, meshTb );
4068 createTool( separator(), meshTb );
4069 createTool( 701, meshTb );
4070 createTool( 711, meshTb );
4071 createTool( 712, meshTb );
4072 createTool( 713, meshTb );
4074 createTool( 801, groupTb );
4075 createTool( 806, groupTb );
4076 createTool( 802, groupTb );
4077 createTool( 803, groupTb );
4079 createTool( 900, info );
4080 //createTool( 902, meshTb );
4081 //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4082 createTool( 904, info );
4084 createTool( 6005, ctrl0dTb );
4085 createTool( 6028, ctrl0dTb );
4087 createTool( 6002, ctrl1dTb );
4088 createTool( 6003, ctrl1dTb );
4089 createTool( 6001, ctrl1dTb );
4090 createTool( 6004, ctrl1dTb );
4091 createTool( 6029, ctrl1dTb );
4093 createTool( 6021, ctrl2dTb );
4094 createTool( 6025, ctrl2dTb );
4095 createTool( 6027, ctrl2dTb );
4096 createTool( 6018, ctrl2dTb );
4097 createTool( 6019, ctrl2dTb );
4098 createTool( 6011, ctrl2dTb );
4099 createTool( 6012, ctrl2dTb );
4100 createTool( 6013, ctrl2dTb );
4101 createTool( 6014, ctrl2dTb );
4102 createTool( 6015, ctrl2dTb );
4103 createTool( 6016, ctrl2dTb );
4104 createTool( 6022, ctrl2dTb );
4105 createTool( 6030, ctrl2dTb );
4107 createTool( 6017, ctrl3dTb );
4108 createTool( 6009, ctrl3dTb );
4109 createTool( 6023, ctrl3dTb );
4110 createTool( 6024, ctrl3dTb );
4111 createTool( 6026, ctrl3dTb );
4112 createTool( 6031, ctrl3dTb );
4114 createTool( 4000, addElemTb );
4115 createTool( 4009, addElemTb );
4116 createTool( 4070, addElemTb );
4117 createTool( 4008, addElemTb );
4118 createTool( 4010, addElemTb );
4119 createTool( 4021, addElemTb );
4120 createTool( 4022, addElemTb );
4121 createTool( 4023, addElemTb );
4122 createTool( 4031, addElemTb );
4123 createTool( 4032, addElemTb );
4124 createTool( 4133, addElemTb );
4125 createTool( 4134, addElemTb );
4126 createTool( 4135, addElemTb );
4127 createTool( 4033, addElemTb );
4129 createTool( 4034, addNonElemTb );
4130 createTool( 4035, addNonElemTb );
4131 createTool( 4137, addNonElemTb );
4132 createTool( 4036, addNonElemTb );
4133 createTool( 4136, addNonElemTb );
4134 createTool( 4037, addNonElemTb );
4135 createTool( 4038, addNonElemTb );
4136 createTool( 4039, addNonElemTb );
4137 createTool( 4040, addNonElemTb );
4138 createTool( 4140, addNonElemTb );
4140 createTool( 4041, remTb );
4141 createTool( 4042, remTb );
4142 createTool( 4044, remTb );
4143 createTool( 4043, remTb );
4145 createTool( 4051, renumbTb );
4146 createTool( 4052, renumbTb );
4149 createTool( 4061, transformTb );
4150 createTool( 4062, transformTb );
4151 createTool( 4063, transformTb );
4152 createTool( 4068, transformTb );
4153 createTool( 4064, transformTb );
4154 createTool( 4065, transformTb );
4155 createTool( 4066, transformTb );
4156 createTool( 4069, transformTb );
4158 createTool( 4067,modifyTb );
4159 createTool( 407, modifyTb );
4160 createTool( 408, modifyTb );
4161 createTool( 409, modifyTb );
4162 createTool( 420, modifyTb );
4163 createTool( 410, modifyTb );
4164 createTool( 411, modifyTb );
4165 createTool( 419, modifyTb );
4166 createTool( 412, modifyTb );
4167 createTool( 413, modifyTb );
4168 createTool( 416, modifyTb );
4169 createTool( 414, modifyTb );
4170 createTool( 415, modifyTb );
4171 createTool( 417, modifyTb );
4172 createTool( 418, modifyTb );
4174 createTool( 501, measuremTb );
4176 createTool( 214, dispModeTb );
4178 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4179 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4182 QString OB = "'ObjectBrowser'",
4183 View = "'" + SVTK_Viewer::Type() + "'",
4185 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4186 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4187 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4188 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4189 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4190 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4191 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4192 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4193 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4194 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4195 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4197 mesh_part = mesh + " " + subMesh + " " + group,
4198 mesh_group = mesh + " " + group,
4199 hyp_alg = hypo + " " + algo;
4201 // popup for object browser
4203 isInvisible("not( isVisible )"),
4204 isEmpty("numberOfNodes = 0"),
4205 isNotEmpty("numberOfNodes <> 0"),
4207 // has nodes, edges, etc in VISIBLE! actor
4208 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4209 hasElems("(count( elemTypes ) > 0)"),
4210 hasDifferentElems("(count( elemTypes ) > 1)"),
4211 hasBalls("({'BallElem'} in elemTypes)"),
4212 hasElems0d("({'Elem0d'} in elemTypes)"),
4213 hasEdges("({'Edge'} in elemTypes)"),
4214 hasFaces("({'Face'} in elemTypes)"),
4215 hasVolumes("({'Volume'} in elemTypes)");
4217 createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
4218 createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
4219 createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
4220 createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
4221 createPopupItem( 803, OB, group ); // EDIT_GROUP
4222 createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
4224 popupMgr()->insert( separator(), -1, 0 );
4225 createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
4226 createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
4227 createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
4228 createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
4229 createPopupItem( 214, OB, mesh_part ); // UPDATE
4230 createPopupItem( 900, OB, mesh_part ); // ADV_INFO
4231 createPopupItem( 904, OB, mesh_group ); // FIND_ELEM
4232 createPopupItem( 6032, OB, mesh_part ); // CTRL_INFO
4233 popupMgr()->insert( separator(), -1, 0 );
4234 createPopupItem( 801, OB, mesh ); // CREATE_GROUP
4235 createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
4236 createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
4237 popupMgr()->insert( separator(), -1, 0 );
4238 createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
4239 createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4240 popupMgr()->insert( separator(), -1, 0 );
4241 createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
4242 popupMgr()->insert( separator(), -1, 0 );
4243 createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
4244 createPopupItem( 418, OB, mesh + " " + group, // create 2D mesh from 3D
4246 popupMgr()->insert( separator(), -1, 0 );
4248 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4249 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4250 QString only_one_2D = only_one_non_empty + " && dim>1";
4252 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4253 createPopupItem( 125, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_MED
4254 createPopupItem( 126, OB, mesh_group, only_one_non_empty, anId ); // EXPORT_UNV
4255 createPopupItem( 141, OB, mesh_group, only_one_2D, anId ); // EXPORT_STL
4257 createPopupItem( 143, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_CGNS
4259 createPopupItem( 145, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_SAUV
4260 createPopupItem( 147, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_GMF
4261 createPopupItem( 124, OB, mesh_group, multiple_non_empty, anId ); // EXPORT_DAT
4262 createPopupItem( 33, OB, mesh_part + " " + hyp_alg ); // DELETE
4263 createPopupItem( 813, OB, group ); // DEL_GROUP with contents
4264 popupMgr()->insert( separator(), -1, 0 );
4267 createPopupItem( 803, View, group ); // EDIT_GROUP
4268 createPopupItem( 804, View, elems ); // ADD
4269 createPopupItem( 805, View, elems ); // REMOVE
4271 popupMgr()->insert( separator(), -1, 0 );
4272 createPopupItem( 214, View, mesh_part ); // UPDATE
4273 createPopupItem( 900, View, mesh_part ); // ADV_INFO
4274 createPopupItem( 6032,View, mesh_part ); // CTRL_INFO
4275 createPopupItem( 904, View, mesh ); // FIND_ELEM
4276 popupMgr()->insert( separator(), -1, 0 );
4278 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
4279 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
4280 popupMgr()->insert( separator(), -1, 0 );
4282 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4283 QString aType = QString( "%1type in {%2}" ).arg( lc );
4284 aType = aType.arg( mesh_part );
4285 QString aMeshInVTK = aClient + "&&" + aType;
4287 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4288 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4289 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4291 //-------------------------------------------------
4293 //-------------------------------------------------
4294 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4296 popupMgr()->insert( action( 9010 ), anId, -1 );
4297 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4298 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4300 popupMgr()->insert( action( 9011 ), anId, -1 );
4301 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4302 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4304 popupMgr()->insert( separator(), -1, -1 );
4306 //-------------------------------------------------
4308 //-------------------------------------------------
4309 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4311 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4312 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4313 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4315 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4316 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4317 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4319 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4320 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4321 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4323 popupMgr()->insert( separator(), anId, -1 );
4325 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4326 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4327 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4329 //-------------------------------------------------
4331 //-------------------------------------------------
4332 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4334 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4336 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4337 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4338 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4340 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4341 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4342 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4344 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4345 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4346 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4348 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4349 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4350 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4352 popupMgr()->insert( action( 222 ), anId, -1 ); // BALLS
4353 popupMgr()->setRule( action( 222 ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4354 popupMgr()->setRule( action( 222 ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4356 popupMgr()->insert( separator(), anId, -1 );
4358 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4359 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4362 //-------------------------------------------------
4363 // Representation of the 2D Quadratic elements
4364 //-------------------------------------------------
4365 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4366 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4367 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4368 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4370 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4371 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4372 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4374 //-------------------------------------------------
4375 // Orientation of faces
4376 //-------------------------------------------------
4377 popupMgr()->insert( action( 221 ), -1, -1 );
4378 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4379 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4381 //-------------------------------------------------
4383 //-------------------------------------------------
4384 popupMgr()->insert( action( 1132 ), -1, -1 );
4385 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4387 //-------------------------------------------------
4389 //-------------------------------------------------
4390 popupMgr()->insert( action( 1133 ), -1, -1 );
4391 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4393 //-------------------------------------------------
4395 //-------------------------------------------------
4397 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4398 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4399 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4400 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4402 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4404 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4405 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4407 popupMgr()->insert( separator(), anId, -1 );
4409 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4411 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4412 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4413 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4415 popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4416 popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4417 popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4419 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4421 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4422 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4423 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4425 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4426 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4427 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4429 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4430 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4431 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4433 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4434 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4435 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4436 popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4437 popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4438 popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4440 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4442 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4443 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4444 QtxPopupMgr::VisibleRule );
4445 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4447 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4448 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4449 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4451 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4452 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4453 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4455 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4456 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4457 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4459 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4460 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4461 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4463 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4464 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4465 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4467 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4468 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4469 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4471 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4472 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4473 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4475 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4476 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4477 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4479 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4480 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4481 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4483 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4484 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4485 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4487 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4488 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4489 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4490 popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4491 popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4492 popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4494 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4496 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4497 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4498 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4500 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4501 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4502 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4504 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4505 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4506 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4508 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4509 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4510 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4512 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4513 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4514 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4516 popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4517 popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4518 popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4520 popupMgr()->insert( separator(), anId, -1 );
4522 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4523 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4525 popupMgr()->insert( separator(), anId, -1 );
4527 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4529 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4530 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4532 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4533 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4534 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4536 #ifndef DISABLE_PLOT2DVIEWER
4537 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4538 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4541 //-------------------------------------------------
4543 //-------------------------------------------------
4544 popupMgr()->insert( separator(), -1, -1 );
4545 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4546 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4547 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4548 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4550 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4551 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4553 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4554 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4556 popupMgr()->insert( separator(), -1, -1 );
4558 //-------------------------------------------------
4560 //-------------------------------------------------
4561 popupMgr()->insert( action( 1134 ), -1, -1 );
4562 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4564 popupMgr()->insert( separator(), -1, -1 );
4566 popupMgr()->insert( action( 41 ), -1, -1 );
4567 popupMgr()->setRule( action( 41 ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4568 popupMgr()->insert( separator(), -1, -1 );
4570 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4571 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4573 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4574 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4577 //================================================================================
4579 * \brief Return true if SMESH or GEOM objects are selected.
4580 * Is called form LightApp_Module::activateModule() which clear selection if
4581 * not isSelectionCompatible()
4583 //================================================================================
4585 bool SMESHGUI::isSelectionCompatible()
4587 bool isCompatible = true;
4588 SALOME_ListIO selected;
4589 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4590 Sel->selectedObjects( selected );
4592 SALOME_ListIteratorOfListIO It( selected );
4593 for ( ; isCompatible && It.More(); It.Next())
4595 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4596 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4598 return isCompatible;
4602 bool SMESHGUI::reusableOperation( const int id )
4604 // compute, evaluate and precompute are not reusable operations
4605 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4608 bool SMESHGUI::activateModule( SUIT_Study* study )
4610 bool res = SalomeApp_Module::activateModule( study );
4612 setMenuShown( true );
4613 setToolShown( true );
4615 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4616 PyGILState_STATE gstate = PyGILState_Ensure();
4617 PyObjWrapper pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4618 if ( !pluginsmanager ) {
4622 PyObjWrapper result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4626 PyGILState_Release(gstate);
4627 // end of SMESH plugins loading
4629 // Reset actions accelerator keys
4630 //action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4631 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4632 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4634 action( 33)->setEnabled(true); // Delete: Key_Delete
4636 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4637 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4638 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4639 if ( _PTR(Study) aStudy = s->studyDS()) {
4640 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4641 updateObjBrowser(); // objects can be removed
4644 // get all view currently opened in the study and connect their signals to
4645 // the corresponding slots of the class.
4646 SUIT_Desktop* aDesk = study->application()->desktop();
4648 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4649 SUIT_ViewWindow* wnd;
4650 foreach ( wnd, wndList )
4657 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4659 setMenuShown( false );
4660 setToolShown( false );
4662 EmitSignalCloseAllDialogs();
4664 // Unset actions accelerator keys
4665 //action(111)->setShortcut(QKeySequence()); // Import DAT
4666 action(112)->setShortcut(QKeySequence()); // Import UNV
4667 action(113)->setShortcut(QKeySequence()); // Import MED
4669 action( 33)->setEnabled(false); // Delete: Key_Delete
4671 return SalomeApp_Module::deactivateModule( study );
4674 void SMESHGUI::studyClosed( SUIT_Study* s )
4676 SMESH::RemoveVisuData( s->id() );
4677 SalomeApp_Module::studyClosed( s );
4680 void SMESHGUI::OnGUIEvent()
4682 const QObject* obj = sender();
4683 if ( !obj || !obj->inherits( "QAction" ) )
4685 int id = actionId((QAction*)obj);
4690 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4692 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4693 if ( CORBA::is_nil( myComponentSMESH ) )
4695 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4697 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4698 return aGUI.myComponentSMESH;
4701 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4702 return myComponentSMESH;
4705 QString SMESHGUI::engineIOR() const
4707 CORBA::ORB_var anORB = getApp()->orb();
4708 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4709 return QString( anIOR.in() );
4712 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4714 SalomeApp_Module::contextMenuPopup( client, menu, title );
4716 selectionMgr()->selectedObjects( lst );
4717 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4718 Handle(SALOME_InteractiveObject) io = lst.First();
4719 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4720 _PTR(Study) study = appStudy->studyDS();
4721 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4723 QString aName = QString( obj->GetName().c_str() );
4724 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4725 aName.remove( (aName.length() - 1), 1 );
4731 LightApp_Selection* SMESHGUI::createSelection() const
4733 return new SMESHGUI_Selection();
4736 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4738 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4739 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4742 void SMESHGUI::viewManagers( QStringList& list ) const
4744 list.append( SVTK_Viewer::Type() );
4747 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4749 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4750 SMESH::UpdateSelectionProp( this );
4752 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4753 for(int i = 0; i < aViews.count() ; i++){
4754 SUIT_ViewWindow *sf = aViews[i];
4760 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4762 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4763 myClippingPlaneInfoMap.erase( theViewManager );
4766 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4768 theActor->AddObserver( SMESH::DeleteActorEvent,
4769 myEventCallbackCommand.GetPointer(),
4773 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4774 unsigned long theEvent,
4775 void* theClientData,
4778 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4779 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4780 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4781 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4782 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4783 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4784 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4785 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4786 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4787 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4788 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4789 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4790 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4791 if( anActor == *anIter3 ) {
4792 anActorList.erase( anIter3 );
4803 void SMESHGUI::createPreferences()
4805 // General tab ------------------------------------------------------------------------
4806 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4808 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4809 setPreferenceProperty( autoUpdate, "columns", 2 );
4810 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4811 setPreferenceProperty( lim, "min", 0 );
4812 setPreferenceProperty( lim, "max", 100000000 );
4813 setPreferenceProperty( lim, "step", 1000 );
4814 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4815 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4817 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4818 setPreferenceProperty( qaGroup, "columns", 2 );
4819 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4820 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4821 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4822 setPreferenceProperty( prec, "min", 0 );
4823 setPreferenceProperty( prec, "max", 16 );
4824 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4825 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4826 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4827 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4828 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4830 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4831 setPreferenceProperty( dispgroup, "columns", 2 );
4832 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4834 modes.append( tr("MEN_WIRE") );
4835 modes.append( tr("MEN_SHADE") );
4836 modes.append( tr("MEN_NODES") );
4837 modes.append( tr("MEN_SHRINK") );
4838 QList<QVariant> indices;
4839 indices.append( 0 );
4840 indices.append( 1 );
4841 indices.append( 2 );
4842 indices.append( 3 );
4843 setPreferenceProperty( dispmode, "strings", modes );
4844 setPreferenceProperty( dispmode, "indexes", indices );
4846 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4847 setPreferenceProperty( arcgroup, "columns", 2 );
4848 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4849 QStringList quadraticModes;
4850 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4851 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4853 indices.append( 0 );
4854 indices.append( 1 );
4855 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4856 setPreferenceProperty( quadraticmode, "indexes", indices );
4858 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4859 "SMESH", "max_angle" );
4860 setPreferenceProperty( maxAngle, "min", 1 );
4861 setPreferenceProperty( maxAngle, "max", 90 );
4865 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4866 setPreferenceProperty( exportgroup, "columns", 2 );
4867 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4868 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4870 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4871 setPreferenceProperty( computeGroup, "columns", 2 );
4872 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4874 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4875 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4876 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4878 indices.append( 0 );
4879 indices.append( 1 );
4880 indices.append( 2 );
4881 setPreferenceProperty( notifyMode, "strings", modes );
4882 setPreferenceProperty( notifyMode, "indexes", indices );
4884 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4885 setPreferenceProperty( infoGroup, "columns", 2 );
4886 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4888 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4889 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4891 indices.append( 0 );
4892 indices.append( 1 );
4893 setPreferenceProperty( elemInfo, "strings", modes );
4894 setPreferenceProperty( elemInfo, "indexes", indices );
4895 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4896 setPreferenceProperty( nodesLim, "min", 0 );
4897 setPreferenceProperty( nodesLim, "max", 10000000 );
4898 setPreferenceProperty( nodesLim, "step", 10000 );
4899 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4900 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
4901 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4902 setPreferenceProperty( ctrlLim, "min", 0 );
4903 setPreferenceProperty( ctrlLim, "max", 10000000 );
4904 setPreferenceProperty( ctrlLim, "step", 1000 );
4905 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
4906 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
4907 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
4908 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
4909 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
4911 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4912 setPreferenceProperty( segGroup, "columns", 2 );
4913 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4914 "SMESH", "segmentation" );
4915 setPreferenceProperty( segLen, "min", 1 );
4916 setPreferenceProperty( segLen, "max", 10000000 );
4917 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4918 "SMESH", "nb_segments_per_edge" );
4919 setPreferenceProperty( nbSeg, "min", 1 );
4920 setPreferenceProperty( nbSeg, "max", 10000000 );
4922 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4923 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4924 "SMESH", "forget_mesh_on_hyp_modif" );
4927 // Quantities with individual precision settings
4928 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4929 setPreferenceProperty( precGroup, "columns", 2 );
4931 const int nbQuantities = 6;
4932 int precs[nbQuantities], ii = 0;
4933 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4934 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4935 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4936 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4937 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4938 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4939 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4940 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4941 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4942 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4943 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4944 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4946 // Set property for precision value for spinboxes
4947 for ( ii = 0; ii < nbQuantities; ii++ ){
4948 setPreferenceProperty( precs[ii], "min", -14 );
4949 setPreferenceProperty( precs[ii], "max", 14 );
4950 setPreferenceProperty( precs[ii], "precision", 2 );
4953 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4954 setPreferenceProperty( previewGroup, "columns", 2 );
4955 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4956 setPreferenceProperty( chunkSize, "min", 1 );
4957 setPreferenceProperty( chunkSize, "max", 1000 );
4958 setPreferenceProperty( chunkSize, "step", 50 );
4960 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4961 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4963 // Mesh tab ------------------------------------------------------------------------
4964 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4965 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4966 setPreferenceProperty( nodeGroup, "columns", 3 );
4968 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4970 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4972 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4973 QList<QVariant> aMarkerTypeIndicesList;
4974 QList<QVariant> aMarkerTypeIconsList;
4975 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4976 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4977 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4978 aMarkerTypeIndicesList << i;
4979 aMarkerTypeIconsList << pixmap;
4981 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4982 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4984 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4986 QList<QVariant> aMarkerScaleIndicesList;
4987 QStringList aMarkerScaleValuesList;
4988 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4989 aMarkerScaleIndicesList << i;
4990 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4992 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4993 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4995 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4996 //setPreferenceProperty( elemGroup, "columns", 2 );
4998 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4999 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5000 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5001 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5002 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5003 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5004 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5005 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5006 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5009 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5010 setPreferenceProperty( grpGroup, "columns", 2 );
5012 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5013 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5015 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5016 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5017 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5018 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
5019 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5020 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5021 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5022 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5023 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5024 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5026 setPreferenceProperty( size0d, "min", 1 );
5027 setPreferenceProperty( size0d, "max", 10 );
5029 setPreferenceProperty( ballSize, "min", 1 );
5030 setPreferenceProperty( ballSize, "max", 10 );
5032 setPreferenceProperty( elemW, "min", 1 );
5033 setPreferenceProperty( elemW, "max", 5 );
5035 setPreferenceProperty( outW, "min", 1 );
5036 setPreferenceProperty( outW, "max", 5 );
5038 setPreferenceProperty( shrink, "min", 0 );
5039 setPreferenceProperty( shrink, "max", 100 );
5041 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5042 setPreferenceProperty( numGroup, "columns", 2 );
5044 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5045 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5047 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5048 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5050 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5051 setPreferenceProperty( orientGroup, "columns", 1 );
5053 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5054 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5056 setPreferenceProperty( orientScale, "min", 0.05 );
5057 setPreferenceProperty( orientScale, "max", 0.5 );
5058 setPreferenceProperty( orientScale, "step", 0.05 );
5060 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5062 // Selection tab ------------------------------------------------------------------------
5063 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5065 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5066 setPreferenceProperty( selGroup, "columns", 2 );
5068 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5069 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5071 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5072 setPreferenceProperty( preGroup, "columns", 2 );
5074 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5076 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5077 setPreferenceProperty( precSelGroup, "columns", 2 );
5079 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5080 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5081 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5083 // Scalar Bar tab ------------------------------------------------------------------------
5084 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5085 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5086 setPreferenceProperty( fontGr, "columns", 2 );
5088 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5089 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5091 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5092 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5094 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5095 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5097 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5098 setPreferenceProperty( numcol, "min", 2 );
5099 setPreferenceProperty( numcol, "max", 256 );
5101 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5102 setPreferenceProperty( numlab, "min", 2 );
5103 setPreferenceProperty( numlab, "max", 65 );
5105 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5106 setPreferenceProperty( orientGr, "columns", 2 );
5107 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5108 QStringList orients;
5109 orients.append( tr( "SMESH_VERTICAL" ) );
5110 orients.append( tr( "SMESH_HORIZONTAL" ) );
5111 indices.clear(); indices.append( 0 ); indices.append( 1 );
5112 setPreferenceProperty( orient, "strings", orients );
5113 setPreferenceProperty( orient, "indexes", indices );
5115 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5116 setPreferenceProperty( posVSizeGr, "columns", 2 );
5117 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5118 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5119 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5120 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5121 setPreferenceProperty( xv, "step", 0.1 );
5122 setPreferenceProperty( xv, "min", 0.0 );
5123 setPreferenceProperty( xv, "max", 1.0 );
5124 setPreferenceProperty( yv, "step", 0.1 );
5125 setPreferenceProperty( yv, "min", 0.0 );
5126 setPreferenceProperty( yv, "max", 1.0 );
5127 setPreferenceProperty( wv, "step", 0.1 );
5128 setPreferenceProperty( wv, "min", 0.0 );
5129 setPreferenceProperty( wv, "max", 1.0 );
5130 setPreferenceProperty( hv, "min", 0.0 );
5131 setPreferenceProperty( hv, "max", 1.0 );
5132 setPreferenceProperty( hv, "step", 0.1 );
5134 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5135 setPreferenceProperty( posHSizeGr, "columns", 2 );
5136 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5137 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5138 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5139 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5140 setPreferenceProperty( xv, "min", 0.0 );
5141 setPreferenceProperty( xv, "max", 1.0 );
5142 setPreferenceProperty( xv, "step", 0.1 );
5143 setPreferenceProperty( xh, "min", 0.0 );
5144 setPreferenceProperty( xh, "max", 1.0 );
5145 setPreferenceProperty( xh, "step", 0.1 );
5146 setPreferenceProperty( yh, "min", 0.0 );
5147 setPreferenceProperty( yh, "max", 1.0 );
5148 setPreferenceProperty( yh, "step", 0.1 );
5149 setPreferenceProperty( wh, "min", 0.0 );
5150 setPreferenceProperty( wh, "max", 1.0 );
5151 setPreferenceProperty( wh, "step", 0.1 );
5152 setPreferenceProperty( hh, "min", 0.0 );
5153 setPreferenceProperty( hh, "max", 1.0 );
5154 setPreferenceProperty( hh, "step", 0.1 );
5156 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5157 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5158 setPreferenceProperty( distributionGr, "columns", 3 );
5160 types.append( tr( "SMESH_MONOCOLOR" ) );
5161 types.append( tr( "SMESH_MULTICOLOR" ) );
5162 indices.clear(); indices.append( 0 ); indices.append( 1 );
5163 setPreferenceProperty( coloringType, "strings", types );
5164 setPreferenceProperty( coloringType, "indexes", indices );
5165 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5169 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5171 if( sect=="SMESH" ) {
5172 float sbX1,sbY1,sbW,sbH;
5173 float aTol = 1.00000009999999;
5174 std::string aWarning;
5175 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5176 if( name=="selection_object_color" || name=="selection_element_color" ||
5177 name=="highlight_color" ||
5178 name=="selection_precision_node" || name=="selection_precision_element" ||
5179 name=="selection_precision_object")
5180 SMESH::UpdateSelectionProp( this );
5181 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5182 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5183 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5184 if(sbX1+sbW > aTol){
5185 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5188 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5189 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5192 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5193 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5194 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5195 if(sbY1+sbH > aTol){
5196 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5197 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5198 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5201 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5202 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5203 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5204 if(sbX1+sbW > aTol){
5205 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5208 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5209 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5212 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5213 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5214 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5215 if(sbY1+sbH > aTol){
5216 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5219 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5220 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5223 else if ( name == "segmentation" ) {
5224 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5225 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5227 else if ( name == "nb_segments_per_edge" ) {
5228 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5229 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5231 else if ( name == "historical_python_dump" ||
5232 name == "forget_mesh_on_hyp_modif") {
5233 QString val = aResourceMgr->stringValue( "SMESH", name );
5234 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5236 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5237 SMESH::UpdateFontProp( this );
5239 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5240 SMESH::UpdateFontProp( this );
5243 if(aWarning.size() != 0){
5244 aWarning += "The default values are applied instead.";
5245 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5246 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5247 QObject::tr(aWarning.c_str()));
5252 //================================================================================
5254 * \brief Update something in accordance with update flags
5255 * \param theFlags - update flags
5257 * Update viewer or/and object browser etc. in accordance with update flags ( see
5258 * LightApp_UpdateFlags enumeration ).
5260 //================================================================================
5261 void SMESHGUI::update( const int flags )
5263 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5264 SMESH::UpdateView();
5266 SalomeApp_Module::update( flags );
5269 //================================================================================
5271 * \brief Set default selection mode
5273 * SLOT called when operation commited. Sets default selection mode
5275 //================================================================================
5276 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5278 SVTK_ViewWindow* vtkWnd =
5279 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5281 vtkWnd->SetSelectionMode( ActorSelection );
5284 //================================================================================
5286 * \brief Set default selection mode
5288 * SLOT called when operation aborted. Sets default selection mode
5290 //================================================================================
5291 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5293 SVTK_ViewWindow* vtkWnd =
5294 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5296 vtkWnd->SetSelectionMode( ActorSelection );
5299 //================================================================================
5301 * \brief Creates operation with given identifier
5302 * \param id - identifier of operation to be started
5303 * \return Pointer on created operation or NULL if operation is not created
5305 * Virtual method redefined from the base class creates operation with given id.
5306 * It is called called automatically from startOperation method of base class.
5308 //================================================================================
5309 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5311 LightApp_Operation* op = 0;
5312 // to do : create operation here
5315 case 417: //convert to quadratic
5316 op = new SMESHGUI_ConvToQuadOp();
5318 case 418: // create 2D mesh as boundary on 3D
5319 op = new SMESHGUI_Make2DFrom3DOp();
5321 case 420: // Reorient faces
5322 op = new SMESHGUI_ReorientFacesOp();
5324 case 701: // Compute mesh
5325 op = new SMESHGUI_ComputeOp();
5327 case 702: // Create mesh
5328 op = new SMESHGUI_MeshOp( true, true );
5330 case 703: // Create sub-mesh
5331 op = new SMESHGUI_MeshOp( true, false );
5333 case 704: // Edit mesh/sub-mesh
5334 op = new SMESHGUI_MeshOp( false );
5336 case 711: // Precompute mesh
5337 op = new SMESHGUI_PrecomputeOp();
5339 case 712: // Evaluate mesh
5340 op = new SMESHGUI_EvaluateOp();
5342 case 713: // Evaluate mesh
5343 op = new SMESHGUI_MeshOrderOp();
5345 case 806: // Create group on geom
5346 op = new SMESHGUI_GroupOnShapeOp();
5348 case 904: // Find element
5349 op = new SMESHGUI_FindElemByPointOp();
5351 case 4067: // Make mesh pass through point
5352 op = new SMESHGUI_MakeNodeAtPointOp();
5354 case 4070: // Create 0D elements on all nodes
5355 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5362 op = SalomeApp_Module::createOperation( id );
5366 //================================================================================
5368 * \brief Stops current operations and starts a given one
5369 * \param id - The id of the operation to start
5371 //================================================================================
5373 void SMESHGUI::switchToOperation(int id)
5375 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5376 activeStudy()->abortAllOperations();
5377 startOperation( id );
5380 LightApp_Displayer* SMESHGUI::displayer()
5383 myDisplayer = new SMESHGUI_Displayer( getApp() );
5387 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5390 int aTolerance = 64;
5391 int anIterations = 0;
5397 if( anIterations % aPeriod == 0 )
5400 if( aTolerance < 1 )
5404 aHue = (int)( 360.0 * rand() / RAND_MAX );
5407 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5408 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5409 for( ; it != itEnd; ++it )
5411 SALOMEDS::Color anAutoColor = *it;
5412 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5415 aQColor.getHsv( &h, &s, &v );
5416 if( abs( h - aHue ) < aTolerance )
5428 aColor.setHsv( aHue, 255, 255 );
5430 SALOMEDS::Color aSColor;
5431 aSColor.R = aColor.redF();
5432 aSColor.G = aColor.greenF();
5433 aSColor.B = aColor.blueF();
5438 const char* gSeparator = "_"; // character used to separate parameter names
5439 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5440 const char* gPathSep = "|"; // character used to separate paths
5443 * \brief Store visual parameters
5445 * This method is called just before the study document is saved.
5446 * Store visual parameters in AttributeParameter attribue(s)
5448 void SMESHGUI::storeVisualParameters (int savePoint)
5451 Kernel_Utils::Localizer loc;
5453 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5454 if (!appStudy || !appStudy->studyDS())
5456 _PTR(Study) studyDS = appStudy->studyDS();
5458 // componentName is used for encoding of entries when storing them in IParameters
5459 std::string componentName = myComponentSMESH->ComponentDataType();
5460 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5461 //if (!aSComponent) return;
5464 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5465 componentName.c_str(),
5467 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5469 // store map of custom markers
5470 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5471 if( !aMarkerMap.empty() )
5473 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5474 for( ; anIter != aMarkerMap.end(); anIter++ )
5476 int anId = anIter->first;
5477 VTK::MarkerData aMarkerData = anIter->second;
5478 std::string aMarkerFileName = aMarkerData.first;
5479 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5480 if( aMarkerTexture.size() < 3 )
5481 continue; // should contain at least width, height and the first value
5483 QString aPropertyName( "texture" );
5484 aPropertyName += gSeparator;
5485 aPropertyName += QString::number( anId );
5487 QString aPropertyValue = aMarkerFileName.c_str();
5488 aPropertyValue += gPathSep;
5490 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5491 ushort aWidth = *aTextureIter++;
5492 ushort aHeight = *aTextureIter++;
5493 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5494 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5495 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5496 aPropertyValue += QString::number( *aTextureIter );
5498 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5502 // viewers counters are used for storing view_numbers in IParameters
5505 // main cycle to store parameters of displayed objects
5506 QList<SUIT_ViewManager*> lst;
5507 QList<SUIT_ViewManager*>::Iterator it;
5508 getApp()->viewManagers(lst);
5509 for (it = lst.begin(); it != lst.end(); it++)
5511 SUIT_ViewManager* vman = *it;
5512 QString vType = vman->getType();
5514 // saving VTK actors properties
5515 if (vType == SVTK_Viewer::Type())
5517 // store the clipping planes attached to the view manager
5518 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5519 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5520 if( anIter != myClippingPlaneInfoMap.end() )
5521 aClippingPlaneInfoList = anIter->second;
5523 if( !aClippingPlaneInfoList.empty() ) {
5524 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5525 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5527 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5528 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5530 QString aPropertyName( "ClippingPlane" );
5531 aPropertyName += gSeparator;
5532 aPropertyName += QString::number( vtkViewers );
5533 aPropertyName += gSeparator;
5534 aPropertyName += QString::number( anId );
5536 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5537 aPropertyValue += gDigitsSep;
5538 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5539 aPropertyValue += gDigitsSep;
5540 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5541 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5542 aPropertyValue += gDigitsSep;
5543 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5544 aPropertyValue += gDigitsSep;
5545 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5546 aPropertyValue += gDigitsSep;
5547 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5548 aPropertyValue += gDigitsSep;
5549 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5550 aPropertyValue += gDigitsSep;
5551 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5552 aPropertyValue += gDigitsSep;
5553 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5555 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5556 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5557 aPropertyValue += gDigitsSep;
5558 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5559 aPropertyValue += gDigitsSep;
5560 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5561 aPropertyValue += gDigitsSep;
5562 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5565 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5569 QVector<SUIT_ViewWindow*> views = vman->getViews();
5570 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5572 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5574 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5575 vtkActorCollection* allActors = aCopy.GetActors();
5576 allActors->InitTraversal();
5577 while (vtkActor* actor = allActors->GetNextActor())
5579 if (actor->GetVisibility()) // store only visible actors
5581 SMESH_Actor* aSmeshActor = 0;
5582 if (actor->IsA("SMESH_Actor"))
5583 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5584 if (aSmeshActor && aSmeshActor->hasIO())
5586 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5589 // entry is "encoded" = it does NOT contain component adress,
5590 // since it is a subject to change on next component loading
5591 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5593 std::string param, vtkParam = vType.toLatin1().data();
5594 vtkParam += gSeparator;
5595 vtkParam += QString::number(vtkViewers).toLatin1().data();
5596 vtkParam += gSeparator;
5599 param = vtkParam + "Visibility";
5600 ip->setParameter(entry, param, "On");
5603 param = vtkParam + "Representation";
5604 ip->setParameter(entry, param, QString::number
5605 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5608 param = vtkParam + "IsShrunk";
5609 ip->setParameter(entry, param, QString::number
5610 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5612 // Displayed entities
5613 unsigned int aMode = aSmeshActor->GetEntityMode();
5614 bool isE = aMode & SMESH_Actor::eEdges;
5615 bool isF = aMode & SMESH_Actor::eFaces;
5616 bool isV = aMode & SMESH_Actor::eVolumes;
5617 bool is0d = aMode & SMESH_Actor::e0DElements;
5618 bool isB = aMode & SMESH_Actor::eBallElem;
5620 QString modeStr ("e");
5621 modeStr += gDigitsSep; modeStr += QString::number(isE);
5622 modeStr += gDigitsSep; modeStr += "f";
5623 modeStr += gDigitsSep; modeStr += QString::number(isF);
5624 modeStr += gDigitsSep; modeStr += "v";
5625 modeStr += gDigitsSep; modeStr += QString::number(isV);
5626 modeStr += gDigitsSep; modeStr += "0d";
5627 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5628 modeStr += gDigitsSep; modeStr += "b";
5629 modeStr += gDigitsSep; modeStr += QString::number(isB);
5631 param = vtkParam + "Entities";
5632 ip->setParameter(entry, param, modeStr.toLatin1().data());
5638 aSmeshActor->GetSufaceColor(r, g, b, delta);
5639 QStringList colorStr;
5640 colorStr << "surface";
5641 colorStr << QString::number(r);
5642 colorStr << QString::number(g);
5643 colorStr << QString::number(b);
5645 colorStr << "backsurface";
5646 colorStr << QString::number(delta);
5648 aSmeshActor->GetVolumeColor(r, g, b, delta);
5649 colorStr << "volume";
5650 colorStr << QString::number(r);
5651 colorStr << QString::number(g);
5652 colorStr << QString::number(b);
5653 colorStr << QString::number(delta);
5655 aSmeshActor->GetEdgeColor(r, g, b);
5657 colorStr << QString::number(r);
5658 colorStr << QString::number(g);
5659 colorStr << QString::number(b);
5661 aSmeshActor->GetNodeColor(r, g, b);
5663 colorStr << QString::number(r);
5664 colorStr << QString::number(g);
5665 colorStr << QString::number(b);
5667 aSmeshActor->GetOutlineColor(r, g, b);
5668 colorStr << "outline";
5669 colorStr << QString::number(r);
5670 colorStr << QString::number(g);
5671 colorStr << QString::number(b);
5673 aSmeshActor->Get0DColor(r, g, b);
5674 colorStr << "elem0d";
5675 colorStr << QString::number(r);
5676 colorStr << QString::number(g);
5677 colorStr << QString::number(b);
5679 aSmeshActor->GetBallColor(r, g, b);
5681 colorStr << QString::number(r);
5682 colorStr << QString::number(g);
5683 colorStr << QString::number(b);
5685 aSmeshActor->GetFacesOrientationColor(r, g, b);
5686 colorStr << "orientation";
5687 colorStr << QString::number(r);
5688 colorStr << QString::number(g);
5689 colorStr << QString::number(b);
5691 param = vtkParam + "Colors";
5692 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5695 QStringList sizeStr;
5697 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5698 sizeStr << "outline";
5699 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5700 sizeStr << "elem0d";
5701 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5703 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5704 sizeStr << "shrink";
5705 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5706 sizeStr << "orientation";
5707 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5708 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5710 param = vtkParam + "Sizes";
5711 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5716 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5717 if( aMarkerType == VTK::MT_USER ) {
5718 markerStr += "custom";
5719 markerStr += gDigitsSep;
5720 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5724 markerStr += gDigitsSep;
5725 markerStr += QString::number( (int)aMarkerType );
5726 markerStr += gDigitsSep;
5727 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5730 param = vtkParam + "PointMarker";
5731 ip->setParameter(entry, param, markerStr.toLatin1().data());
5734 param = vtkParam + "Opacity";
5735 ip->setParameter(entry, param,
5736 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5739 param = vtkParam + "ClippingPlane";
5741 if( !aClippingPlaneInfoList.empty() ) {
5742 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5743 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5745 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5746 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5747 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5748 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5749 if( aSmeshActor == *anIter2 ) {
5750 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5751 QString::number( anId ).toLatin1().constData() );
5758 ip->setParameter( entry, param, "Off" );
5759 } // if (io->hasEntry())
5760 } // SMESH_Actor && hasIO
5762 } // while.. actors traversal
5766 } // if (SVTK view model)
5767 } // for (viewManagers)
5770 // data structures for clipping planes processing
5774 bool isOpenGLClipping;
5775 vtkIdType RelativeOrientation;
5778 int AbsoluteOrientation;
5779 double X, Y, Z, Dx, Dy, Dz;
5781 typedef std::list<TPlaneData> TPlaneDataList;
5782 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5784 typedef std::list<vtkActor*> TActorList;
5787 TActorList ActorList;
5788 SUIT_ViewManager* ViewManager;
5790 typedef std::list<TPlaneInfo> TPlaneInfoList;
5791 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5794 * \brief Restore visual parameters
5796 * This method is called after the study document is opened.
5797 * Restore visual parameters from AttributeParameter attribue(s)
5799 void SMESHGUI::restoreVisualParameters (int savePoint)
5802 Kernel_Utils::Localizer loc;
5804 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5805 if (!appStudy || !appStudy->studyDS())
5807 _PTR(Study) studyDS = appStudy->studyDS();
5809 // componentName is used for encoding of entries when storing them in IParameters
5810 std::string componentName = myComponentSMESH->ComponentDataType();
5811 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5812 //if (!aSComponent) return;
5815 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5816 componentName.c_str(),
5818 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5820 // restore map of custom markers and map of clipping planes
5821 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5822 TPlaneDataMap aPlaneDataMap;
5824 std::vector<std::string> properties = ip->getProperties();
5825 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5827 std::string property = *propIt;
5828 QString aPropertyName( property.c_str() );
5829 QString aPropertyValue( ip->getProperty( property ).c_str() );
5831 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5832 if( aPropertyNameList.isEmpty() )
5835 QString aPropertyType = aPropertyNameList[0];
5836 if( aPropertyType == "texture" )
5838 if( aPropertyNameList.size() != 2 )
5842 int anId = aPropertyNameList[1].toInt( &ok );
5843 if( !ok || anId < 1 )
5846 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5847 if( aPropertyValueList.size() != 2 )
5850 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5851 QString aMarkerTextureString = aPropertyValueList[1];
5852 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5853 if( aMarkerTextureStringList.size() != 3 )
5857 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5862 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5866 VTK::MarkerTexture aMarkerTexture;
5867 aMarkerTexture.push_back( aWidth );
5868 aMarkerTexture.push_back( aHeight );
5870 QString aMarkerTextureData = aMarkerTextureStringList[2];
5871 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5873 QChar aChar = aMarkerTextureData.at( i );
5874 if( aChar.isDigit() )
5875 aMarkerTexture.push_back( aChar.digitValue() );
5878 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5880 else if( aPropertyType == "ClippingPlane" )
5882 if( aPropertyNameList.size() != 3 )
5886 int aViewId = aPropertyNameList[1].toInt( &ok );
5887 if( !ok || aViewId < 0 )
5891 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5892 if( !ok || aClippingPlaneId < 0 )
5895 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5896 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
5899 TPlaneData aPlaneData;
5900 aPlaneData.Id = aClippingPlaneId;
5903 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
5908 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
5912 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
5915 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
5920 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
5925 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
5930 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
5935 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
5940 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
5945 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
5949 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
5951 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
5956 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
5961 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
5966 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
5971 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5972 aPlaneDataList.push_back( aPlaneData );
5976 TPlaneInfoMap aPlaneInfoMap;
5978 std::vector<std::string> entries = ip->getEntries();
5980 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5982 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5983 QString entry (ip->decodeEntry(*entIt).c_str());
5985 // Check that the entry corresponds to a real object in the Study
5986 // as the object may be deleted or modified after the visual state is saved.
5987 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5988 if (!so) continue; //Skip the not existent entry
5990 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5991 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5993 std::vector<std::string>::iterator namesIt = paramNames.begin();
5994 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5996 // actors are stored in a map after displaying of them for
5997 // quicker access in the future: map < viewID to actor >
5998 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6000 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6002 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6003 // '_' is used as separator and should not be used in viewer type or parameter names.
6004 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6005 if (lst.size() != 3)
6008 QString viewerTypStr = lst[0];
6009 QString viewIndexStr = lst[1];
6010 QString paramNameStr = lst[2];
6013 int viewIndex = viewIndexStr.toUInt(&ok);
6014 if (!ok) // bad conversion of view index to integer
6018 if (viewerTypStr == SVTK_Viewer::Type())
6020 SMESH_Actor* aSmeshActor = 0;
6021 if (vtkActors.IsBound(viewIndex))
6022 aSmeshActor = vtkActors.Find(viewIndex);
6024 QList<SUIT_ViewManager*> lst;
6025 getApp()->viewManagers(viewerTypStr, lst);
6027 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6028 SUIT_ViewManager* vman = NULL;
6029 if (viewIndex >= 0 && viewIndex < lst.count())
6030 vman = lst.at(viewIndex);
6032 if (paramNameStr == "Visibility")
6034 if (!aSmeshActor && displayer() && vman)
6036 SUIT_ViewModel* vmodel = vman->getViewModel();
6037 // SVTK view model can be casted to SALOME_View
6038 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6040 // store displayed actor in a temporary map for quicker
6041 // access later when restoring other parameters
6042 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6043 vtkRenderer* Renderer = vtkView->getRenderer();
6044 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6045 vtkActorCollection* theActors = aCopy.GetActors();
6046 theActors->InitTraversal();
6047 bool isFound = false;
6048 vtkActor *ac = theActors->GetNextActor();
6049 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6050 if (ac->IsA("SMESH_Actor")) {
6051 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6052 if (aGeomAc->hasIO()) {
6053 Handle(SALOME_InteractiveObject) io =
6054 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6055 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6057 vtkActors.Bind(viewIndex, aGeomAc);
6063 } // if (paramNameStr == "Visibility")
6066 // the rest properties "work" with SMESH_Actor
6069 QString val ((*valuesIt).c_str());
6072 if (paramNameStr == "Representation") {
6073 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6076 else if (paramNameStr == "IsShrunk") {
6078 if (!aSmeshActor->IsShrunk())
6079 aSmeshActor->SetShrink();
6082 if (aSmeshActor->IsShrunk())
6083 aSmeshActor->UnShrink();
6086 // Displayed entities
6087 else if (paramNameStr == "Entities") {
6088 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6089 int aEntityMode = SMESH_Actor::eAllEntity;
6090 for ( int i = 0; i < mode.count(); i+=2 ) {
6091 if ( i < mode.count()-1 ) {
6092 QString type = mode[i];
6093 bool val = mode[i+1].toInt();
6094 if ( type == "e" && !val )
6095 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6096 else if ( type == "f" && !val )
6097 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6098 else if ( type == "v" && !val )
6099 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6100 else if ( type == "0d" && !val )
6101 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6102 else if ( type == "b" && !val )
6103 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6106 aSmeshActor->SetEntityMode( aEntityMode );
6109 else if (paramNameStr == "Colors") {
6110 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6117 QColor outlineColor;
6118 QColor orientationColor;
6124 // below lines are required to get default values for delta coefficients
6125 // of backface color for faces and color of reversed volumes
6126 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6127 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6128 for ( int i = 0; i < colors.count(); i++ ) {
6129 QString type = colors[i];
6130 if ( type == "surface" ) {
6131 // face color is set by 3 values r:g:b, where
6132 // - r,g,b - is rgb color components
6133 if ( i+1 >= colors.count() ) break; // format error
6134 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6135 if ( i+2 >= colors.count() ) break; // format error
6136 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6137 if ( i+3 >= colors.count() ) break; // format error
6138 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6139 faceColor.setRgbF( r, g, b );
6142 else if ( type == "backsurface" ) {
6143 // backface color can be defined in several ways
6144 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6145 // - in latest versions, it is set as delta coefficient
6146 bool rgbOk = false, deltaOk;
6147 if ( i+1 >= colors.count() ) break; // format error
6148 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6149 int delta = colors[i+1].toInt( &deltaOk );
6151 if ( i+1 < colors.count() ) // index is shifted to 1
6152 g = colors[i+1].toDouble( &rgbOk );
6153 if ( rgbOk ) i++; // shift index
6154 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6155 b = colors[i+1].toDouble( &rgbOk );
6157 // - as currently there's no way to set directly backsurface color as it was before,
6158 // we ignore old dump where r,g,b triple was set
6159 // - also we check that delta parameter is set properly
6160 if ( !rgbOk && deltaOk )
6163 else if ( type == "volume" ) {
6164 // volume color is set by 4 values r:g:b:delta, where
6165 // - r,g,b - is a normal volume rgb color components
6166 // - delta - is a reversed volume color delta coefficient
6167 if ( i+1 >= colors.count() ) break; // format error
6168 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6169 if ( i+2 >= colors.count() ) break; // format error
6170 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6171 if ( i+3 >= colors.count() ) break; // format error
6172 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6173 if ( i+4 >= colors.count() ) break; // format error
6174 int delta = colors[i+4].toInt( &bOk );
6175 if ( !bOk ) break; // format error
6176 volumeColor.setRgbF( r, g, b );
6180 else if ( type == "edge" ) {
6181 // edge color is set by 3 values r:g:b, where
6182 // - r,g,b - is rgb color components
6183 if ( i+1 >= colors.count() ) break; // format error
6184 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6185 if ( i+2 >= colors.count() ) break; // format error
6186 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6187 if ( i+3 >= colors.count() ) break; // format error
6188 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6189 edgeColor.setRgbF( r, g, b );
6192 else if ( type == "node" ) {
6193 // node color is set by 3 values r:g:b, where
6194 // - r,g,b - is rgb color components
6195 if ( i+1 >= colors.count() ) break; // format error
6196 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6197 if ( i+2 >= colors.count() ) break; // format error
6198 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6199 if ( i+3 >= colors.count() ) break; // format error
6200 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6201 nodeColor.setRgbF( r, g, b );
6204 else if ( type == "elem0d" ) {
6205 // 0d element color is set by 3 values r:g:b, where
6206 // - r,g,b - is rgb color components
6207 if ( i+1 >= colors.count() ) break; // format error
6208 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6209 if ( i+2 >= colors.count() ) break; // format error
6210 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6211 if ( i+3 >= colors.count() ) break; // format error
6212 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6213 elem0dColor.setRgbF( r, g, b );
6216 else if ( type == "ball" ) {
6217 // ball color is set by 3 values r:g:b, where
6218 // - r,g,b - is rgb color components
6219 if ( i+1 >= colors.count() ) break; // format error
6220 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6221 if ( i+2 >= colors.count() ) break; // format error
6222 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6223 if ( i+3 >= colors.count() ) break; // format error
6224 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6225 ballColor.setRgbF( r, g, b );
6228 else if ( type == "outline" ) {
6229 // outline color is set by 3 values r:g:b, where
6230 // - r,g,b - is rgb color components
6231 if ( i+1 >= colors.count() ) break; // format error
6232 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6233 if ( i+2 >= colors.count() ) break; // format error
6234 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6235 if ( i+3 >= colors.count() ) break; // format error
6236 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6237 outlineColor.setRgbF( r, g, b );
6240 else if ( type == "orientation" ) {
6241 // orientation color is set by 3 values r:g:b, where
6242 // - r,g,b - is rgb color components
6243 if ( i+1 >= colors.count() ) break; // format error
6244 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6245 if ( i+2 >= colors.count() ) break; // format error
6246 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6247 if ( i+3 >= colors.count() ) break; // format error
6248 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6249 orientationColor.setRgbF( r, g, b );
6254 if ( nodeColor.isValid() )
6255 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6257 if ( edgeColor.isValid() )
6258 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6260 if ( faceColor.isValid() )
6261 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6263 if ( volumeColor.isValid() )
6264 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6265 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6266 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6268 if ( elem0dColor.isValid() )
6269 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6271 if ( ballColor.isValid() )
6272 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6274 if ( outlineColor.isValid() )
6275 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6276 // orientation color
6277 if ( orientationColor.isValid() )
6278 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6281 else if (paramNameStr == "Sizes") {
6282 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6285 int outlineWidth = -1;
6286 int elem0dSize = -1;
6288 double shrinkSize = -1;
6289 double orientationSize = -1;
6290 bool orientation3d = false;
6291 for ( int i = 0; i < sizes.count(); i++ ) {
6292 QString type = sizes[i];
6293 if ( type == "line" ) {
6294 // line (wireframe) width is given as single integer value
6295 if ( i+1 >= sizes.count() ) break; // format error
6296 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6300 if ( type == "outline" ) {
6301 // outline width is given as single integer value
6302 if ( i+1 >= sizes.count() ) break; // format error
6303 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6307 else if ( type == "elem0d" ) {
6308 // 0d element size is given as single integer value
6309 if ( i+1 >= sizes.count() ) break; // format error
6310 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6314 else if ( type == "ball" ) {
6315 // ball size is given as single integer value
6316 if ( i+1 >= sizes.count() ) break; // format error
6317 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6321 else if ( type == "shrink" ) {
6322 // shrink factor is given as single floating point value
6323 if ( i+1 >= sizes.count() ) break; // format error
6324 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6328 else if ( type == "orientation" ) {
6329 // orientation vectors are specified by two values size:3d, where
6330 // - size - is a floating point value specifying scale factor
6331 // - 3d - is a boolean
6332 if ( i+1 >= sizes.count() ) break; // format error
6333 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6334 if ( i+2 >= sizes.count() ) break; // format error
6335 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6336 orientationSize = v1;
6337 orientation3d = (bool)v2;
6341 // line (wireframe) width
6342 if ( lineWidth > 0 )
6343 aSmeshActor->SetLineWidth( lineWidth );
6345 if ( outlineWidth > 0 )
6346 aSmeshActor->SetOutlineWidth( outlineWidth );
6347 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6348 aSmeshActor->SetOutlineWidth( lineWidth );
6350 if ( elem0dSize > 0 )
6351 aSmeshActor->Set0DSize( elem0dSize );
6354 aSmeshActor->SetBallSize( ballSize );
6356 if ( shrinkSize > 0 )
6357 aSmeshActor->SetShrinkFactor( shrinkSize );
6358 // orientation vectors
6359 if ( orientationSize > 0 ) {
6360 aSmeshActor->SetFacesOrientationScale( orientationSize );
6361 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6365 else if (paramNameStr == "PointMarker") {
6366 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6367 if( data.count() >= 2 ) {
6369 int aParam1 = data[1].toInt( &ok );
6371 if( data[0] == "std" && data.count() == 3 ) {
6372 int aParam2 = data[2].toInt( &ok );
6373 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6375 else if( data[0] == "custom" ) {
6376 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6377 if( markerIt != aMarkerMap.end() ) {
6378 VTK::MarkerData aMarkerData = markerIt->second;
6379 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6386 else if (paramNameStr == "Opacity") {
6387 aSmeshActor->SetOpacity(val.toFloat());
6390 else if (paramNameStr.startsWith("ClippingPlane")) {
6391 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6392 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6393 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6394 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6395 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6396 // new format - val looks like "Off" or "0" (plane id)
6397 // (note: in new format "Off" value is used only for consistency,
6398 // so it is processed together with values in old format)
6399 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6400 if( anIsOldFormat ) {
6401 if (paramNameStr == "ClippingPlane1" || val == "Off")
6402 aSmeshActor->RemoveAllClippingPlanes();
6404 QList<SUIT_ViewManager*> lst;
6405 getApp()->viewManagers(viewerTypStr, lst);
6406 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6407 if (viewIndex >= 0 && viewIndex < lst.count()) {
6408 SUIT_ViewManager* vman = lst.at(viewIndex);
6409 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6411 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6413 SMESH::TActorList anActorList;
6414 anActorList.push_back( aSmeshActor );
6415 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6416 aPlane->myViewWindow = vtkView;
6417 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6418 aPlane->PlaneMode = aMode;
6419 bool isOpenGLClipping = ( bool )vals[1].toInt();
6420 aPlane->IsOpenGLClipping = isOpenGLClipping;
6421 if ( aMode == SMESH::Absolute ) {
6422 aPlane->myAbsoluteOrientation = vals[2].toInt();
6423 aPlane->X = vals[3].toFloat();
6424 aPlane->Y = vals[4].toFloat();
6425 aPlane->Z = vals[5].toFloat();
6426 aPlane->Dx = vals[6].toFloat();
6427 aPlane->Dy = vals[7].toFloat();
6428 aPlane->Dz = vals[8].toFloat();
6430 else if ( aMode == SMESH::Relative ) {
6431 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6432 aPlane->myDistance = vals[3].toFloat();
6433 aPlane->myAngle[0] = vals[4].toFloat();
6434 aPlane->myAngle[1] = vals[5].toFloat();
6438 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6439 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6440 aClippingPlaneInfo.Plane = aPlane;
6441 aClippingPlaneInfo.ActorList = anActorList;
6442 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6450 int aPlaneId = val.toInt( &ok );
6451 if( ok && aPlaneId >= 0 ) {
6452 bool anIsDefinedPlane = false;
6453 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6454 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6455 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6456 TPlaneInfo& aPlaneInfo = *anIter;
6457 if( aPlaneInfo.PlaneId == aPlaneId ) {
6458 aPlaneInfo.ActorList.push_back( aSmeshActor );
6459 anIsDefinedPlane = true;
6463 if( !anIsDefinedPlane ) {
6464 TPlaneInfo aPlaneInfo;
6465 aPlaneInfo.PlaneId = aPlaneId;
6466 aPlaneInfo.ActorList.push_back( aSmeshActor );
6467 aPlaneInfo.ViewManager = vman;
6469 // to make the list sorted by plane id
6470 anIter = aPlaneInfoList.begin();
6471 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6472 const TPlaneInfo& aPlaneInfoRef = *anIter;
6473 if( aPlaneInfoRef.PlaneId > aPlaneId )
6476 aPlaneInfoList.insert( anIter, aPlaneInfo );
6481 } // if (aSmeshActor)
6482 } // other parameters than Visibility
6484 } // for names/parameters iterator
6485 } // for entries iterator
6487 // take into account planes with empty list of actors referred to them
6488 QList<SUIT_ViewManager*> aVMList;
6489 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6491 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6492 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6493 int aViewId = aPlaneDataIter->first;
6494 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6495 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6497 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6499 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6500 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6501 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6502 const TPlaneData& aPlaneData = *anIter2;
6503 int aPlaneId = aPlaneData.Id;
6505 bool anIsFound = false;
6506 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6507 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6508 const TPlaneInfo& aPlaneInfo = *anIter3;
6509 if( aPlaneInfo.PlaneId == aPlaneId ) {
6516 TPlaneInfo aPlaneInfo; // ActorList field is empty
6517 aPlaneInfo.PlaneId = aPlaneId;
6518 aPlaneInfo.ViewManager = aViewManager;
6520 // to make the list sorted by plane id
6521 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6522 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6523 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6524 if( aPlaneInfoRef.PlaneId > aPlaneId )
6527 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6533 // add clipping planes to actors according to the restored parameters
6534 // and update the clipping plane map
6535 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6536 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6537 int aViewId = anIter1->first;
6538 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6540 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6541 if( anIter2 == aPlaneDataMap.end() )
6543 const TPlaneDataList& aPlaneDataList = anIter2->second;
6545 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6546 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6547 const TPlaneInfo& aPlaneInfo = *anIter3;
6548 int aPlaneId = aPlaneInfo.PlaneId;
6549 const TActorList& anActorList = aPlaneInfo.ActorList;
6550 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6554 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6558 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6560 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6561 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6562 const TPlaneData& aPlaneData = *anIter4;
6563 if( aPlaneData.Id == aPlaneId ) {
6564 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6565 aPlane->myViewWindow = aViewWindow;
6566 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6567 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6568 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6569 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6570 aPlane->X = aPlaneData.X;
6571 aPlane->Y = aPlaneData.Y;
6572 aPlane->Z = aPlaneData.Z;
6573 aPlane->Dx = aPlaneData.Dx;
6574 aPlane->Dy = aPlaneData.Dy;
6575 aPlane->Dz = aPlaneData.Dz;
6577 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6578 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6579 aPlane->myDistance = aPlaneData.Distance;
6580 aPlane->myAngle[0] = aPlaneData.Angle[0];
6581 aPlane->myAngle[1] = aPlaneData.Angle[1];
6584 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6585 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6586 aClippingPlaneInfo.Plane = aPlane;
6587 aClippingPlaneInfo.ActorList = anActorList;
6588 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6599 // update all VTK views
6600 QList<SUIT_ViewManager*> lst;
6601 getApp()->viewManagers(lst);
6602 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6603 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6604 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6605 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6606 // set OpenGL clipping planes
6607 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6608 vtkActorCollection* anAllActors = aCopy.GetActors();
6609 anAllActors->InitTraversal();
6610 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6611 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6612 anActor->SetOpenGLClippingPlane();
6614 vtkView->getRenderer()->ResetCameraClippingRange();
6621 \brief Adds preferences for dfont of VTK viewer
6623 \param pIf group identifier
6624 \param param parameter
6625 \return identifier of preferences
6627 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6629 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6631 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6634 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6635 fam.append( tr( "SMESH_FONT_COURIER" ) );
6636 fam.append( tr( "SMESH_FONT_TIMES" ) );
6638 setPreferenceProperty( tfont, "fonts", fam );
6640 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6641 if ( needSize ) f = f | QtxFontEdit::Size;
6642 setPreferenceProperty( tfont, "features", f );
6648 \brief Actions after hypothesis edition
6649 Updates object browser after hypothesis edition
6651 void SMESHGUI::onHypothesisEdit( int result )
6654 SMESHGUI::Modified();
6655 updateObjBrowser( true );
6660 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6661 \param pview view being closed
6663 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6664 #ifndef DISABLE_PLOT2DVIEWER
6665 //Crear all Plot2d Viewers if need.
6666 SMESH::ClearPlot2Viewers(pview);
6670 void SMESHGUI::message( const QString& msg )
6673 QStringList data = msg.split("/");
6674 if ( data.count() > 0 ) {
6675 if ( data.first() == "mesh_loading" ) {
6677 QString entry = data.count() > 1 ? data[1] : QString();
6678 if ( entry.isEmpty() )
6681 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6683 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6686 name = obj->GetName().c_str();
6687 if ( name.isEmpty() )
6690 if ( data.last() == "stop" )
6691 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6693 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6694 QApplication::processEvents();
6700 \brief Connects or disconnects signals about activating and cloning view on the module slots
6701 \param pview view which is connected/disconnected
6703 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6707 SUIT_ViewManager* viewMgr = pview->getViewManager();
6709 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6710 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6712 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6713 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6718 \brief Return \c true if object can be renamed
6720 bool SMESHGUI::renameAllowed( const QString& entry) const {
6721 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6725 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6729 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6734 if(appStudy->isComponent(entry) || obj->isReference())
6737 // check type to prevent renaming of inappropriate objects
6738 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6739 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6740 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6741 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6742 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6743 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6750 Rename object by entry.
6751 \param entry entry of the object
6752 \param name new name of the object
6753 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6755 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6757 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6761 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6766 _PTR(Study) aStudy = appStudy->studyDS();
6771 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6773 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6778 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6779 _PTR(GenericAttribute) anAttr;
6780 _PTR(AttributeName) aName;
6782 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6784 // check type to prevent renaming of inappropriate objects
6785 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6786 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6787 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6788 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6789 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6790 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6791 if ( !name.isEmpty() ) {
6792 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6794 // update name of group object and its actor
6795 Handle(SALOME_InteractiveObject) IObject =
6796 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6798 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6799 if( !aGroupObject->_is_nil() ) {
6800 aGroupObject->SetName( qPrintable(name) );
6801 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6802 anActor->setName( qPrintable(name) );
6812 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6814 static QList<QColor> colors;
6816 if ( colors.isEmpty() ) {
6818 for (int s = 0; s < 2 ; s++)
6820 for (int v = 100; v >= 40; v = v - 20)
6822 for (int h = 0; h < 359 ; h = h + 60)
6824 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
6829 static int currentColor = 0;
6831 SALOMEDS::Color color;
6832 color.R = (double)colors[currentColor].red() / 255.0;
6833 color.G = (double)colors[currentColor].green() / 255.0;
6834 color.B = (double)colors[currentColor].blue() / 255.0;
6836 currentColor = (currentColor+1) % colors.count();