1 // Copyright (C) 2007-2014 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, or (at your option) any later version.
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_FieldSelectorWdg.h"
48 #include "SMESHGUI_FileInfoDlg.h"
49 #include "SMESHGUI_FileValidator.h"
50 #include "SMESHGUI_FilterDlg.h"
51 #include "SMESHGUI_FilterLibraryDlg.h"
52 #include "SMESHGUI_FindElemByPointDlg.h"
53 #include "SMESHGUI_GroupDlg.h"
54 #include "SMESHGUI_GroupOnShapeDlg.h"
55 #include "SMESHGUI_GroupOpDlg.h"
56 #include "SMESHGUI_Hypotheses.h"
57 #include "SMESHGUI_Make2DFrom3DOp.h"
58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
59 #include "SMESHGUI_Measurements.h"
60 #include "SMESHGUI_MergeDlg.h"
61 #include "SMESHGUI_MeshInfo.h"
62 #include "SMESHGUI_MeshOp.h"
63 #include "SMESHGUI_MeshOrderOp.h"
64 #include "SMESHGUI_MeshPatternDlg.h"
65 #include "SMESHGUI_MultiEditDlg.h"
66 #include "SMESHGUI_NodesDlg.h"
67 #include "SMESHGUI_Operations.h"
68 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
69 #include "SMESHGUI_PropertiesDlg.h"
70 #include "SMESHGUI_RemoveElementsDlg.h"
71 #include "SMESHGUI_RemoveNodesDlg.h"
72 #include "SMESHGUI_RenumberingDlg.h"
73 #include "SMESHGUI_ReorientFacesDlg.h"
74 #include "SMESHGUI_RevolutionDlg.h"
75 #include "SMESHGUI_RotationDlg.h"
76 #include "SMESHGUI_ScaleDlg.h"
77 #include "SMESHGUI_Selection.h"
78 #include "SMESHGUI_SewingDlg.h"
79 #include "SMESHGUI_SingleEditDlg.h"
80 #include "SMESHGUI_SmoothingDlg.h"
81 #include "SMESHGUI_SymmetryDlg.h"
82 #include "SMESHGUI_TranslationDlg.h"
83 #include "SMESHGUI_TransparencyDlg.h"
85 #include "SMESHGUI_FilterUtils.h"
86 #include "SMESHGUI_GEOMGenUtils.h"
87 #include "SMESHGUI_GroupUtils.h"
88 #include "SMESHGUI_HypothesesUtils.h"
89 #include "SMESHGUI_MeshUtils.h"
90 #include "SMESHGUI_PatternUtils.h"
91 #include "SMESHGUI_Utils.h"
92 #include "SMESHGUI_VTKUtils.h"
94 #include <SMESH_version.h>
96 #include "SMESH_ControlsDef.hxx"
97 #include <SMESH_Actor.h>
98 #include <SMESH_ActorUtils.h>
99 #include <SMESH_Client.hxx>
100 #include <SMESH_ScalarBarActor.h>
101 #include <SMESH_TypeFilter.hxx>
103 // SALOME GUI includes
104 #include <SalomeApp_Application.h>
105 #include <SalomeApp_CheckFileDlg.h>
106 #include <SalomeApp_DataObject.h>
107 #include <SalomeApp_Study.h>
108 #include <SalomeApp_Tools.h>
110 #include <LightApp_DataOwner.h>
111 #include <LightApp_NameDlg.h>
112 #include <LightApp_Preferences.h>
113 #include <LightApp_SelectionMgr.h>
114 #include <LightApp_UpdateFlags.h>
116 #include <SVTK_ViewManager.h>
117 #include <SVTK_ViewModel.h>
118 #include <SVTK_ViewWindow.h>
120 #include <VTKViewer_Algorithm.h>
122 #include <PyInterp_Interp.h>
124 #include <SUIT_Desktop.h>
125 #include <SUIT_FileDlg.h>
126 #include <SUIT_MessageBox.h>
127 #include <SUIT_OverrideCursor.h>
128 #include <SUIT_ResourceMgr.h>
129 #include <SUIT_Session.h>
131 #include <QtxPopupMgr.h>
132 #include <QtxFontEdit.h>
134 #include <SALOME_ListIO.hxx>
135 #include <SALOME_ListIteratorOfListIO.hxx>
137 #ifndef DISABLE_PLOT2DVIEWER
138 #include <SPlot2d_ViewModel.h>
139 #include <SPlot2d_Histogram.h>
143 #include <SALOMEconfig.h>
144 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
145 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
146 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
149 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
150 #include <QApplication>
152 #include <QTextStream>
155 #include <boost/shared_ptr.hpp>
158 #include <vtkCallbackCommand.h>
159 #include <vtkCamera.h>
160 #include <vtkLookupTable.h>
161 #include <vtkPlane.h>
162 #include <vtkRenderer.h>
164 // SALOME KERNEL includes
165 #include <SALOMEDSClient_ClientFactory.hxx>
166 #include <SALOMEDSClient_IParameters.hxx>
167 #include <SALOMEDSClient_SComponent.hxx>
168 #include <SALOMEDSClient_StudyBuilder.hxx>
169 #include <SALOMEDS_Study.hxx>
170 #include <SALOMEDS_SObject.hxx>
173 #include <Standard_ErrorHandler.hxx>
174 #include <NCollection_DataMap.hxx>
176 #include <Basics_Utils.hxx>
178 //To disable automatic genericobj management, the following line should be commented.
179 //Otherwise, it should be uncommented.
180 //Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
181 #define WITHGENERICOBJ
183 // Below macro, when uncommented, switches on simplified (more performant) algorithm
184 // of auto-color picking up
185 #define SIMPLE_AUTOCOLOR
190 //=============================================================
191 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
194 void ExportMeshToFile(int theCommandID);
196 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
198 void SetDisplayEntity(int theCommandID);
200 void Control( int theCommandID );
203 //================================================================================
205 * \brief Reads meshes from file
207 //================================================================================
209 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
213 std::string myExtension;
215 if ( theCommandID == SMESHOp::OpImportMED ) {
216 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
217 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
219 else if ( theCommandID == SMESHOp::OpImportUNV ) {
220 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
222 else if ( theCommandID == SMESHOp::OpImportDAT ) {
223 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
225 else if ( theCommandID == SMESHOp::OpImportSTL ) {
226 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
229 else if ( theCommandID == SMESHOp::OpImportCGNS ) {
230 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
233 else if ( theCommandID == SMESHOp::OpImportSAUV ) {
234 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
235 filter.append( QObject::tr( "All files (*)" ) );
237 else if ( theCommandID == SMESHOp::OpImportGMF ) {
238 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
239 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
242 QString anInitialPath = "";
243 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
244 anInitialPath = QDir::currentPath();
246 QStringList filenames;
247 bool toCreateGroups = true;
249 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
250 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
251 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
252 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
253 // fd->setNameFilters( filter );
254 // fd->SetChecked( true );
256 // filenames << fd->selectedFile();
257 // toCreateGroups = fd->IsChecked();
263 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
266 QObject::tr( "SMESH_IMPORT_MESH" ) );
268 if ( filenames.count() > 0 ) {
269 SUIT_OverrideCursor wc;
270 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
273 QStringList anEntryList;
274 bool isEmpty = false;
275 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
276 QString filename = *it;
277 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
279 switch ( theCommandID ) {
280 case SMESHOp::OpImportDAT:
282 // DAT format (currently unsupported)
283 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
284 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
287 case SMESHOp::OpImportUNV:
290 aMeshes->length( 1 );
291 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
292 if ( aMeshes[0]->_is_nil() )
293 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
294 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
297 case SMESHOp::OpImportMED:
300 SMESH::DriverMED_ReadStatus res;
301 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
302 if ( res != SMESH::DRS_OK ) {
303 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
304 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
308 case SMESHOp::OpImportSTL:
311 aMeshes->length( 1 );
312 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
313 if ( aMeshes[0]->_is_nil() ) {
314 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
315 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
320 case SMESHOp::OpImportCGNS:
323 SMESH::DriverMED_ReadStatus res;
324 aMeshes = theComponentMesh->CreateMeshesFromCGNS( 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() ) ) );
332 case SMESHOp::OpImportSAUV:
335 SMESH::DriverMED_ReadStatus res;
336 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
337 if ( res != SMESH::DRS_OK ) {
338 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
339 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
343 case SMESHOp::OpImportGMF:
346 SMESH::ComputeError_var res;
347 aMeshes->length( 1 );
348 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
351 if ( res->code != SMESH::DRS_OK ) {
352 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
353 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
354 if ( strlen( res->comment.in() ) > 0 ) {
355 errors.back() += ": ";
356 errors.back() += res->comment.in();
363 catch ( const SALOME::SALOME_Exception& S_ex ) {
364 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
365 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
368 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
369 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
371 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
372 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
373 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
374 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
375 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
377 anEntryList.append( aMeshSO->GetID().c_str() );
385 // update Object browser
386 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
388 // browse to the published meshes
389 if( LightApp_Application* anApp =
390 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
391 anApp->browseObjects( anEntryList );
393 // show Error message box if there were errors
394 if ( errors.count() > 0 ) {
395 SUIT_MessageBox::critical( SMESHGUI::desktop(),
396 QObject::tr( "SMESH_ERROR" ),
397 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
400 // show warning message box, if some imported mesh is empty
402 SUIT_MessageBox::warning( SMESHGUI::desktop(),
403 QObject::tr( "SMESH_WRN_WARNING" ),
404 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
409 //================================================================================
411 * \brief Export selected meshes or groups into a file
413 //================================================================================
415 void ExportMeshToFile( int theCommandID )
417 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
418 SALOME_ListIO selected;
420 aSel->selectedObjects( selected );
422 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT || theCommandID == SMESHOp::OpPopupExportDAT );
423 const bool isMED = ( theCommandID == SMESHOp::OpExportMED || theCommandID == SMESHOp::OpPopupExportMED );
424 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV || theCommandID == SMESHOp::OpPopupExportUNV );
425 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL || theCommandID == SMESHOp::OpPopupExportSTL );
427 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS || theCommandID == SMESHOp::OpPopupExportCGNS );
429 const bool isCGNS= false;
431 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV || theCommandID == SMESHOp::OpPopupExportSAUV );
432 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF || theCommandID == SMESHOp::OpPopupExportGMF );
434 // actually, the following condition can't be met (added for insurance)
435 if( selected.Extent() == 0 ||
436 ( selected.Extent() > 1 && !isMED && !isSTL ))
439 // get mesh object from selection and check duplication of their names
440 bool hasDuplicatedMeshNames = false;
441 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
442 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
443 SALOME_ListIteratorOfListIO It( selected );
444 for( ; It.More(); It.Next() )
446 Handle(SALOME_InteractiveObject) anIObject = It.Value();
447 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
448 if ( aMeshItem->_is_nil() ) {
449 SUIT_MessageBox::warning( SMESHGUI::desktop(),
450 QObject::tr( "SMESH_WRN_WARNING" ),
451 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
455 QString aMeshName = anIObject->getName();
457 // check for name duplications
458 if ( !hasDuplicatedMeshNames )
459 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
460 if( aMeshName == (*aMeshIter).second ) {
461 hasDuplicatedMeshNames = true;
466 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
469 if( hasDuplicatedMeshNames && isMED ) {
470 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
471 QObject::tr("SMESH_WRN_WARNING"),
472 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
473 QObject::tr("SMESH_BUT_YES"),
474 QObject::tr("SMESH_BUT_NO"), 0, 1);
479 aMeshIter = aMeshList.begin();
480 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
481 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
482 QString aMeshName = (*aMeshIter).second;
484 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
486 // check for equal group names within each mesh
487 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
488 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
489 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
490 int aRet = SUIT_MessageBox::warning
491 (SMESHGUI::desktop(),
492 QObject::tr("SMESH_WRN_WARNING"),
493 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
494 QObject::tr("SMESH_BUT_YES"),
495 QObject::tr("SMESH_BUT_NO"), 0, 1);
502 // Warn the user about presence of not supported elements
504 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
508 notSupportedElemTypes.push_back( SMESH::Entity_0D );
509 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
514 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
515 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
516 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
517 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
518 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
519 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
520 notSupportedElemTypes.push_back( SMESH::Entity_0D );
521 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
526 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
527 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
528 notSupportedElemTypes.push_back( SMESH::Entity_0D );
529 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
534 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
535 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
540 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
541 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
542 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
543 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
544 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
545 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
546 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
551 notSupportedElemTypes.push_back( SMESH::Entity_0D );
552 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
553 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
554 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
555 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
556 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
557 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
558 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
559 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
561 if ( ! notSupportedElemTypes.empty() )
563 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
564 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
565 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
566 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
568 if ( !presentNotSupported.empty() )
571 const char* typeMsg[SMESH::Entity_Last] = {
572 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
573 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
574 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
575 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
576 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
577 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
578 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
579 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
581 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
582 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
583 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
584 if ( iType != presentNotSupported.size() - 1 )
585 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
587 int aRet = SUIT_MessageBox::warning
588 (SMESHGUI::desktop(),
589 QObject::tr("SMESH_WRN_WARNING"),
590 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
591 QObject::tr("SMESH_BUT_YES"),
592 QObject::tr("SMESH_BUT_NO"), 0, 1);
597 // Get parameters of export operation
600 SMESH::MED_VERSION aFormat;
601 // Init the parameters with the default values
602 bool aIsASCII_STL = true;
603 bool toCreateGroups = false;
604 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
606 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
607 bool toOverwrite = true;
608 bool toFindOutDim = true;
610 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
611 QString anInitialPath = "";
612 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
613 anInitialPath = QDir::currentPath();
615 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
617 // Get a file name to write in and additional otions
618 if ( isUNV || isDAT || isGMF ) // Export w/o options
621 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
623 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
625 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
626 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
627 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
628 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
629 anInitialPath + QString("/") + aMeshName,
630 aFilter, aTitle, false);
632 else if ( isCGNS )// Export to CGNS
634 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
635 fd->setWindowTitle( aTitle );
636 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
637 if ( !anInitialPath.isEmpty() )
638 fd->setDirectory( anInitialPath );
639 fd->selectFile(aMeshName);
640 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
641 fd->setValidator( fv );
644 aFilename = fd->selectedFile();
645 toOverwrite = fv->isOverwrite();
649 else if ( isSTL ) // Export to STL
651 QMap<QString, int> aFilterMap;
652 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
653 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
656 QMap<QString, int>::const_iterator it = aFilterMap.begin();
657 for ( ; it != aFilterMap.end(); ++it )
658 filters.push_back( it.key() );
660 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
661 fd->setWindowTitle( aTitle );
662 fd->setNameFilters( filters );
663 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
664 if ( !anInitialPath.isEmpty() )
665 fd->setDirectory( anInitialPath );
666 fd->selectFile(aMeshName);
670 aFilename = fd->selectedFile();
671 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
676 else if ( isMED || isSAUV ) // Export to MED or SAUV
678 QMap<QString, SMESH::MED_VERSION> aFilterMap;
679 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
681 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
682 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
683 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
686 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
687 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
688 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
692 QString aDefaultFilter;
693 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
694 for ( ; it != aFilterMap.end(); ++it ) {
695 filters.push_back( it.key() );
696 if (it.value() == SMESH::MED_V2_2)
697 aDefaultFilter = it.key();
699 QStringList checkBoxes;
700 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
702 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
703 QList< QWidget* > wdgList;
704 if ( fieldSelWdg->GetAllFeilds( aMeshList, aFieldList ))
705 wdgList.append( fieldSelWdg );
707 SalomeApp_CheckFileDlg* fd =
708 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
709 fd->setWindowTitle( aTitle );
710 fd->setNameFilters( filters );
711 fd->selectNameFilter( aDefaultFilter );
712 fd->SetChecked( toCreateGroups, 0 );
713 fd->SetChecked( toFindOutDim, 1 );
714 if ( !anInitialPath.isEmpty() )
715 fd->setDirectory( anInitialPath );
716 fd->selectFile(aMeshName);
718 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
719 fd->setValidator( fv );
724 aFilename = fd->selectedFile();
726 aFilename = QString::null;
729 aFormat = aFilterMap[fd->selectedNameFilter()];
730 toOverwrite = fv->isOverwrite();
732 if ( !aFilename.isEmpty() ) {
733 // med-2.1 does not support poly elements
734 if ( aFormat==SMESH::MED_V2_1 )
735 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
736 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
737 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
738 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
739 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
741 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
742 QObject::tr("SMESH_WRN_WARNING"),
743 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
744 QObject::tr("SMESH_BUT_YES"),
745 QObject::tr("SMESH_BUT_NO"), 0, 1);
753 // can't append to an existing using other format
754 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
755 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
756 if( !isVersionOk || aVersion != aFormat ) {
757 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
758 QObject::tr("SMESH_WRN_WARNING"),
759 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
760 QObject::tr("SMESH_BUT_YES"),
761 QObject::tr("SMESH_BUT_NO"), 0, 1);
768 QStringList aMeshNamesCollisionList;
769 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
770 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
771 QString anExistingMeshName( aMeshNames[ i ] );
772 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
773 QString anExportMeshName = (*aMeshIter).second;
774 if( anExportMeshName == anExistingMeshName ) {
775 aMeshNamesCollisionList.append( anExportMeshName );
780 if( !aMeshNamesCollisionList.isEmpty() ) {
781 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
782 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
783 QObject::tr("SMESH_WRN_WARNING"),
784 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
785 QObject::tr("SMESH_BUT_YES"),
786 QObject::tr("SMESH_BUT_NO"),
787 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
796 toCreateGroups = fd->IsChecked(0);
797 toFindOutDim = fd->IsChecked(1);
798 fieldSelWdg->GetSelectedFeilds();
799 if ( !fieldSelWdg->parent() )
810 if ( !aFilename.isEmpty() ) {
811 // Check whether the file already exists and delete it if yes
812 QFile aFile( aFilename );
813 if ( aFile.exists() && toOverwrite )
815 SUIT_OverrideCursor wc;
818 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
819 // bool Renumber = false;
820 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
822 // Renumber= resMgr->booleanValue("renumbering");
824 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
825 // aMeshEditor->RenumberNodes();
826 // aMeshEditor->RenumberElements();
827 // if ( SMESHGUI::automaticUpdate() )
828 // SMESH::UpdateView();
832 aMeshIter = aMeshList.begin();
833 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
835 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
836 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
837 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
838 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
839 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
840 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
841 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
842 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
844 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
845 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
846 fields, geoAssFields.toLatin1().data() );
851 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
853 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
854 if( !aMeshItem->_is_nil() )
855 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
860 if ( aMeshOrGroup->_is_equivalent( aMesh ))
861 aMesh->ExportDAT( aFilename.toUtf8().data() );
863 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
867 if ( aMeshOrGroup->_is_equivalent( aMesh ))
868 aMesh->ExportUNV( aFilename.toUtf8().data() );
870 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
874 if ( aMeshOrGroup->_is_equivalent( aMesh ))
875 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
877 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
881 aMeshIter = aMeshList.begin();
882 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
884 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
885 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
886 aMeshItem->ExportCGNS( aMeshOrGroup,
887 aFilename.toUtf8().data(),
888 toOverwrite && aMeshIndex == 0 );
893 toCreateGroups = true;
894 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
897 catch (const SALOME::SALOME_Exception& S_ex){
899 SUIT_MessageBox::warning(SMESHGUI::desktop(),
900 QObject::tr("SMESH_WRN_WARNING"),
901 QObject::tr("SMESH_EXPORT_FAILED"));
907 inline void InverseEntityMode(unsigned int& theOutputMode,
908 unsigned int theMode)
910 bool anIsNotPresent = ~theOutputMode & theMode;
912 theOutputMode |= theMode;
914 theOutputMode &= ~theMode;
917 void SetDisplayEntity(int theCommandID){
918 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
919 SALOME_ListIO selected;
921 aSel->selectedObjects( selected );
923 if(selected.Extent() >= 1){
924 SALOME_ListIteratorOfListIO It( selected );
925 for( ; It.More(); It.Next()){
926 Handle(SALOME_InteractiveObject) IObject = It.Value();
927 if(IObject->hasEntry()){
928 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
929 unsigned int aMode = anActor->GetEntityMode();
930 switch(theCommandID){
931 case SMESHOp::OpDE0DElements:
932 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
934 case SMESHOp::OpDEEdges:
935 InverseEntityMode(aMode,SMESH_Actor::eEdges);
937 case SMESHOp::OpDEFaces:
938 InverseEntityMode(aMode,SMESH_Actor::eFaces);
940 case SMESHOp::OpDEVolumes:
941 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
943 case SMESHOp::OpDEBalls:
944 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
946 case SMESHOp::OpDEAllEntity:
947 aMode = SMESH_Actor::eAllEntity;
951 anActor->SetEntityMode(aMode);
960 SALOME_ListIO selected;
961 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
965 LightApp_SelectionMgr* aSel = app->selectionMgr();
966 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
967 if( !aSel || !appStudy )
970 aSel->selectedObjects( selected );
971 if( selected.IsEmpty() )
974 Handle(SALOME_InteractiveObject) anIObject = selected.First();
976 _PTR(Study) aStudy = appStudy->studyDS();
977 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
978 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
979 if( aMainObject->_is_nil() )
982 SUIT_OverrideCursor wc;
984 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
986 QList<SALOMEDS::Color> aReservedColors;
988 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
989 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
991 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
992 //SALOMEDS::Color aColor = aGroupObject->GetColor();
994 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
995 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
996 #else // old algorithm for auto-colors
997 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
998 aReservedColors.append( aColor );
999 #endif // SIMPLE_AUTOCOLOR
1000 aGroupObject->SetColor( aColor );
1002 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1003 if (aGroupSObject) {
1006 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1007 switch ( aGroupObject->GetType ()) {
1009 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1011 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1013 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1015 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1017 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1018 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1021 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1022 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1028 SMESH::RepaintCurrentView();
1031 void OverallMeshQuality() {
1032 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1033 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1034 SALOME_ListIO selected;
1036 aSel->selectedObjects( selected );
1038 if ( selected.IsEmpty() ) return;
1039 SALOME_ListIteratorOfListIO It( selected );
1040 for ( ; It.More(); It.Next() ) {
1041 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1042 ctrlDlg->showInfo( It.Value() );
1047 QString functorToString( SMESH::Controls::FunctorPtr f )
1049 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1050 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1051 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1052 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1053 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1054 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1055 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1056 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1057 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1058 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1059 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1060 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1061 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1062 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1063 type = QObject::tr( "WARP_ELEMENTS" );
1064 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1065 type = QObject::tr( "TAPER_ELEMENTS" );
1066 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1067 type = QObject::tr( "SKEW_ELEMENTS" );
1068 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1069 type = QObject::tr( "AREA_ELEMENTS" );
1070 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1071 type = QObject::tr( "LENGTH_EDGES" );
1072 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1073 type = QObject::tr( "LENGTH2D_EDGES" );
1074 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1075 type = QObject::tr( "MULTI_BORDERS" );
1076 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1077 type = QObject::tr( "MULTI2D_BORDERS" );
1078 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1079 type = QObject::tr( "FREE_NODES" );
1080 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1081 type = QObject::tr( "FREE_EDGES" );
1082 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1083 type = QObject::tr( "FREE_BORDERS" );
1084 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1085 type = QObject::tr( "FREE_FACES" );
1086 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1087 type = QObject::tr( "BARE_BORDER_VOLUME" );
1088 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1089 type = QObject::tr( "BARE_BORDER_FACE" );
1090 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1091 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1092 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1093 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1094 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1095 type = QObject::tr( "EQUAL_NODE" );
1096 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1097 type = QObject::tr( "EQUAL_EDGE" );
1098 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1099 type = QObject::tr( "EQUAL_FACE" );
1100 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1101 type = QObject::tr( "EQUAL_VOLUME" );
1105 void SaveDistribution()
1107 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1108 SALOME_ListIO selected;
1110 aSel->selectedObjects( selected );
1112 if ( selected.Extent() == 1 ) {
1113 Handle(SALOME_InteractiveObject) anIO = selected.First();
1114 if ( anIO->hasEntry() ) {
1115 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1116 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1117 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1118 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1119 if ( aScalarBarActor && aFunctor ) {
1120 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1122 std::vector<int> elements;
1123 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1124 if ( mesh->_is_nil() ) {
1125 SMESH::SMESH_IDSource_var idSource =
1126 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1127 if ( !idSource->_is_nil() )
1129 SMESH::long_array_var ids = idSource->GetIDs();
1130 elements.resize( ids->length() );
1131 for ( unsigned i = 0; i < elements.size(); ++i )
1132 elements[i] = ids[i];
1135 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1136 vtkLookupTable* lookupTable =
1137 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1138 double * minmax = lookupTable->GetRange();
1139 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1140 std::vector<int> nbEvents;
1141 std::vector<double> funValues;
1142 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
1143 QString anInitialPath = "";
1144 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1145 anInitialPath = QDir::currentPath();
1146 QString aMeshName = anIO->getName();
1148 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1149 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1150 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1151 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1152 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1155 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1157 if ( !aFilename.isEmpty() ) {
1158 QFile f( aFilename );
1159 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1160 QTextStream out( &f );
1161 out << "# Mesh: " << aMeshName << endl;
1162 out << "# Control: " << functorToString( aFunctor ) << endl;
1164 out.setFieldWidth( 10 );
1165 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1166 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1177 void ShowDistribution() {
1178 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1179 SALOME_ListIO selected;
1181 aSel->selectedObjects( selected );
1183 if ( selected.Extent() == 1 ) {
1184 Handle(SALOME_InteractiveObject) anIO = selected.First();
1185 if ( anIO->hasEntry() ) {
1186 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1187 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1188 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1189 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1195 #ifndef DISABLE_PLOT2DVIEWER
1196 void PlotDistribution() {
1197 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1201 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1202 SALOME_ListIO selected;
1204 aSel->selectedObjects( selected );
1206 if ( selected.Extent() == 1 ) {
1207 Handle(SALOME_InteractiveObject) anIO = selected.First();
1208 if ( anIO->hasEntry() ) {
1209 //Find Actor by entry before getting Plot2d viewer,
1210 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1211 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1213 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1218 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1222 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1226 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1227 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1228 QString functorName = functorToString( anActor->GetFunctor());
1229 QString aHistogramName("%1 : %2");
1230 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1231 aHistogram->setName(aHistogramName);
1232 aHistogram->setHorTitle(functorName);
1233 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1234 aPlot->displayObject(aHistogram, true);
1239 #endif //DISABLE_PLOT2DVIEWER
1241 void DisableAutoColor(){
1242 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1243 SALOME_ListIO selected;
1245 aSel->selectedObjects( selected );
1247 if(selected.Extent()){
1248 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1249 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1250 if ( !aMesh->_is_nil() ) {
1251 aMesh->SetAutoColor( false );
1256 void sortChildren(){
1257 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1258 SALOME_ListIO selected;
1260 aSel->selectedObjects( selected );
1262 if(selected.Extent()){
1263 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1264 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1265 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1267 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1268 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1275 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1277 SALOME_ListIO selected;
1278 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1282 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1283 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1284 if( !aSel || !appStudy )
1287 if( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1288 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1289 aModule->EmitSignalDeactivateDialog();
1290 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1291 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1296 _PTR(Study) aStudy = appStudy->studyDS();
1298 aSel->selectedObjects( selected );
1300 if(selected.Extent() >= 1){
1301 switch(theCommandID){
1302 case SMESHOp::OpTransparency:{
1303 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1304 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1307 case SMESHOp::OpProperties: {
1309 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1310 QColor orientationColor, outlineColor, volumeColor;
1311 int deltaF = 0, deltaV = 0;
1314 double ballScale = 1.0;
1316 int outlineWidth = 1;
1317 double shrinkCoef = 0.0;
1318 double orientationScale = 0.0;
1319 bool orientation3d = false;
1320 VTK::MarkerType markerType = VTK::MT_NONE;
1321 VTK::MarkerScale markerScale = VTK::MS_NONE;
1323 bool hasNodes = false;
1324 int presentEntities = 0;
1325 bool firstTime = true;
1327 SALOME_ListIteratorOfListIO It( selected );
1328 for ( ; It.More(); It.Next() ) {
1329 Handle(SALOME_InteractiveObject) IObject = It.Value();
1330 if ( !IObject->hasEntry() ) continue;
1331 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1332 if ( !anActor || !anActor->GetObject() ) continue;
1335 // nodes: color, marker
1336 anActor->GetNodeColor( color[0], color[1], color[2] );
1337 nodeColor.setRgbF( color[0], color[1], color[2] );
1338 markerType = anActor->GetMarkerType();
1339 markerScale = anActor->GetMarkerScale();
1340 markerId = anActor->GetMarkerTexture();
1341 // edges: color, width
1342 anActor->GetEdgeColor( color[0], color[1], color[2] );
1343 edgeColor.setRgbF( color[0], color[1], color[2] );
1344 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1345 // faces: front color, back color (delta)
1346 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1347 faceColor.setRgbF( color[0], color[1], color[2] );
1348 // faces: front color, back color (delta)
1349 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1350 volumeColor.setRgbF( color[0], color[1], color[2] );
1351 // 0d elements: color, size
1352 anActor->Get0DColor( color[0], color[1], color[2] );
1353 elem0dColor.setRgbF( color[0], color[1], color[2] );
1354 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1355 // balls: color, size
1356 anActor->GetBallColor( color[0], color[1], color[2] );
1357 ballColor.setRgbF( color[0], color[1], color[2] );
1358 ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1359 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1361 anActor->GetOutlineColor( color[0], color[1], color[2] );
1362 outlineColor.setRgbF( color[0], color[1], color[2] );
1363 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1364 // orientation vectors: color, scale, 3d flag
1365 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1366 orientationColor.setRgbF( color[0], color[1], color[2] );
1367 orientationScale = anActor->GetFacesOrientationScale();
1368 orientation3d = anActor->GetFacesOrientation3DVectors();
1370 shrinkCoef = anActor->GetShrinkFactor();
1373 firstTime = false; // we only take properties from first object (for performance reasons)
1376 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1377 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1378 presentEntities = presentEntities | SMESH_Actor::eEdges;
1379 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1380 presentEntities = presentEntities | SMESH_Actor::eFaces;
1381 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1382 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1383 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1384 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1385 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1386 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1388 // as we know that all types of elements are present, we can exit the loop
1389 if ( presentEntities == SMESH_Actor::eAllEntity )
1393 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1394 // nodes: color, marker
1395 dlg.setNodeColor( nodeColor );
1396 if( markerType != VTK::MT_USER )
1397 dlg.setNodeMarker( markerType, markerScale );
1399 dlg.setNodeCustomMarker( markerId );
1400 // edges: color, line width
1401 dlg.setEdgeColor( edgeColor );
1402 dlg.setEdgeWidth( edgeWidth );
1403 // faces: front color, back color
1404 dlg.setFaceColor( faceColor, deltaF );
1405 // volumes: normal color, reversed color
1406 dlg.setVolumeColor( volumeColor, deltaV );
1407 // outlines: color, line width
1408 dlg.setOutlineColor( outlineColor );
1409 dlg.setOutlineWidth( outlineWidth );
1410 // 0d elements: color, size
1411 dlg.setElem0dColor( elem0dColor );
1412 dlg.setElem0dSize( elem0dSize );
1413 // balls: color, size
1414 dlg.setBallColor( ballColor );
1415 dlg.setBallSize( ballSize );
1416 dlg.setBallScale( ballScale );
1417 // orientation: color, scale, 3d flag
1418 dlg.setOrientationColor( orientationColor );
1419 dlg.setOrientationSize( int( orientationScale * 100. ) );
1420 dlg.setOrientation3d( orientation3d );
1421 // shrink: scale factor
1422 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1423 // hide unused controls
1424 dlg.showControls( presentEntities, hasNodes );
1427 nodeColor = dlg.nodeColor();
1428 markerType = dlg.nodeMarkerType();
1429 markerScale = dlg.nodeMarkerScale();
1430 markerId = dlg.nodeMarkerId();
1431 edgeColor = dlg.edgeColor();
1432 edgeWidth = dlg.edgeWidth();
1433 faceColor = dlg.faceColor();
1434 deltaF = dlg.faceColorDelta();
1435 volumeColor = dlg.volumeColor();
1436 deltaV = dlg.volumeColorDelta();
1437 outlineColor = dlg.outlineColor();
1438 outlineWidth = dlg.outlineWidth();
1439 elem0dColor = dlg.elem0dColor();
1440 elem0dSize = dlg.elem0dSize();
1441 ballColor = dlg.ballColor();
1442 ballSize = dlg.ballSize();
1443 ballScale = dlg.ballScale();
1444 orientationColor = dlg.orientationColor();
1445 orientationScale = dlg.orientationSize() / 100.;
1446 orientation3d = dlg.orientation3d();
1447 shrinkCoef = dlg.shrinkCoef() / 100.;
1449 // store point markers map that might be changed by the user
1450 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1452 // set properties from dialog box to the presentations
1453 SALOME_ListIteratorOfListIO It( selected );
1454 for ( ; It.More(); It.Next() ) {
1455 Handle(SALOME_InteractiveObject) IObject = It.Value();
1456 if ( !IObject->hasEntry() ) continue;
1457 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1458 if ( !anActor ) continue;
1460 // nodes: color, marker
1461 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1462 if ( markerType != VTK::MT_USER ) {
1463 anActor->SetMarkerStd( markerType, markerScale );
1466 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1467 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1468 if ( iter != markerMap.end() )
1469 anActor->SetMarkerTexture( markerId, iter->second.second );
1471 // volumes: normal color, reversed color (delta)
1472 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1473 // faces: front color, back color (delta)
1474 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1475 // edges: color, width
1476 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1477 anActor->SetLineWidth( edgeWidth );
1479 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1480 anActor->SetOutlineWidth( outlineWidth );
1481 // 0D elements: color, size
1482 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1483 anActor->Set0DSize( elem0dSize );
1484 // balls: color, size
1485 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1486 anActor->SetBallSize( ballSize );
1487 anActor->SetBallScale( ballScale );
1488 // orientation: color, scale, 3d flag
1489 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1490 anActor->SetFacesOrientationScale( orientationScale );
1491 anActor->SetFacesOrientation3DVectors( orientation3d );
1493 anActor->SetShrinkFactor( shrinkCoef );
1495 // for groups, set also proper color
1496 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1497 if ( !aGroupObject->_is_nil() ) {
1498 SMESH::ElementType anElementType = aGroupObject->GetType();
1500 switch( anElementType ) {
1502 aColor = nodeColor; break;
1504 aColor = edgeColor; break;
1506 aColor = faceColor; break;
1508 aColor = volumeColor; break;
1510 aColor = elem0dColor; break;
1512 aColor = ballColor; break;
1516 if ( aColor.isValid() ) {
1517 SALOMEDS::Color aGroupColor;
1518 aGroupColor.R = aColor.redF();
1519 aGroupColor.G = aColor.greenF();
1520 aGroupColor.B = aColor.blueF();
1521 aGroupObject->SetColor( aGroupColor );
1523 } // if ( !aGroupObject->_is_nil() )
1524 } // for ( ; It.More(); It.Next() )
1525 SMESH::RepaintCurrentView();
1526 } // if ( dlg.exec() )
1528 } // case SMESHOp::OpProperties:
1529 } // switch(theCommandID)
1530 SALOME_ListIteratorOfListIO It( selected );
1531 for( ; It.More(); It.Next()){
1532 Handle(SALOME_InteractiveObject) IObject = It.Value();
1533 if(IObject->hasEntry()){
1534 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1535 switch(theCommandID){
1536 case SMESHOp::OpDMWireframe:
1537 anActor->SetRepresentation(SMESH_Actor::eEdge);
1539 case SMESHOp::OpDMShading:
1540 anActor->SetRepresentation(SMESH_Actor::eSurface);
1542 case SMESHOp::OpDMShrink:
1543 if(anActor->IsShrunk())
1544 anActor->UnShrink();
1546 anActor->SetShrink();
1548 case SMESHOp::OpDMNodes:
1549 anActor->SetRepresentation(SMESH_Actor::ePoint);
1551 case SMESHOp::OpRepresentationLines:
1552 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1553 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1555 case SMESHOp::OpRepresentationArcs:
1556 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1557 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1563 SMESH::RepaintCurrentView();
1567 void Control( int theCommandID )
1569 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1570 SALOME_ListIO selected;
1572 aSel->selectedObjects( selected );
1574 if( !selected.IsEmpty() ){
1575 Handle(SALOME_InteractiveObject) anIO = selected.First();
1577 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1578 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1579 switch ( theCommandID ){
1580 case SMESHOp::OpFreeNode:
1581 aControl = SMESH_Actor::eFreeNodes;
1583 case SMESHOp::OpEqualNode:
1584 aControl = SMESH_Actor::eCoincidentNodes;
1586 case SMESHOp::OpFreeEdge:
1587 aControl = SMESH_Actor::eFreeEdges;
1589 case SMESHOp::OpFreeBorder:
1590 aControl = SMESH_Actor::eFreeBorders;
1592 case SMESHOp::OpLength:
1593 aControl = SMESH_Actor::eLength;
1595 case SMESHOp::OpConnection:
1596 aControl = SMESH_Actor::eMultiConnection;
1598 case SMESHOp::OpEqualEdge:
1599 aControl = SMESH_Actor::eCoincidentElems1D;
1601 case SMESHOp::OpFreeFace:
1602 aControl = SMESH_Actor::eFreeFaces;
1604 case SMESHOp::OpBareBorderFace:
1605 aControl = SMESH_Actor::eBareBorderFace;
1607 case SMESHOp::OpOverConstrainedFace:
1608 aControl = SMESH_Actor::eOverConstrainedFace;
1610 case SMESHOp::OpLength2D:
1611 aControl = SMESH_Actor::eLength2D;
1613 case SMESHOp::OpConnection2D:
1614 aControl = SMESH_Actor::eMultiConnection2D;
1616 case SMESHOp::OpArea:
1617 aControl = SMESH_Actor::eArea;
1619 case SMESHOp::OpTaper:
1620 aControl = SMESH_Actor::eTaper;
1622 case SMESHOp::OpAspectRatio:
1623 aControl = SMESH_Actor::eAspectRatio;
1625 case SMESHOp::OpMinimumAngle:
1626 aControl = SMESH_Actor::eMinimumAngle;
1628 case SMESHOp::OpWarpingAngle:
1629 aControl = SMESH_Actor::eWarping;
1631 case SMESHOp::OpSkew:
1632 aControl = SMESH_Actor::eSkew;
1634 case SMESHOp::OpMaxElementLength2D:
1635 aControl = SMESH_Actor::eMaxElementLength2D;
1637 case SMESHOp::OpEqualFace:
1638 aControl = SMESH_Actor:: eCoincidentElems2D;
1640 case SMESHOp::OpAspectRatio3D:
1641 aControl = SMESH_Actor::eAspectRatio3D;
1643 case SMESHOp::OpVolume:
1644 aControl = SMESH_Actor::eVolume3D;
1646 case SMESHOp::OpMaxElementLength3D:
1647 aControl = SMESH_Actor::eMaxElementLength3D;
1649 case SMESHOp::OpBareBorderVolume:
1650 aControl = SMESH_Actor::eBareBorderVolume;
1652 case SMESHOp::OpOverConstrainedVolume:
1653 aControl = SMESH_Actor::eOverConstrainedVolume;
1655 case SMESHOp::OpEqualVolume:
1656 aControl = SMESH_Actor::eCoincidentElems3D;
1660 anActor->SetControlMode(aControl);
1661 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1662 SMESH::RepaintCurrentView();
1663 #ifndef DISABLE_PLOT2DVIEWER
1664 if(anActor->GetPlot2Histogram()) {
1665 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1666 QString functorName = functorToString( anActor->GetFunctor());
1667 QString aHistogramName("%1 : %2");
1668 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1669 aHistogram->setName(aHistogramName);
1670 aHistogram->setHorTitle(functorName);
1671 SMESH::ProcessIn2DViewers(anActor);
1680 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1681 SMESH::MeshObjectType theType,
1682 const QString theInTypeName,
1683 QString & theOutTypeName)
1685 SMESH_TypeFilter aTypeFilter( theType );
1687 if( !theIO.IsNull() )
1689 entry = theIO->getEntry();
1690 LightApp_DataOwner owner( entry );
1691 if ( aTypeFilter.isOk( &owner )) {
1692 theOutTypeName = theInTypeName;
1700 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1702 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1703 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1705 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1706 CORBA::String_var anID = aSComp->GetID().c_str();
1707 if (!strcmp(anID.in(),theIO->getEntry()))
1713 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1714 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1715 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1716 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1717 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1725 QString CheckHomogeneousSelection()
1727 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1728 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1729 SALOME_ListIO selected;
1731 aSel->selectedObjects( selected );
1733 QString RefType = CheckTypeObject(selected.First());
1734 SALOME_ListIteratorOfListIO It(selected);
1735 for ( ; It.More(); It.Next())
1737 Handle(SALOME_InteractiveObject) IObject = It.Value();
1738 QString Type = CheckTypeObject(IObject);
1739 if (Type.compare(RefType) != 0)
1740 return "Heterogeneous Selection";
1748 void SMESHGUI::OnEditDelete()
1750 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1751 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1752 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1754 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1755 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1756 _PTR(GenericAttribute) anAttr;
1757 _PTR(AttributeIOR) anIOR;
1759 int objectCount = 0;
1761 QString aParentComponent = QString::null;
1762 Handle(SALOME_InteractiveObject) anIO;
1763 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1765 anIO = anIt.Value();
1766 QString cur = anIO->getComponentDataType();
1767 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1769 // check if object is reference
1770 _PTR(SObject) aRefSObj;
1771 aNameList.append("\n - ");
1772 if ( aSO->ReferencedObject( aRefSObj ) ) {
1773 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1774 aNameList.append( aRefName );
1775 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1778 aNameList.append(anIO->getName());
1782 if( aParentComponent.isNull() )
1783 aParentComponent = cur;
1784 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1785 aParentComponent = "";
1788 if ( objectCount == 0 )
1789 return; // No Valid Objects Selected
1791 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1792 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1793 QObject::tr("ERR_ERROR"),
1794 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1797 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1798 if (SUIT_MessageBox::warning
1799 (SMESHGUI::desktop(),
1800 QObject::tr("SMESH_WRN_WARNING"),
1801 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1802 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1803 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1806 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1808 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1809 // then treat them all starting from the deepest objects (at list back)
1810 std::list< _PTR(SObject) > listSO;
1811 SALOME_ListIteratorOfListIO It(selected);
1812 for( ; It.More(); It.Next()) // loop on selected IO's
1814 Handle(SALOME_InteractiveObject) IObject = It.Value();
1815 if(IObject->hasEntry()) {
1816 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1818 // disable removal of "SMESH" component object
1819 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1821 if ( engineIOR() == anIOR->Value().c_str() )
1824 //Check the referenced object
1825 _PTR(SObject) aRefSObject;
1826 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1827 aSO = aRefSObject; // Delete main Object instead of reference
1829 listSO.push_back( aSO );
1830 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1831 for ( ; itSO != listSO.end(); ++itSO ) {
1832 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1833 for (it->InitEx(false); it->More(); it->Next())
1834 listSO.push_back( it->Value() );
1838 // Check if none of objects to delete is referred from outside
1839 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1840 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1842 _PTR(SObject) SO = *ritSO;
1843 if ( !SO ) continue;
1844 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1845 for (size_t i = 0; i < aReferences.size(); i++) {
1846 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1847 std::string type = aComponent->ComponentDataType();
1848 if ( type != "SMESH" )
1850 SUIT_MessageBox::warning( anApp->desktop(),
1851 QObject::tr("WRN_WARNING"),
1852 QObject::tr("DEP_OBJECT") );
1853 return; // outside SMESH, there is an object depending on a SMESH object
1858 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1859 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1861 Handle(SALOME_InteractiveObject) IObject = It.Value();
1862 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1863 if ( !mesh->_is_nil() )
1867 // Treat SO's in the list starting from the back
1868 aStudyBuilder->NewCommand(); // There is a transaction
1869 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1871 _PTR(SObject) SO = *ritSO;
1872 if ( !SO ) continue;
1873 std::string anEntry = SO->GetID();
1875 /** Erase graphical object and remove all its data **/
1876 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1877 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1879 /** Remove an object from data structures **/
1880 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1881 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1882 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1883 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1884 aMesh->RemoveGroup( aGroup );
1886 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1887 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1888 aMesh->RemoveSubMesh( aSubMesh );
1890 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1892 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1895 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1896 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1897 QString objType = CheckTypeObject(IObject);
1898 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1899 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1900 aStudyBuilder->RemoveObjectWithChildren( SO );
1902 else {// default action: remove SObject from the study
1903 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1904 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1906 aStudyBuilder->RemoveObjectWithChildren( SO );
1910 } /* listSO back loop */
1912 aStudyBuilder->CommitCommand();
1914 /* Clear any previous selection */
1916 aSel->setSelectedObjects( l1 );
1918 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1922 SMESHGUI_EXPORT CAM_Module* createModule()
1924 return new SMESHGUI();
1927 SMESHGUI_EXPORT char* getModuleVersion() {
1928 return (char*)SMESH_VERSION_STR;
1932 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1934 //=============================================================================
1938 //=============================================================================
1939 SMESHGUI::SMESHGUI() :
1940 SalomeApp_Module( "SMESH" )
1942 if ( CORBA::is_nil( myComponentSMESH ) )
1944 CORBA::Boolean anIsEmbeddedMode;
1945 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1946 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1948 // 0019923: EDF 765 SMESH : default values of hypothesis
1949 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1950 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1951 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1952 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1953 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1955 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1956 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1957 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1959 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1960 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1964 myActiveDialogBox = 0;
1965 myFilterLibraryDlg = 0;
1969 myEventCallbackCommand = vtkCallbackCommand::New();
1970 myEventCallbackCommand->Delete();
1971 myEventCallbackCommand->SetClientData( this );
1972 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1975 /* load resources for all available meshers */
1976 SMESH::InitAvailableHypotheses();
1979 //=============================================================================
1983 //=============================================================================
1984 SMESHGUI::~SMESHGUI()
1988 //=============================================================================
1992 //=============================================================================
1993 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1995 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1997 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2002 //=============================================================================
2006 //=============================================================================
2007 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2009 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2013 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2014 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2015 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2016 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2017 return autoUpdate && !exceeded;
2020 //=============================================================================
2024 //=============================================================================
2025 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2026 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2028 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2032 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2033 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2034 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2036 SMESH::long_array_var info = theMesh->GetMeshInfo();
2037 long nbOdElems = info[SMDSEntity_0D];
2038 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2039 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2040 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2041 info[SMDSEntity_Polygon];
2042 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2043 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2044 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2045 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
2046 info[SMDSEntity_Polyhedra] +
2047 info[SMDSEntity_Hexagonal_Prism];
2048 long nbBalls = info[SMDSEntity_Ball];
2050 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2051 *nbElements = requestedSize;
2053 *entities = SMESH_Actor::eAllEntity;
2056 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2058 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2060 if ( incrementalLimit ) {
2063 if ( nbOdElems > 0 ) {
2064 if ( total + nbOdElems > updateLimit ) {
2065 *entities = *entities & ~SMESH_Actor::e0DElements;
2066 *hidden = *hidden | SMESH_Actor::e0DElements;
2073 if ( nbEdges > 0 ) {
2074 if ( total + nbEdges > updateLimit ) {
2075 *entities = *entities & ~SMESH_Actor::eEdges;
2076 *hidden = *hidden | SMESH_Actor::eEdges;
2083 if ( nbFaces > 0 ) {
2084 if ( total + nbFaces > updateLimit ) {
2085 *entities = *entities & ~SMESH_Actor::eFaces;
2086 *hidden = *hidden | SMESH_Actor::eFaces;
2093 if ( nbVolumes > 0 ) {
2094 if ( total + nbVolumes > updateLimit ) {
2095 *entities = *entities & ~SMESH_Actor::eVolumes;
2096 *hidden = *hidden | SMESH_Actor::eVolumes;
2103 if ( nbBalls > 0 ) {
2104 if ( total + nbBalls > updateLimit ) {
2105 *entities = *entities & ~SMESH_Actor::eBallElem;
2106 *hidden = *hidden | SMESH_Actor::eBallElem;
2114 return autoUpdate && !exceeded;
2117 //=============================================================================
2121 //=============================================================================
2122 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2124 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2127 //=============================================================================
2131 //=============================================================================
2132 SMESHGUI* SMESHGUI::GetSMESHGUI()
2134 SMESHGUI* smeshMod = 0;
2135 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2138 CAM_Module* module = app->module( "Mesh" );
2139 smeshMod = dynamic_cast<SMESHGUI*>( module );
2142 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2144 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2147 _PTR(Study) aStudy = study->studyDS();
2149 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2158 Standard_EXPORT SMESHGUI* GetComponentGUI()
2160 return SMESHGUI::GetSMESHGUI();
2164 //=============================================================================
2168 //=============================================================================
2169 void SMESHGUI::SetState(int aState)
2174 //=============================================================================
2178 //=============================================================================
2179 void SMESHGUI::ResetState()
2184 //=============================================================================
2188 //=============================================================================
2189 void SMESHGUI::EmitSignalDeactivateDialog()
2191 emit SignalDeactivateActiveDialog();
2194 //=============================================================================
2198 //=============================================================================
2199 void SMESHGUI::EmitSignalStudyFrameChanged()
2201 emit SignalStudyFrameChanged();
2204 //=============================================================================
2208 //=============================================================================
2209 void SMESHGUI::EmitSignalCloseAllDialogs()
2211 emit SignalCloseAllDialogs();
2214 //=============================================================================
2218 //=============================================================================
2219 void SMESHGUI::EmitSignalVisibilityChanged()
2221 emit SignalVisibilityChanged();
2224 //=============================================================================
2228 //=============================================================================
2229 QDialog *SMESHGUI::GetActiveDialogBox()
2231 return myActiveDialogBox;
2234 //=============================================================================
2238 //=============================================================================
2239 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2241 myActiveDialogBox = (QDialog *) aDlg;
2245 //=============================================================================
2249 //=============================================================================
2250 SUIT_Desktop* SMESHGUI::desktop()
2252 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2254 return app->desktop();
2259 //=============================================================================
2263 //=============================================================================
2264 SalomeApp_Study* SMESHGUI::activeStudy()
2266 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2268 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2273 //=============================================================================
2277 //=============================================================================
2278 void SMESHGUI::Modified( bool theIsUpdateActions )
2280 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2281 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2282 appStudy->Modified();
2283 if( theIsUpdateActions )
2284 app->updateActions();
2289 //=============================================================================
2293 //=============================================================================
2294 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2296 /* Here the position is on the bottom right corner - 10 */
2297 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2299 SUIT_Desktop *PP = desktop();
2300 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2301 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2305 //=============================================================================
2309 //=============================================================================
2310 static int isStudyLocked(_PTR(Study) theStudy){
2311 return theStudy->GetProperties()->IsLocked();
2314 static bool checkLock(_PTR(Study) theStudy) {
2315 if (isStudyLocked(theStudy)) {
2316 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2317 QObject::tr("WRN_WARNING"),
2318 QObject::tr("WRN_STUDY_LOCKED") );
2324 //=======================================================================
2325 //function : CheckActiveStudyLocked
2327 //=======================================================================
2329 bool SMESHGUI::isActiveStudyLocked()
2331 _PTR(Study) aStudy = activeStudy()->studyDS();
2332 return checkLock( aStudy );
2335 //=============================================================================
2339 //=============================================================================
2340 bool SMESHGUI::OnGUIEvent( int theCommandID )
2342 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2346 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2347 SUIT_ResourceMgr* mgr = resourceMgr();
2351 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2352 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2355 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2356 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2358 //QAction* act = action( theCommandID );
2360 switch (theCommandID) {
2361 case SMESHOp::OpDelete:
2362 if(checkLock(aStudy)) break;
2365 case SMESHOp::OpImportDAT:
2366 case SMESHOp::OpImportUNV:
2367 case SMESHOp::OpImportMED:
2368 case SMESHOp::OpImportSTL:
2370 case SMESHOp::OpImportCGNS:
2372 case SMESHOp::OpImportSAUV:
2373 case SMESHOp::OpImportGMF:
2375 if(checkLock(aStudy)) break;
2376 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2380 case SMESHOp::OpFileInformation:
2382 SALOME_ListIO selected;
2383 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2385 aSel->selectedObjects( selected );
2386 if( selected.Extent() )
2388 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2389 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2390 if ( !aMesh->_is_nil() )
2392 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2398 case SMESHOp::OpExportDAT:
2399 case SMESHOp::OpExportMED:
2400 case SMESHOp::OpExportUNV:
2401 case SMESHOp::OpExportSTL:
2403 case SMESHOp::OpExportCGNS:
2405 case SMESHOp::OpExportSAUV:
2406 case SMESHOp::OpExportGMF:
2407 case SMESHOp::OpPopupExportDAT:
2408 case SMESHOp::OpPopupExportMED:
2409 case SMESHOp::OpPopupExportUNV:
2410 case SMESHOp::OpPopupExportSTL:
2412 case SMESHOp::OpPopupExportCGNS:
2414 case SMESHOp::OpPopupExportSAUV:
2415 case SMESHOp::OpPopupExportGMF:
2417 ::ExportMeshToFile(theCommandID);
2421 case SMESHOp::OpReset: // SCALAR BAR
2423 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2424 SALOME_ListIO selected;
2426 aSel->selectedObjects( selected );
2428 if( selected.Extent() ) {
2429 Handle(SALOME_InteractiveObject) anIO = selected.First();
2430 if( anIO->hasEntry() ) {
2431 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2432 anActor->SetControlMode( SMESH_Actor::eNone );
2433 #ifndef DISABLE_PLOT2DVIEWER
2434 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2441 case SMESHOp::OpScalarBarProperties:
2443 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2446 case SMESHOp::OpSaveDistribution:
2448 // dump control distribution data to the text file
2449 ::SaveDistribution();
2453 case SMESHOp::OpShowDistribution:
2455 // show/ distribution
2456 ::ShowDistribution();
2460 #ifndef DISABLE_PLOT2DVIEWER
2461 case SMESHOp::OpPlotDistribution:
2463 // plot distribution
2464 ::PlotDistribution();
2470 case SMESHOp::OpAutoColor:
2474 case SMESHOp::OpDisableAutoColor:
2475 ::DisableAutoColor();
2478 case SMESHOp::OpClipping:
2479 case SMESHOp::OpTransparency:
2480 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2483 case SMESHOp::OpDMWireframe:
2484 case SMESHOp::OpDMShading:
2485 case SMESHOp::OpDMNodes:
2486 case SMESHOp::OpDMShrink:
2487 ::SetDisplayMode(theCommandID, myMarkerMap);
2490 //2D quadratic representation
2491 case SMESHOp::OpRepresentationLines:
2492 case SMESHOp::OpRepresentationArcs:
2493 ::SetDisplayMode(theCommandID, myMarkerMap);
2497 case SMESHOp::OpDE0DElements:
2498 case SMESHOp::OpDEEdges:
2499 case SMESHOp::OpDEFaces:
2500 case SMESHOp::OpDEVolumes:
2501 case SMESHOp::OpDEBalls:
2502 case SMESHOp::OpDEAllEntity:
2503 ::SetDisplayEntity(theCommandID);
2506 case SMESHOp::OpOrientationOnFaces:
2508 LightApp_SelectionMgr* mgr = selectionMgr();
2509 SALOME_ListIO selected; mgr->selectedObjects( selected );
2511 SALOME_ListIteratorOfListIO it(selected);
2512 for( ; it.More(); it.Next()) {
2513 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2514 if(anIObject->hasEntry()) {
2515 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2516 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2523 case SMESHOp::OpUpdate:
2525 if(checkLock(aStudy)) break;
2526 SUIT_OverrideCursor wc;
2528 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2531 SMESH::UpdateView();
2533 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2534 SMESH::OnVisuException();
2536 catch (...) { // PAL16774 (Crash after display of many groups)
2537 SMESH::OnVisuException();
2541 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2542 aSel->selectedObjects( l );
2543 aSel->setSelectedObjects( l );
2547 case SMESHOp::OpHide:
2548 case SMESHOp::OpShow:
2549 case SMESHOp::OpShowOnly:
2551 SMESH::EDisplaing anAction;
2552 switch (theCommandID) {
2553 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2554 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2555 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2558 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2559 SALOME_ListIO sel_objects, to_process;
2561 aSel->selectedObjects( sel_objects );
2563 if( theCommandID==SMESHOp::OpShowOnly )
2565 MESSAGE("anAction = SMESH::eDisplayOnly");
2566 startOperation( myEraseAll );
2569 extractContainers( sel_objects, to_process );
2572 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2576 SALOME_ListIteratorOfListIO It( to_process );
2577 for ( ; It.More(); It.Next()) {
2579 Handle(SALOME_InteractiveObject) IOS = It.Value();
2580 if (IOS->hasEntry()) {
2582 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2583 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2584 break; // PAL16774 (Crash after display of many groups)
2586 if (anAction == SMESH::eDisplayOnly)
2588 MESSAGE("anAction = SMESH::eDisplayOnly");
2589 anAction = SMESH::eDisplay;
2595 // PAL13338 + PAL15161 -->
2596 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2597 MESSAGE("anAction = SMESH::eDisplayOnly");
2598 SMESH::UpdateView();
2599 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2601 // PAL13338 + PAL15161 <--
2603 catch (...) { // PAL16774 (Crash after display of many groups)
2604 SMESH::OnVisuException();
2607 if (anAction == SMESH::eErase) {
2608 MESSAGE("anAction == SMESH::eErase");
2610 aSel->setSelectedObjects( l1 );
2613 aSel->setSelectedObjects( to_process );
2618 case SMESHOp::OpNode:
2620 if(checkLock(aStudy)) break;
2623 EmitSignalDeactivateDialog();
2625 ( new SMESHGUI_NodesDlg( this ) )->show();
2628 SUIT_MessageBox::warning(desktop(),
2629 tr("SMESH_WRN_WARNING"),
2630 tr("SMESH_WRN_VIEWER_VTK"));
2635 case SMESHOp::OpCreateMesh:
2636 case SMESHOp::OpCreateSubMesh:
2637 case SMESHOp::OpEditMeshOrSubMesh:
2638 case SMESHOp::OpCompute:
2639 case SMESHOp::OpPreCompute:
2640 case SMESHOp::OpEvaluate:
2641 case SMESHOp::OpMeshOrder:
2642 startOperation( theCommandID );
2644 case SMESHOp::OpCopyMesh:
2646 if (checkLock(aStudy)) break;
2647 EmitSignalDeactivateDialog();
2648 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2651 case SMESHOp::OpBuildCompoundMesh:
2653 if (checkLock(aStudy)) break;
2654 EmitSignalDeactivateDialog();
2655 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2659 case SMESHOp::OpDiagonalInversion:
2660 case SMESHOp::OpUnionOfTwoTriangle:
2664 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2665 tr( "NOT_A_VTK_VIEWER" ) );
2669 if ( checkLock( aStudy ) )
2672 /*Standard_Boolean aRes;
2673 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2674 if ( aMesh->_is_nil() )
2676 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2677 tr( "SMESH_BAD_SELECTION" ) );
2681 EmitSignalDeactivateDialog();
2682 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2683 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2685 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2688 case SMESHOp::OpOrientation:
2689 case SMESHOp::OpUnionOfTriangles:
2690 case SMESHOp::OpCuttingOfQuadrangles:
2691 case SMESHOp::OpSplitVolumes:
2695 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2696 tr( "NOT_A_VTK_VIEWER" ) );
2700 if ( checkLock( aStudy ) )
2703 EmitSignalDeactivateDialog();
2704 SMESHGUI_MultiEditDlg* aDlg = NULL;
2705 if ( theCommandID == SMESHOp::OpOrientation )
2706 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2707 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2708 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2709 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2710 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2712 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2717 case SMESHOp::OpSmoothing:
2719 if(checkLock(aStudy)) break;
2721 EmitSignalDeactivateDialog();
2722 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2725 SUIT_MessageBox::warning(desktop(),
2726 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2730 case SMESHOp::OpExtrusion:
2732 if (checkLock(aStudy)) break;
2734 EmitSignalDeactivateDialog();
2735 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2737 SUIT_MessageBox::warning(desktop(),
2738 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2742 case SMESHOp::OpExtrusionAlongAPath:
2744 if (checkLock(aStudy)) break;
2746 EmitSignalDeactivateDialog();
2747 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2749 SUIT_MessageBox::warning(desktop(),
2750 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2754 case SMESHOp::OpRevolution:
2756 if(checkLock(aStudy)) break;
2758 EmitSignalDeactivateDialog();
2759 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2762 SUIT_MessageBox::warning(desktop(),
2763 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2767 case SMESHOp::OpPatternMapping:
2769 if ( checkLock( aStudy ) )
2773 EmitSignalDeactivateDialog();
2774 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2777 SUIT_MessageBox::warning(desktop(),
2778 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2782 case SMESHOp::OpConvertMeshToQuadratic:
2783 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2784 case SMESHOp::OpReorientFaces:
2785 case SMESHOp::OpCreateGeometryGroup:
2787 startOperation( theCommandID );
2790 case SMESHOp::OpCreateGroup:
2794 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2795 tr( "NOT_A_VTK_VIEWER" ) );
2799 if(checkLock(aStudy)) break;
2800 EmitSignalDeactivateDialog();
2801 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2803 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2804 SALOME_ListIO selected;
2806 aSel->selectedObjects( selected );
2808 int nbSel = selected.Extent();
2810 // check if mesh is selected
2811 aMesh = SMESH::GetMeshByIO( selected.First() );
2813 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2818 case SMESHOp::OpConstructGroup:
2822 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2823 tr( "NOT_A_VTK_VIEWER" ) );
2827 if(checkLock(aStudy)) break;
2828 EmitSignalDeactivateDialog();
2830 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2831 SALOME_ListIO selected;
2833 aSel->selectedObjects( selected );
2835 int nbSel = selected.Extent();
2837 // check if submesh is selected
2838 Handle(SALOME_InteractiveObject) IObject = selected.First();
2839 if (IObject->hasEntry()) {
2840 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2842 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2843 if (!aSubMesh->_is_nil()) {
2845 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2846 // get submesh elements list by types
2847 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2848 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2849 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2850 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2851 // create group for each type o elements
2852 QString aName = IObject->getName();
2853 QStringList anEntryList;
2854 if (aNodes->length() > 0) {
2855 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2856 aGroup->Add(aNodes.inout());
2857 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2858 anEntryList.append( aSObject->GetID().c_str() );
2860 if (aEdges->length() > 0) {
2861 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2862 aGroup->Add(aEdges.inout());
2863 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2864 anEntryList.append( aSObject->GetID().c_str() );
2866 if (aFaces->length() > 0) {
2867 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2868 aGroup->Add(aFaces.inout());
2869 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2870 anEntryList.append( aSObject->GetID().c_str() );
2872 if (aVolumes->length() > 0) {
2873 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2874 aGroup->Add(aVolumes.inout());
2875 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2876 anEntryList.append( aSObject->GetID().c_str() );
2879 anApp->browseObjects( anEntryList );
2881 catch(const SALOME::SALOME_Exception & S_ex){
2882 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2889 SUIT_MessageBox::warning(desktop(),
2890 tr("SMESH_WRN_WARNING"),
2891 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2896 case SMESHOp::OpEditGroup:
2900 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2901 tr( "NOT_A_VTK_VIEWER" ) );
2905 if(checkLock(aStudy)) break;
2906 EmitSignalDeactivateDialog();
2908 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2909 SALOME_ListIO selected;
2911 aSel->selectedObjects( selected );
2913 SALOME_ListIteratorOfListIO It (selected);
2914 int nbSelectedGroups = 0;
2915 for ( ; It.More(); It.Next() )
2917 SMESH::SMESH_GroupBase_var aGroup =
2918 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2919 if (!aGroup->_is_nil()) {
2921 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2925 if (nbSelectedGroups == 0)
2927 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2933 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
2935 if(checkLock(aStudy)) break;
2936 if (myState == 800) {
2937 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2938 if (aDlg) aDlg->onAdd();
2943 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
2945 if(checkLock(aStudy)) break;
2946 if (myState == 800) {
2947 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2948 if (aDlg) aDlg->onRemove();
2953 case SMESHOp::OpEditGeomGroupAsGroup:
2957 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2958 tr( "NOT_A_VTK_VIEWER" ) );
2962 if(checkLock(aStudy)) break;
2963 EmitSignalDeactivateDialog();
2965 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2966 SALOME_ListIO selected;
2968 aSel->selectedObjects( selected );
2970 SALOME_ListIteratorOfListIO It (selected);
2971 for ( ; It.More(); It.Next() )
2973 SMESH::SMESH_GroupOnGeom_var aGroup =
2974 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2975 if (!aGroup->_is_nil()) {
2976 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2981 SMESH::SMESH_GroupOnFilter_var aGroup =
2982 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2983 if (!aGroup->_is_nil()) {
2984 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2992 case SMESHOp::OpUnionGroups:
2993 case SMESHOp::OpIntersectGroups:
2994 case SMESHOp::OpCutGroups:
2998 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2999 tr( "NOT_A_VTK_VIEWER" ) );
3003 if ( checkLock( aStudy ) )
3006 EmitSignalDeactivateDialog();
3008 SMESHGUI_GroupOpDlg* aDlg = 0;
3009 if ( theCommandID == SMESHOp::OpUnionGroups )
3010 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3011 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3012 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3014 aDlg = new SMESHGUI_CutGroupsDlg( this );
3021 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3023 if ( checkLock( aStudy ) )
3026 EmitSignalDeactivateDialog();
3027 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3033 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3037 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3038 tr( "NOT_A_VTK_VIEWER" ) );
3042 if ( checkLock( aStudy ) )
3045 EmitSignalDeactivateDialog();
3047 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3051 case SMESHOp::OpMeshInformation:
3052 case SMESHOp::OpWhatIs:
3054 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3055 EmitSignalDeactivateDialog();
3056 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3057 SALOME_ListIO selected;
3059 aSel->selectedObjects( selected );
3061 if ( selected.Extent() > 1 ) { // a dlg for each IO
3062 SALOME_ListIteratorOfListIO It( selected );
3063 for ( ; It.More(); It.Next() ) {
3064 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3065 dlg->showInfo( It.Value() );
3070 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3076 case SMESHOp::OpFindElementByPoint:
3078 startOperation( theCommandID );
3082 case SMESHOp::OpEditHypothesis:
3084 if(checkLock(aStudy)) break;
3086 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3087 SALOME_ListIO selected;
3089 aSel->selectedObjects( selected );
3091 int nbSel = selected.Extent();
3094 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3095 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3097 if ( !aHypothesis->_is_nil() )
3099 SMESHGUI_GenericHypothesisCreator* aCreator =
3100 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3103 // set geometry of mesh and sub-mesh to aCreator
3104 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3105 if ( selected.Extent() == 1 )
3107 QString subGeomID, meshGeomID;
3108 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3109 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3111 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3112 aCreator->setShapeEntry( subGeomID );
3113 aCreator->setMainShapeEntry( meshGeomID );
3117 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3127 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3129 if(checkLock(aStudy)) break;
3130 SUIT_OverrideCursor wc;
3132 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3133 SALOME_ListIO selected;
3135 aSel->selectedObjects( selected, QString::null, false );
3137 SALOME_ListIteratorOfListIO It(selected);
3138 for (int i = 0; It.More(); It.Next(), i++) {
3139 Handle(SALOME_InteractiveObject) IObject = It.Value();
3140 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3143 aSel->setSelectedObjects( l1 );
3148 case SMESHOp::OpElem0D:
3149 case SMESHOp::OpBall:
3150 case SMESHOp::OpEdge:
3151 case SMESHOp::OpTriangle:
3152 case SMESHOp::OpQuadrangle:
3153 case SMESHOp::OpPolygon:
3154 case SMESHOp::OpTetrahedron:
3155 case SMESHOp::OpHexahedron:
3156 case SMESHOp::OpPentahedron:
3157 case SMESHOp::OpPyramid:
3158 case SMESHOp::OpHexagonalPrism:
3160 if(checkLock(aStudy)) break;
3162 EmitSignalDeactivateDialog();
3163 SMDSAbs_EntityType type = SMDSEntity_Edge;
3164 switch (theCommandID) {
3165 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3166 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3167 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3168 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3169 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3170 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3171 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3172 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3173 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3174 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3177 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3180 SUIT_MessageBox::warning(desktop(),
3181 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3185 case SMESHOp::OpPolyhedron:
3187 if(checkLock(aStudy)) break;
3189 EmitSignalDeactivateDialog();
3190 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3193 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3194 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3198 case SMESHOp::OpQuadraticEdge:
3199 case SMESHOp::OpQuadraticTriangle:
3200 case SMESHOp::OpBiQuadraticTriangle:
3201 case SMESHOp::OpQuadraticQuadrangle:
3202 case SMESHOp::OpBiQuadraticQuadrangle:
3203 case SMESHOp::OpQuadraticTetrahedron:
3204 case SMESHOp::OpQuadraticPyramid:
3205 case SMESHOp::OpQuadraticPentahedron:
3206 case SMESHOp::OpQuadraticHexahedron:
3207 case SMESHOp::OpTriQuadraticHexahedron:
3209 if(checkLock(aStudy)) break;
3211 EmitSignalDeactivateDialog();
3212 SMDSAbs_EntityType type = SMDSEntity_Last;
3214 switch (theCommandID) {
3215 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3216 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3217 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3218 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3219 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3220 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3221 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3222 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3223 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3224 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3227 if ( type != SMDSEntity_Last )
3228 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3231 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3232 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3236 case SMESHOp::OpRemoveNodes:
3238 if(checkLock(aStudy)) break;
3240 EmitSignalDeactivateDialog();
3241 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3244 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3245 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3249 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3251 if(checkLock(aStudy)) break;
3253 EmitSignalDeactivateDialog();
3254 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3258 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3259 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3263 case SMESHOp::OpClearMesh: {
3265 if(checkLock(aStudy)) break;
3267 SALOME_ListIO selected;
3268 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3269 aSel->selectedObjects( selected );
3271 SUIT_OverrideCursor wc;
3272 SALOME_ListIteratorOfListIO It (selected);
3273 for ( ; It.More(); It.Next() )
3275 Handle(SALOME_InteractiveObject) IOS = It.Value();
3276 SMESH::SMESH_Mesh_var aMesh =
3277 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3278 if ( aMesh->_is_nil()) continue;
3280 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3282 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3283 SMESH::ModifiedMesh( aMeshSObj, false, true);
3284 // hide groups and submeshes
3285 _PTR(ChildIterator) anIter =
3286 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3287 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3289 _PTR(SObject) so = anIter->Value();
3290 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3293 catch (const SALOME::SALOME_Exception& S_ex){
3295 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3299 SMESH::UpdateView();
3303 case SMESHOp::OpRemoveOrphanNodes:
3305 if(checkLock(aStudy)) break;
3306 SALOME_ListIO selected;
3307 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3308 aSel->selectedObjects( selected );
3309 if ( selected.Extent() == 1 ) {
3310 Handle(SALOME_InteractiveObject) anIO = selected.First();
3311 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3312 if ( !aMesh->_is_nil() ) {
3313 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3314 tr( "SMESH_WARNING" ),
3315 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3316 SUIT_MessageBox::Yes |
3317 SUIT_MessageBox::No,
3318 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3321 SUIT_OverrideCursor wc;
3322 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3323 int removed = aMeshEditor->RemoveOrphanNodes();
3324 SUIT_MessageBox::information(SMESHGUI::desktop(),
3325 tr("SMESH_INFORMATION"),
3326 tr("NB_NODES_REMOVED").arg(removed));
3327 if ( removed > 0 ) {
3328 SMESH::UpdateView();
3329 SMESHGUI::Modified();
3332 catch (const SALOME::SALOME_Exception& S_ex) {
3333 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3342 case SMESHOp::OpRenumberingNodes:
3344 if(checkLock(aStudy)) break;
3346 EmitSignalDeactivateDialog();
3347 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3351 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3352 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3356 case SMESHOp::OpRenumberingElements:
3358 if(checkLock(aStudy)) break;
3360 EmitSignalDeactivateDialog();
3361 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3365 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3366 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3370 case SMESHOp::OpTranslation:
3372 if(checkLock(aStudy)) break;
3374 EmitSignalDeactivateDialog();
3375 ( new SMESHGUI_TranslationDlg( this ) )->show();
3378 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3379 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3383 case SMESHOp::OpRotation:
3385 if(checkLock(aStudy)) break;
3387 EmitSignalDeactivateDialog();
3388 ( new SMESHGUI_RotationDlg( this ) )->show();
3391 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3392 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3396 case SMESHOp::OpSymmetry:
3398 if(checkLock(aStudy)) break;
3400 EmitSignalDeactivateDialog();
3401 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3404 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3405 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3409 case SMESHOp::OpScale:
3411 if(checkLock(aStudy)) break;
3413 EmitSignalDeactivateDialog();
3414 ( new SMESHGUI_ScaleDlg( this ) )->show();
3417 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3418 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3423 case SMESHOp::OpSewing:
3425 if(checkLock(aStudy)) break;
3427 EmitSignalDeactivateDialog();
3428 ( new SMESHGUI_SewingDlg( this ) )->show();
3431 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3432 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3436 case SMESHOp::OpMergeNodes:
3438 if(checkLock(aStudy)) break;
3440 EmitSignalDeactivateDialog();
3441 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3444 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3445 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3449 case SMESHOp::OpMergeElements:
3451 if (checkLock(aStudy)) break;
3453 EmitSignalDeactivateDialog();
3454 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3456 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3457 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3462 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3463 startOperation( SMESHOp::OpMoveNode );
3466 case SMESHOp::OpDuplicateNodes:
3468 if(checkLock(aStudy)) break;
3470 EmitSignalDeactivateDialog();
3471 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3474 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3475 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3480 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3481 startOperation( SMESHOp::OpElem0DOnElemNodes );
3484 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3486 static QList<int> aTypes;
3487 if ( aTypes.isEmpty() )
3489 aTypes.append( SMESH::NODE );
3490 aTypes.append( SMESH::EDGE );
3491 aTypes.append( SMESH::FACE );
3492 aTypes.append( SMESH::VOLUME );
3494 if (!myFilterLibraryDlg)
3495 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3496 else if (myFilterLibraryDlg->isHidden())
3497 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3498 myFilterLibraryDlg->raise();
3502 case SMESHOp::OpFreeNode:
3503 case SMESHOp::OpEqualNode:
3504 case SMESHOp::OpFreeEdge:
3505 case SMESHOp::OpFreeBorder:
3506 case SMESHOp::OpLength:
3507 case SMESHOp::OpConnection:
3508 case SMESHOp::OpEqualEdge:
3509 case SMESHOp::OpFreeFace:
3510 case SMESHOp::OpBareBorderFace:
3511 case SMESHOp::OpOverConstrainedFace:
3512 case SMESHOp::OpLength2D:
3513 case SMESHOp::OpConnection2D:
3514 case SMESHOp::OpArea:
3515 case SMESHOp::OpTaper:
3516 case SMESHOp::OpAspectRatio:
3517 case SMESHOp::OpMinimumAngle:
3518 case SMESHOp::OpWarpingAngle:
3519 case SMESHOp::OpSkew:
3520 case SMESHOp::OpMaxElementLength2D:
3521 case SMESHOp::OpEqualFace:
3522 case SMESHOp::OpAspectRatio3D:
3523 case SMESHOp::OpVolume:
3524 case SMESHOp::OpMaxElementLength3D:
3525 case SMESHOp::OpBareBorderVolume:
3526 case SMESHOp::OpOverConstrainedVolume:
3527 case SMESHOp::OpEqualVolume:
3530 LightApp_SelectionMgr* mgr = selectionMgr();
3531 SALOME_ListIO selected; mgr->selectedObjects( selected );
3533 if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3534 _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3536 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3537 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
3538 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3539 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
3540 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3541 SUIT_OverrideCursor wc;
3542 ::Control( theCommandID );
3547 SUIT_MessageBox::warning(desktop(),
3548 tr( "SMESH_WRN_WARNING" ),
3549 tr( "SMESH_BAD_SELECTION" ) );
3553 SUIT_MessageBox::warning(desktop(),
3554 tr( "SMESH_WRN_WARNING" ),
3555 tr( "NOT_A_VTK_VIEWER" ) );
3558 case SMESHOp::OpOverallMeshQuality:
3559 OverallMeshQuality();
3561 case SMESHOp::OpNumberingNodes:
3563 SUIT_OverrideCursor wc;
3564 LightApp_SelectionMgr* mgr = selectionMgr();
3565 SALOME_ListIO selected; mgr->selectedObjects( selected );
3567 SALOME_ListIteratorOfListIO it(selected);
3568 for( ; it.More(); it.Next()) {
3569 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3570 if(anIObject->hasEntry()) {
3571 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3572 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3578 case SMESHOp::OpNumberingElements:
3580 SUIT_OverrideCursor wc;
3581 LightApp_SelectionMgr* mgr = selectionMgr();
3582 SALOME_ListIO selected; mgr->selectedObjects( selected );
3584 SALOME_ListIteratorOfListIO it(selected);
3585 for( ; it.More(); it.Next()) {
3586 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3587 if(anIObject->hasEntry())
3588 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3589 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3594 case SMESHOp::OpPropertiesLength:
3595 case SMESHOp::OpPropertiesArea:
3596 case SMESHOp::OpPropertiesVolume:
3597 case SMESHOp::OpMinimumDistance:
3598 case SMESHOp::OpBoundingBox:
3600 int page = SMESHGUI_MeasureDlg::MinDistance;
3601 if ( theCommandID == SMESHOp::OpBoundingBox )
3602 page = SMESHGUI_MeasureDlg::BoundingBox;
3603 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3604 page = SMESHGUI_MeasureDlg::Length;
3605 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3606 page = SMESHGUI_MeasureDlg::Area;
3607 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3608 page = SMESHGUI_MeasureDlg::Volume;
3610 EmitSignalDeactivateDialog();
3611 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3615 case SMESHOp::OpSortChild:
3621 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3622 //updateObjBrowser();
3626 //=============================================================================
3630 //=============================================================================
3631 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3636 //=============================================================================
3640 //=============================================================================
3641 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3646 //=============================================================================
3650 //=============================================================================
3651 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3656 //=============================================================================
3657 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3658 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3660 //=============================================================================
3661 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3662 SUIT_ViewWindow* wnd )
3664 if(theIO->hasEntry()){
3665 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3666 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3670 //=======================================================================
3671 // function : createSMESHAction
3673 //=======================================================================
3674 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3675 const int key, const bool toggle, const QString& shortcutAction )
3678 QWidget* parent = application()->desktop();
3679 SUIT_ResourceMgr* resMgr = resourceMgr();
3681 if ( !icon_id.isEmpty() )
3682 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3684 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3685 if ( !pix.isNull() )
3686 icon = QIcon( pix );
3688 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3689 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3690 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3692 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3693 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3696 //=======================================================================
3697 // function : createPopupItem
3699 //=======================================================================
3700 void SMESHGUI::createPopupItem( const int id,
3701 const QString& clients,
3702 const QString& types,
3703 const QString& theRule,
3706 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3707 popupMgr()->insert( action( id ), pId, 0 );
3709 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3710 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3711 QString rule = "(%1) and (%2) and (%3)";
3712 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3713 if( clients.isEmpty() )
3714 rule = rule.arg( QString( "true" ) );
3716 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3717 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3720 bool cont = myRules.contains( id );
3722 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3724 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3725 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3728 //=======================================================================
3729 // function : initialize
3731 //=======================================================================
3732 void SMESHGUI::initialize( CAM_Application* app )
3734 SalomeApp_Module::initialize( app );
3736 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3738 /* Automatic Update flag */
3739 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3741 // ----- create actions --------------
3743 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3744 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3745 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3746 //createSMESHAction( 114, "NUM" );
3747 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3749 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3751 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3752 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3753 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3754 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3755 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3756 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3758 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3760 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3761 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3762 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3763 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3764 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3765 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3767 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3769 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3770 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3771 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3772 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3773 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3774 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3775 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3776 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3777 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3778 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3779 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3780 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3781 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_COMPUTE" );
3782 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_COMPUTE" );
3783 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3784 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3785 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3786 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3787 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3788 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3789 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3790 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3791 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3792 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3793 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3794 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3795 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3796 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3797 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3798 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3800 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3801 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3802 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3803 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3804 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3805 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3806 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3807 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3808 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3809 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3810 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3811 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3812 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3813 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3814 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3815 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3816 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3817 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3818 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3819 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3820 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3821 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3822 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3823 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3824 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3825 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3826 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3828 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3829 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3830 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3831 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3832 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3833 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3834 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3835 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3836 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3837 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3838 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3839 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3840 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3841 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3842 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3843 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3844 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3845 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3846 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3847 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3848 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3849 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3850 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3851 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3853 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3854 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3855 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3856 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3858 createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3859 createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3861 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3862 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3863 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3864 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3865 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3866 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3867 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3868 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3869 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3870 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3871 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3872 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3873 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3874 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3875 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3876 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3877 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3878 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3879 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3880 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3881 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3882 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3883 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3885 createSMESHAction( SMESHOp::OpReset, "RESET" );
3886 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3887 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3888 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3889 #ifndef DISABLE_PLOT2DVIEWER
3890 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3892 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3893 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3894 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3895 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3896 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3897 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3898 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3899 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3900 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3901 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3902 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL" );
3903 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3905 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3906 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3908 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3909 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3910 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3911 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3912 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3913 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3914 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3915 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3916 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3918 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3919 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3920 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3921 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3922 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
3924 createSMESHAction( SMESHOp::OpHide, "HIDE" );
3925 createSMESHAction( SMESHOp::OpShow, "SHOW" );
3926 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
3928 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
3930 // ----- create menu --------------
3931 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3932 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3933 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3934 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3935 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3936 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3937 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3938 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3940 createMenu( separator(), fileId );
3942 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3943 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3944 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3945 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3946 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3947 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3948 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3949 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3950 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3951 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
3952 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
3954 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
3955 createMenu( SMESHOp::OpImportUNV, importId, -1 );
3956 createMenu( SMESHOp::OpImportMED, importId, -1 );
3957 createMenu( SMESHOp::OpImportSTL, importId, -1 );
3959 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
3961 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
3962 createMenu( SMESHOp::OpImportGMF, importId, -1 );
3963 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
3964 createMenu( SMESHOp::OpExportMED, exportId, -1 );
3965 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
3966 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
3968 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
3970 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
3971 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
3972 createMenu( separator(), fileId, 10 );
3974 createMenu( SMESHOp::OpDelete, editId, -1 );
3976 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
3978 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
3979 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
3980 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
3981 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
3982 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
3983 createMenu( separator(), meshId, -1 );
3984 createMenu( SMESHOp::OpCompute, meshId, -1 );
3985 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
3986 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
3987 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
3988 createMenu( separator(), meshId, -1 );
3989 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
3990 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
3991 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
3992 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
3993 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
3994 createMenu( separator(), meshId, -1 );
3995 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
3996 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
3997 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
3998 createMenu( separator(), meshId, -1 );
3999 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4000 createMenu( separator(), meshId, -1 );
4001 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4002 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4003 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4004 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4005 createMenu( separator(), meshId, -1 );
4007 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4008 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4009 createMenu( SMESHOp::OpFreeEdge, edgeId, -1 );
4010 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4011 createMenu( SMESHOp::OpLength, edgeId, -1 );
4012 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4013 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4014 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4015 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4016 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4017 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4018 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4019 createMenu( SMESHOp::OpArea, faceId, -1 );
4020 createMenu( SMESHOp::OpTaper, faceId, -1 );
4021 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4022 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4023 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4024 createMenu( SMESHOp::OpSkew, faceId, -1 );
4025 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4026 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4027 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4028 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4029 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4030 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4031 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4032 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4033 createMenu( separator(), ctrlId, -1 );
4034 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4036 createMenu( SMESHOp::OpNode, addId, -1 );
4037 createMenu( SMESHOp::OpElem0D, addId, -1 );
4038 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4039 createMenu( SMESHOp::OpBall, addId, -1 );
4040 createMenu( SMESHOp::OpEdge, addId, -1 );
4041 createMenu( SMESHOp::OpTriangle, addId, -1 );
4042 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4043 createMenu( SMESHOp::OpPolygon, addId, -1 );
4044 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4045 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4046 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4047 createMenu( SMESHOp::OpPyramid, addId, -1 );
4048 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4049 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4050 createMenu( separator(), addId, -1 );
4051 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4052 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4053 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4054 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4055 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4056 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4057 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4058 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4059 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4060 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4062 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4063 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4064 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4065 createMenu( separator(), removeId, -1 );
4066 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4067 createMenu( separator(), removeId, -1 );
4068 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4070 createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4071 createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4073 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4074 createMenu( SMESHOp::OpRotation, transfId, -1 );
4075 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4076 createMenu( SMESHOp::OpScale, transfId, -1 );
4077 createMenu( SMESHOp::OpSewing, transfId, -1 );
4078 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4079 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4080 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4082 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4083 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4084 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4085 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4086 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4087 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4088 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4089 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4090 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4091 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4092 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4093 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4094 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4095 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4096 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4098 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4099 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4100 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4101 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4102 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4103 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4105 // ----- create toolbars --------------
4106 int meshTb = createTool( tr( "TB_MESH" ) ),
4107 info = createTool( tr( "TB_INFO" ) ),
4108 groupTb = createTool( tr( "TB_GROUP" ) ),
4109 ctrl0dTb = createTool( tr( "TB_CTRL0D" ) ),
4110 ctrl1dTb = createTool( tr( "TB_CTRL1D" ) ),
4111 ctrl2dTb = createTool( tr( "TB_CTRL2D" ) ),
4112 ctrl3dTb = createTool( tr( "TB_CTRL3D" ) ),
4113 addElemTb = createTool( tr( "TB_ADD" ) ),
4114 addNonElemTb = createTool( tr( "TB_ADDNON" ) ),
4115 remTb = createTool( tr( "TB_REM" ) ),
4116 renumbTb = createTool( tr( "TB_RENUMBER" ) ),
4117 transformTb = createTool( tr( "TB_TRANSFORM" ) ),
4118 modifyTb = createTool( tr( "TB_MODIFY" ) ),
4119 measuremTb = createTool( tr( "TB_MEASUREM" ) ),
4120 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
4122 createTool( SMESHOp::OpCreateMesh, meshTb );
4123 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4124 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4125 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4126 createTool( SMESHOp::OpCopyMesh, meshTb );
4127 createTool( separator(), meshTb );
4128 createTool( SMESHOp::OpCompute, meshTb );
4129 createTool( SMESHOp::OpPreCompute, meshTb );
4130 createTool( SMESHOp::OpEvaluate, meshTb );
4131 createTool( SMESHOp::OpMeshOrder, meshTb );
4133 createTool( SMESHOp::OpCreateGroup, groupTb );
4134 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4135 createTool( SMESHOp::OpConstructGroup, groupTb );
4136 createTool( SMESHOp::OpEditGroup, groupTb );
4138 createTool( SMESHOp::OpMeshInformation, info );
4139 //createTool( SMESHOp::OpStdInfo, meshTb );
4140 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4141 createTool( SMESHOp::OpFindElementByPoint, info );
4143 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4144 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4146 createTool( SMESHOp::OpFreeEdge, ctrl1dTb );
4147 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4148 createTool( SMESHOp::OpLength, ctrl1dTb );
4149 createTool( SMESHOp::OpConnection, ctrl1dTb );
4150 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4152 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4153 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4154 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4155 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4156 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4157 createTool( SMESHOp::OpArea, ctrl2dTb );
4158 createTool( SMESHOp::OpTaper, ctrl2dTb );
4159 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4160 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4161 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4162 createTool( SMESHOp::OpSkew, ctrl2dTb );
4163 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4164 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4166 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4167 createTool( SMESHOp::OpVolume, ctrl3dTb );
4168 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4169 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4170 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4171 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4173 createTool( SMESHOp::OpNode, addElemTb );
4174 createTool( SMESHOp::OpElem0D, addElemTb );
4175 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4176 createTool( SMESHOp::OpBall, addElemTb );
4177 createTool( SMESHOp::OpEdge, addElemTb );
4178 createTool( SMESHOp::OpTriangle, addElemTb );
4179 createTool( SMESHOp::OpQuadrangle, addElemTb );
4180 createTool( SMESHOp::OpPolygon, addElemTb );
4181 createTool( SMESHOp::OpTetrahedron, addElemTb );
4182 createTool( SMESHOp::OpHexahedron, addElemTb );
4183 createTool( SMESHOp::OpPentahedron, addElemTb );
4184 createTool( SMESHOp::OpPyramid, addElemTb );
4185 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4186 createTool( SMESHOp::OpPolyhedron, addElemTb );
4188 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4189 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4190 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4191 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4192 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4193 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4194 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4195 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4196 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4197 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4199 createTool( SMESHOp::OpRemoveNodes, remTb );
4200 createTool( SMESHOp::OpRemoveElements, remTb );
4201 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4202 createTool( SMESHOp::OpClearMesh, remTb );
4204 createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4205 createTool( SMESHOp::OpRenumberingElements, renumbTb );
4207 createTool( SMESHOp::OpTranslation, transformTb );
4208 createTool( SMESHOp::OpRotation, transformTb );
4209 createTool( SMESHOp::OpSymmetry, transformTb );
4210 createTool( SMESHOp::OpScale, transformTb );
4211 createTool( SMESHOp::OpSewing, transformTb );
4212 createTool( SMESHOp::OpMergeNodes, transformTb );
4213 createTool( SMESHOp::OpMergeElements, transformTb );
4214 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4216 createTool( SMESHOp::OpMoveNode, modifyTb );
4217 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4218 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4219 createTool( SMESHOp::OpOrientation, modifyTb );
4220 createTool( SMESHOp::OpReorientFaces, modifyTb );
4221 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4222 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4223 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4224 createTool( SMESHOp::OpSmoothing, modifyTb );
4225 createTool( SMESHOp::OpExtrusion, modifyTb );
4226 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4227 createTool( SMESHOp::OpRevolution, modifyTb );
4228 createTool( SMESHOp::OpPatternMapping, modifyTb );
4229 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4230 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4232 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4234 createTool( SMESHOp::OpUpdate, dispModeTb );
4236 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4237 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4240 QString OB = "'ObjectBrowser'",
4241 View = "'" + SVTK_Viewer::Type() + "'",
4243 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4244 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4245 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4246 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4247 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4248 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4249 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4250 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4251 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4252 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4253 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4255 mesh_part = mesh + " " + subMesh + " " + group,
4256 mesh_group = mesh + " " + group,
4257 hyp_alg = hypo + " " + algo;
4259 // popup for object browser
4261 isInvisible("not( isVisible )"),
4262 isEmpty("numberOfNodes = 0"),
4263 isNotEmpty("numberOfNodes <> 0"),
4265 // has nodes, edges, etc in VISIBLE! actor
4266 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4267 hasElems("(count( elemTypes ) > 0)"),
4268 hasDifferentElems("(count( elemTypes ) > 1)"),
4269 hasBalls("({'BallElem'} in elemTypes)"),
4270 hasElems0d("({'Elem0d'} in elemTypes)"),
4271 hasEdges("({'Edge'} in elemTypes)"),
4272 hasFaces("({'Face'} in elemTypes)"),
4273 hasVolumes("({'Volume'} in elemTypes)");
4275 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4276 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& isComputable");
4277 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, mesh, "&& isComputable");
4278 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, subMesh, "&& isComputable" );
4279 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4280 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4282 popupMgr()->insert( separator(), -1, 0 );
4283 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& isComputable" );
4284 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& isComputable && isPreComputable" );
4285 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& isComputable" );
4286 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& isComputable" );
4287 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4288 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4289 createPopupItem( SMESHOp::OpFindElementByPoint, OB, mesh_group );
4290 createPopupItem( SMESHOp::OpOverallMeshQuality, OB, mesh_part );
4291 popupMgr()->insert( separator(), -1, 0 );
4292 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh );
4293 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh );
4294 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4295 popupMgr()->insert( separator(), -1, 0 );
4296 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo);
4297 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4298 popupMgr()->insert( separator(), -1, 0 );
4299 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4300 popupMgr()->insert( separator(), -1, 0 );
4301 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh + " " + subMesh ); // convert to quadratic
4302 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh + " " + group, // create 2D mesh from 3D
4304 popupMgr()->insert( separator(), -1, 0 );
4306 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4307 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4308 QString only_one_2D = only_one_non_empty + " && dim>1";
4310 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4311 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4312 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4313 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4315 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4317 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, multiple_non_empty, anId );
4318 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, multiple_non_empty, anId );
4319 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, multiple_non_empty, anId );
4320 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4321 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4322 popupMgr()->insert( separator(), -1, 0 );
4325 createPopupItem( SMESHOp::OpEditGroup, View, group );
4326 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4327 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4329 popupMgr()->insert( separator(), -1, 0 );
4330 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4331 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4332 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4333 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4334 popupMgr()->insert( separator(), -1, 0 );
4336 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4337 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4338 popupMgr()->insert( separator(), -1, 0 );
4340 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4341 QString aType = QString( "%1type in {%2}" ).arg( lc );
4342 aType = aType.arg( mesh_part );
4343 QString aMeshInVTK = aClient + "&&" + aType;
4345 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4346 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4347 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4349 //-------------------------------------------------
4351 //-------------------------------------------------
4352 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4354 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4355 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4356 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4358 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4359 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4360 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4362 popupMgr()->insert( separator(), -1, -1 );
4364 //-------------------------------------------------
4366 //-------------------------------------------------
4367 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4369 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4370 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4371 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4373 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4374 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4375 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4377 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4378 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4379 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4381 popupMgr()->insert( separator(), anId, -1 );
4383 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4384 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4385 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4387 //-------------------------------------------------
4389 //-------------------------------------------------
4390 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4392 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4394 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4395 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4396 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4398 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4399 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4400 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4402 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4403 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4404 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4406 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4407 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4408 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4410 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4411 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4412 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4414 popupMgr()->insert( separator(), anId, -1 );
4416 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4417 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4420 //-------------------------------------------------
4421 // Representation of the 2D Quadratic elements
4422 //-------------------------------------------------
4423 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4424 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4425 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4426 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4428 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4429 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4430 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4432 //-------------------------------------------------
4433 // Orientation of faces
4434 //-------------------------------------------------
4435 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4436 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4437 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4439 //-------------------------------------------------
4441 //-------------------------------------------------
4442 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4443 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4445 //-------------------------------------------------
4447 //-------------------------------------------------
4448 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4449 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4451 //-------------------------------------------------
4453 //-------------------------------------------------
4455 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4456 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4457 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4458 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4460 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4462 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4463 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4465 popupMgr()->insert( separator(), anId, -1 );
4467 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4469 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4470 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4471 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4473 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4474 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4475 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4477 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4479 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4480 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4481 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4483 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4484 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4485 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4487 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4488 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4489 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4491 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4492 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4493 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4494 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4495 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4496 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4498 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4500 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4501 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4502 QtxPopupMgr::VisibleRule );
4503 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4505 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4506 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4507 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4509 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4510 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4511 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4513 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4514 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4515 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4517 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4518 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4519 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4521 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4522 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4523 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4525 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4526 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4527 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4529 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4530 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4531 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4533 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4534 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4535 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4537 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4538 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4539 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4541 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4542 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4543 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4545 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4546 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4547 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4548 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4549 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4550 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4552 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4554 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4555 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4556 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4558 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4559 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4560 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4562 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4563 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4564 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4566 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4567 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4568 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4570 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4571 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4572 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4574 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4575 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4576 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4578 popupMgr()->insert( separator(), anId, -1 );
4580 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4581 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4583 popupMgr()->insert( separator(), anId, -1 );
4585 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4587 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4588 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4590 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4591 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4592 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4594 #ifndef DISABLE_PLOT2DVIEWER
4595 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4596 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4599 //-------------------------------------------------
4601 //-------------------------------------------------
4602 popupMgr()->insert( separator(), -1, -1 );
4603 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4604 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4605 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4606 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4608 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4609 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4611 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4612 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4614 popupMgr()->insert( separator(), -1, -1 );
4616 //-------------------------------------------------
4618 //-------------------------------------------------
4619 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4620 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4622 popupMgr()->insert( separator(), -1, -1 );
4624 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4625 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4626 popupMgr()->insert( separator(), -1, -1 );
4628 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4629 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4631 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4632 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4635 //================================================================================
4637 * \brief Return true if SMESH or GEOM objects are selected.
4638 * Is called form LightApp_Module::activateModule() which clear selection if
4639 * not isSelectionCompatible()
4641 //================================================================================
4643 bool SMESHGUI::isSelectionCompatible()
4645 bool isCompatible = true;
4646 SALOME_ListIO selected;
4647 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4648 Sel->selectedObjects( selected );
4650 SALOME_ListIteratorOfListIO It( selected );
4651 for ( ; isCompatible && It.More(); It.Next())
4653 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4654 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4656 return isCompatible;
4660 bool SMESHGUI::reusableOperation( const int id )
4662 // compute, evaluate and precompute are not reusable operations
4663 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4666 bool SMESHGUI::activateModule( SUIT_Study* study )
4668 bool res = SalomeApp_Module::activateModule( study );
4670 setMenuShown( true );
4671 setToolShown( true );
4673 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4674 PyGILState_STATE gstate = PyGILState_Ensure();
4675 PyObjWrapper pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4676 if ( !pluginsmanager ) {
4680 PyObjWrapper result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4684 PyGILState_Release(gstate);
4685 // end of SMESH plugins loading
4687 // Reset actions accelerator keys
4688 //action(SMESHOp::OpImportDAT)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B));
4689 action(SMESHOp::OpImportUNV)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U));
4690 action(SMESHOp::OpImportMED)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M));
4692 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4694 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4695 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4696 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4697 if ( _PTR(Study) aStudy = s->studyDS()) {
4698 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4699 updateObjBrowser(); // objects can be removed
4702 // get all view currently opened in the study and connect their signals to
4703 // the corresponding slots of the class.
4704 SUIT_Desktop* aDesk = study->application()->desktop();
4706 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4707 SUIT_ViewWindow* wnd;
4708 foreach ( wnd, wndList )
4715 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4717 setMenuShown( false );
4718 setToolShown( false );
4720 EmitSignalCloseAllDialogs();
4722 // Unset actions accelerator keys
4723 //action(SMESHOp::OpImportDAT)->setShortcut(QKeySequence());
4724 action(SMESHOp::OpImportUNV)->setShortcut(QKeySequence());
4725 action(SMESHOp::OpImportMED)->setShortcut(QKeySequence());
4727 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4729 return SalomeApp_Module::deactivateModule( study );
4732 void SMESHGUI::studyClosed( SUIT_Study* s )
4734 SMESH::RemoveVisuData( s->id() );
4735 SalomeApp_Module::studyClosed( s );
4738 void SMESHGUI::OnGUIEvent()
4740 const QObject* obj = sender();
4741 if ( !obj || !obj->inherits( "QAction" ) )
4743 int id = actionId((QAction*)obj);
4748 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4750 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4751 if ( CORBA::is_nil( myComponentSMESH ) )
4753 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4755 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4756 return aGUI.myComponentSMESH;
4759 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4760 return myComponentSMESH;
4763 QString SMESHGUI::engineIOR() const
4765 CORBA::ORB_var anORB = getApp()->orb();
4766 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4767 return QString( anIOR.in() );
4770 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4772 SalomeApp_Module::contextMenuPopup( client, menu, title );
4774 selectionMgr()->selectedObjects( lst );
4775 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4776 Handle(SALOME_InteractiveObject) io = lst.First();
4777 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4778 _PTR(Study) study = appStudy->studyDS();
4779 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4781 QString aName = QString( QString::fromUtf8(obj->GetName().c_str()) );
4782 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4783 aName.remove( (aName.length() - 1), 1 );
4789 LightApp_Selection* SMESHGUI::createSelection() const
4791 return new SMESHGUI_Selection();
4794 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4796 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4797 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4798 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4801 void SMESHGUI::viewManagers( QStringList& list ) const
4803 list.append( SVTK_Viewer::Type() );
4806 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4808 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4809 SMESH::UpdateSelectionProp( this );
4811 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4812 for(int i = 0; i < aViews.count() ; i++){
4813 SUIT_ViewWindow *sf = aViews[i];
4819 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4821 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4822 myClippingPlaneInfoMap.erase( theViewManager );
4825 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4827 theActor->AddObserver( SMESH::DeleteActorEvent,
4828 myEventCallbackCommand.GetPointer(),
4832 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4833 unsigned long theEvent,
4834 void* theClientData,
4837 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4838 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4839 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4840 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4841 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4842 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4843 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4844 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4845 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4846 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4847 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4848 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4849 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4850 if( anActor == *anIter3 ) {
4851 anActorList.erase( anIter3 );
4862 void SMESHGUI::createPreferences()
4864 // General tab ------------------------------------------------------------------------
4865 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4867 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4868 setPreferenceProperty( autoUpdate, "columns", 2 );
4869 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4870 setPreferenceProperty( lim, "min", 0 );
4871 setPreferenceProperty( lim, "max", 100000000 );
4872 setPreferenceProperty( lim, "step", 1000 );
4873 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4874 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4876 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4877 setPreferenceProperty( qaGroup, "columns", 2 );
4878 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4879 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4880 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4881 setPreferenceProperty( prec, "min", 0 );
4882 setPreferenceProperty( prec, "max", 16 );
4883 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4884 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4885 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4886 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4887 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4889 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4890 setPreferenceProperty( dispgroup, "columns", 2 );
4891 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4893 modes.append( tr("MEN_WIRE") );
4894 modes.append( tr("MEN_SHADE") );
4895 modes.append( tr("MEN_NODES") );
4896 modes.append( tr("MEN_SHRINK") );
4897 QList<QVariant> indices;
4898 indices.append( 0 );
4899 indices.append( 1 );
4900 indices.append( 2 );
4901 indices.append( 3 );
4902 setPreferenceProperty( dispmode, "strings", modes );
4903 setPreferenceProperty( dispmode, "indexes", indices );
4905 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4906 setPreferenceProperty( arcgroup, "columns", 2 );
4907 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4908 QStringList quadraticModes;
4909 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4910 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4912 indices.append( 0 );
4913 indices.append( 1 );
4914 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4915 setPreferenceProperty( quadraticmode, "indexes", indices );
4917 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4918 "SMESH", "max_angle" );
4919 setPreferenceProperty( maxAngle, "min", 1 );
4920 setPreferenceProperty( maxAngle, "max", 90 );
4924 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4925 setPreferenceProperty( exportgroup, "columns", 2 );
4926 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4927 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4929 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4930 setPreferenceProperty( computeGroup, "columns", 2 );
4931 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4933 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4934 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4935 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4937 indices.append( 0 );
4938 indices.append( 1 );
4939 indices.append( 2 );
4940 setPreferenceProperty( notifyMode, "strings", modes );
4941 setPreferenceProperty( notifyMode, "indexes", indices );
4943 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4944 setPreferenceProperty( infoGroup, "columns", 2 );
4945 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4947 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4948 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4950 indices.append( 0 );
4951 indices.append( 1 );
4952 setPreferenceProperty( elemInfo, "strings", modes );
4953 setPreferenceProperty( elemInfo, "indexes", indices );
4954 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4955 setPreferenceProperty( nodesLim, "min", 0 );
4956 setPreferenceProperty( nodesLim, "max", 10000000 );
4957 setPreferenceProperty( nodesLim, "step", 10000 );
4958 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4959 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
4960 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4961 setPreferenceProperty( ctrlLim, "min", 0 );
4962 setPreferenceProperty( ctrlLim, "max", 10000000 );
4963 setPreferenceProperty( ctrlLim, "step", 1000 );
4964 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
4965 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
4966 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
4967 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
4968 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
4970 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4971 setPreferenceProperty( segGroup, "columns", 2 );
4972 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4973 "SMESH", "segmentation" );
4974 setPreferenceProperty( segLen, "min", 1 );
4975 setPreferenceProperty( segLen, "max", 10000000 );
4976 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4977 "SMESH", "nb_segments_per_edge" );
4978 setPreferenceProperty( nbSeg, "min", 1 );
4979 setPreferenceProperty( nbSeg, "max", 10000000 );
4981 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4982 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4983 "SMESH", "forget_mesh_on_hyp_modif" );
4986 // Quantities with individual precision settings
4987 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4988 setPreferenceProperty( precGroup, "columns", 2 );
4990 const int nbQuantities = 6;
4991 int precs[nbQuantities], ii = 0;
4992 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4993 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4994 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4995 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4996 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4997 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4998 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4999 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5000 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5001 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5002 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5003 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5005 // Set property for precision value for spinboxes
5006 for ( ii = 0; ii < nbQuantities; ii++ ){
5007 setPreferenceProperty( precs[ii], "min", -14 );
5008 setPreferenceProperty( precs[ii], "max", 14 );
5009 setPreferenceProperty( precs[ii], "precision", 2 );
5012 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5013 setPreferenceProperty( previewGroup, "columns", 2 );
5014 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5015 setPreferenceProperty( chunkSize, "min", 1 );
5016 setPreferenceProperty( chunkSize, "max", 1000 );
5017 setPreferenceProperty( chunkSize, "step", 50 );
5019 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5020 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5022 // Mesh tab ------------------------------------------------------------------------
5023 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5024 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5025 setPreferenceProperty( nodeGroup, "columns", 3 );
5027 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5029 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5031 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5032 QList<QVariant> aMarkerTypeIndicesList;
5033 QList<QVariant> aMarkerTypeIconsList;
5034 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5035 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5036 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5037 aMarkerTypeIndicesList << i;
5038 aMarkerTypeIconsList << pixmap;
5040 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5041 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5043 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5045 QList<QVariant> aMarkerScaleIndicesList;
5046 QStringList aMarkerScaleValuesList;
5047 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5048 aMarkerScaleIndicesList << i;
5049 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5051 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5052 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5054 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5055 //setPreferenceProperty( elemGroup, "columns", 2 );
5057 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5058 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5059 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5060 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5061 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5062 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5063 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5064 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5065 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5068 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5069 setPreferenceProperty( grpGroup, "columns", 2 );
5071 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5072 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5074 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5075 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5076 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5077 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
5078 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5079 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5080 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5081 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5082 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5083 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5084 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5085 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5087 setPreferenceProperty( size0d, "min", 1 );
5088 setPreferenceProperty( size0d, "max", 10 );
5090 setPreferenceProperty( ballSize, "min", 1 );
5091 setPreferenceProperty( ballSize, "max", 10 );
5093 setPreferenceProperty( ballScale, "min", 1e-2 );
5094 setPreferenceProperty( ballScale, "max", 1e7 );
5095 setPreferenceProperty( ballScale, "step", 0.5 );
5097 setPreferenceProperty( elemW, "min", 1 );
5098 setPreferenceProperty( elemW, "max", 5 );
5100 setPreferenceProperty( outW, "min", 1 );
5101 setPreferenceProperty( outW, "max", 5 );
5103 setPreferenceProperty( shrink, "min", 0 );
5104 setPreferenceProperty( shrink, "max", 100 );
5106 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5107 setPreferenceProperty( numGroup, "columns", 2 );
5109 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5110 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5112 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5113 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5115 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5116 setPreferenceProperty( orientGroup, "columns", 1 );
5118 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5119 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5121 setPreferenceProperty( orientScale, "min", 0.05 );
5122 setPreferenceProperty( orientScale, "max", 0.5 );
5123 setPreferenceProperty( orientScale, "step", 0.05 );
5125 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5127 // Selection tab ------------------------------------------------------------------------
5128 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5130 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5131 setPreferenceProperty( selGroup, "columns", 2 );
5133 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5134 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5136 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5137 setPreferenceProperty( preGroup, "columns", 2 );
5139 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5141 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5142 setPreferenceProperty( precSelGroup, "columns", 2 );
5144 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5145 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5146 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5148 // Scalar Bar tab ------------------------------------------------------------------------
5149 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5150 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5151 setPreferenceProperty( fontGr, "columns", 2 );
5153 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5154 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5156 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5157 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5159 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5160 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5162 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5163 setPreferenceProperty( numcol, "min", 2 );
5164 setPreferenceProperty( numcol, "max", 256 );
5166 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5167 setPreferenceProperty( numlab, "min", 2 );
5168 setPreferenceProperty( numlab, "max", 65 );
5170 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5171 setPreferenceProperty( orientGr, "columns", 2 );
5172 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5173 QStringList orients;
5174 orients.append( tr( "SMESH_VERTICAL" ) );
5175 orients.append( tr( "SMESH_HORIZONTAL" ) );
5176 indices.clear(); indices.append( 0 ); indices.append( 1 );
5177 setPreferenceProperty( orient, "strings", orients );
5178 setPreferenceProperty( orient, "indexes", indices );
5180 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5181 setPreferenceProperty( posVSizeGr, "columns", 2 );
5182 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5183 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5184 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5185 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5186 setPreferenceProperty( xv, "step", 0.1 );
5187 setPreferenceProperty( xv, "min", 0.0 );
5188 setPreferenceProperty( xv, "max", 1.0 );
5189 setPreferenceProperty( yv, "step", 0.1 );
5190 setPreferenceProperty( yv, "min", 0.0 );
5191 setPreferenceProperty( yv, "max", 1.0 );
5192 setPreferenceProperty( wv, "step", 0.1 );
5193 setPreferenceProperty( wv, "min", 0.0 );
5194 setPreferenceProperty( wv, "max", 1.0 );
5195 setPreferenceProperty( hv, "min", 0.0 );
5196 setPreferenceProperty( hv, "max", 1.0 );
5197 setPreferenceProperty( hv, "step", 0.1 );
5199 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5200 setPreferenceProperty( posHSizeGr, "columns", 2 );
5201 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5202 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5203 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5204 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5205 setPreferenceProperty( xv, "min", 0.0 );
5206 setPreferenceProperty( xv, "max", 1.0 );
5207 setPreferenceProperty( xv, "step", 0.1 );
5208 setPreferenceProperty( xh, "min", 0.0 );
5209 setPreferenceProperty( xh, "max", 1.0 );
5210 setPreferenceProperty( xh, "step", 0.1 );
5211 setPreferenceProperty( yh, "min", 0.0 );
5212 setPreferenceProperty( yh, "max", 1.0 );
5213 setPreferenceProperty( yh, "step", 0.1 );
5214 setPreferenceProperty( wh, "min", 0.0 );
5215 setPreferenceProperty( wh, "max", 1.0 );
5216 setPreferenceProperty( wh, "step", 0.1 );
5217 setPreferenceProperty( hh, "min", 0.0 );
5218 setPreferenceProperty( hh, "max", 1.0 );
5219 setPreferenceProperty( hh, "step", 0.1 );
5221 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5222 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5223 setPreferenceProperty( distributionGr, "columns", 3 );
5225 types.append( tr( "SMESH_MONOCOLOR" ) );
5226 types.append( tr( "SMESH_MULTICOLOR" ) );
5227 indices.clear(); indices.append( 0 ); indices.append( 1 );
5228 setPreferenceProperty( coloringType, "strings", types );
5229 setPreferenceProperty( coloringType, "indexes", indices );
5230 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5234 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5236 if( sect=="SMESH" ) {
5237 float sbX1,sbY1,sbW,sbH;
5238 float aTol = 1.00000009999999;
5239 std::string aWarning;
5240 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5241 if( name=="selection_object_color" || name=="selection_element_color" ||
5242 name=="highlight_color" ||
5243 name=="selection_precision_node" || name=="selection_precision_element" ||
5244 name=="selection_precision_object")
5245 SMESH::UpdateSelectionProp( this );
5246 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5247 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5248 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5249 if(sbX1+sbW > aTol){
5250 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5253 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5254 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5257 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5258 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5259 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5260 if(sbY1+sbH > aTol){
5261 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5262 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5263 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5266 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5267 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5268 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5269 if(sbX1+sbW > aTol){
5270 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5273 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5274 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5277 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5278 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5279 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5280 if(sbY1+sbH > aTol){
5281 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5284 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5285 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5288 else if ( name == "segmentation" ) {
5289 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5290 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5292 else if ( name == "nb_segments_per_edge" ) {
5293 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5294 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5296 else if ( name == "historical_python_dump" ||
5297 name == "forget_mesh_on_hyp_modif") {
5298 QString val = aResourceMgr->stringValue( "SMESH", name );
5299 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5301 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5302 SMESH::UpdateFontProp( this );
5304 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5305 SMESH::UpdateFontProp( this );
5308 if(aWarning.size() != 0){
5309 aWarning += "The default values are applied instead.";
5310 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5311 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5312 QObject::tr(aWarning.c_str()));
5317 //================================================================================
5319 * \brief Update something in accordance with update flags
5320 * \param theFlags - update flags
5322 * Update viewer or/and object browser etc. in accordance with update flags ( see
5323 * LightApp_UpdateFlags enumeration ).
5325 //================================================================================
5326 void SMESHGUI::update( const int flags )
5328 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5329 SMESH::UpdateView();
5331 SalomeApp_Module::update( flags );
5334 //================================================================================
5336 * \brief Set default selection mode
5338 * SLOT called when operation commited. Sets default selection mode
5340 //================================================================================
5341 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5343 SVTK_ViewWindow* vtkWnd =
5344 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5346 vtkWnd->SetSelectionMode( ActorSelection );
5349 //================================================================================
5351 * \brief Set default selection mode
5353 * SLOT called when operation aborted. Sets default selection mode
5355 //================================================================================
5356 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5358 SVTK_ViewWindow* vtkWnd =
5359 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5361 vtkWnd->SetSelectionMode( ActorSelection );
5364 //================================================================================
5366 * \brief Creates operation with given identifier
5367 * \param id - identifier of operation to be started
5368 * \return Pointer on created operation or NULL if operation is not created
5370 * Virtual method redefined from the base class creates operation with given id.
5371 * It is called called automatically from startOperation method of base class.
5373 //================================================================================
5374 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5376 LightApp_Operation* op = 0;
5377 // to do : create operation here
5380 case SMESHOp::OpConvertMeshToQuadratic:
5381 op = new SMESHGUI_ConvToQuadOp();
5383 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5384 op = new SMESHGUI_Make2DFrom3DOp();
5386 case SMESHOp::OpReorientFaces:
5387 op = new SMESHGUI_ReorientFacesOp();
5389 case SMESHOp::OpCreateMesh:
5390 op = new SMESHGUI_MeshOp( true, true );
5392 case SMESHOp::OpCreateSubMesh:
5393 op = new SMESHGUI_MeshOp( true, false );
5395 case SMESHOp::OpEditMeshOrSubMesh:
5396 op = new SMESHGUI_MeshOp( false );
5398 case SMESHOp::OpCompute:
5399 op = new SMESHGUI_ComputeOp();
5401 case SMESHOp::OpPreCompute:
5402 op = new SMESHGUI_PrecomputeOp();
5404 case SMESHOp::OpEvaluate:
5405 op = new SMESHGUI_EvaluateOp();
5407 case SMESHOp::OpMeshOrder:
5408 op = new SMESHGUI_MeshOrderOp();
5410 case SMESHOp::OpCreateGeometryGroup:
5411 op = new SMESHGUI_GroupOnShapeOp();
5413 case SMESHOp::OpFindElementByPoint:
5414 op = new SMESHGUI_FindElemByPointOp();
5416 case SMESHOp::OpMoveNode: // Make mesh pass through point
5417 op = new SMESHGUI_MakeNodeAtPointOp();
5419 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5420 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5427 op = SalomeApp_Module::createOperation( id );
5431 //================================================================================
5433 * \brief Stops current operations and starts a given one
5434 * \param id - The id of the operation to start
5436 //================================================================================
5438 void SMESHGUI::switchToOperation(int id)
5440 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5441 activeStudy()->abortAllOperations();
5442 startOperation( id );
5445 LightApp_Displayer* SMESHGUI::displayer()
5448 myDisplayer = new SMESHGUI_Displayer( getApp() );
5452 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5455 int aTolerance = 64;
5456 int anIterations = 0;
5462 if( anIterations % aPeriod == 0 )
5465 if( aTolerance < 1 )
5469 aHue = (int)( 360.0 * rand() / RAND_MAX );
5472 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5473 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5474 for( ; it != itEnd; ++it )
5476 SALOMEDS::Color anAutoColor = *it;
5477 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5480 aQColor.getHsv( &h, &s, &v );
5481 if( abs( h - aHue ) < aTolerance )
5493 aColor.setHsv( aHue, 255, 255 );
5495 SALOMEDS::Color aSColor;
5496 aSColor.R = aColor.redF();
5497 aSColor.G = aColor.greenF();
5498 aSColor.B = aColor.blueF();
5503 const char* gSeparator = "_"; // character used to separate parameter names
5504 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5505 const char* gPathSep = "|"; // character used to separate paths
5508 * \brief Store visual parameters
5510 * This method is called just before the study document is saved.
5511 * Store visual parameters in AttributeParameter attribue(s)
5513 void SMESHGUI::storeVisualParameters (int savePoint)
5516 Kernel_Utils::Localizer loc;
5518 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5519 if (!appStudy || !appStudy->studyDS())
5521 _PTR(Study) studyDS = appStudy->studyDS();
5523 // componentName is used for encoding of entries when storing them in IParameters
5524 std::string componentName = myComponentSMESH->ComponentDataType();
5525 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5526 //if (!aSComponent) return;
5529 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5530 componentName.c_str(),
5532 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5534 // store map of custom markers
5535 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5536 if( !aMarkerMap.empty() )
5538 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5539 for( ; anIter != aMarkerMap.end(); anIter++ )
5541 int anId = anIter->first;
5542 VTK::MarkerData aMarkerData = anIter->second;
5543 std::string aMarkerFileName = aMarkerData.first;
5544 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5545 if( aMarkerTexture.size() < 3 )
5546 continue; // should contain at least width, height and the first value
5548 QString aPropertyName( "texture" );
5549 aPropertyName += gSeparator;
5550 aPropertyName += QString::number( anId );
5552 QString aPropertyValue = aMarkerFileName.c_str();
5553 aPropertyValue += gPathSep;
5555 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5556 ushort aWidth = *aTextureIter++;
5557 ushort aHeight = *aTextureIter++;
5558 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5559 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5560 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5561 aPropertyValue += QString::number( *aTextureIter );
5563 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5567 // viewers counters are used for storing view_numbers in IParameters
5570 // main cycle to store parameters of displayed objects
5571 QList<SUIT_ViewManager*> lst;
5572 QList<SUIT_ViewManager*>::Iterator it;
5573 getApp()->viewManagers(lst);
5574 for (it = lst.begin(); it != lst.end(); it++)
5576 SUIT_ViewManager* vman = *it;
5577 QString vType = vman->getType();
5579 // saving VTK actors properties
5580 if (vType == SVTK_Viewer::Type())
5582 // store the clipping planes attached to the view manager
5583 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5584 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5585 if( anIter != myClippingPlaneInfoMap.end() )
5586 aClippingPlaneInfoList = anIter->second;
5588 if( !aClippingPlaneInfoList.empty() ) {
5589 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5590 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5592 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5593 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5595 QString aPropertyName( "ClippingPlane" );
5596 aPropertyName += gSeparator;
5597 aPropertyName += QString::number( vtkViewers );
5598 aPropertyName += gSeparator;
5599 aPropertyName += QString::number( anId );
5601 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5602 aPropertyValue += gDigitsSep;
5603 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5604 aPropertyValue += gDigitsSep;
5605 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5606 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5607 aPropertyValue += gDigitsSep;
5608 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5609 aPropertyValue += gDigitsSep;
5610 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5611 aPropertyValue += gDigitsSep;
5612 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5613 aPropertyValue += gDigitsSep;
5614 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5615 aPropertyValue += gDigitsSep;
5616 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5617 aPropertyValue += gDigitsSep;
5618 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5620 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5621 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5622 aPropertyValue += gDigitsSep;
5623 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5624 aPropertyValue += gDigitsSep;
5625 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5626 aPropertyValue += gDigitsSep;
5627 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5630 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5634 QVector<SUIT_ViewWindow*> views = vman->getViews();
5635 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5637 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5639 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5640 vtkActorCollection* allActors = aCopy.GetActors();
5641 allActors->InitTraversal();
5642 while (vtkActor* actor = allActors->GetNextActor())
5644 if (actor->GetVisibility()) // store only visible actors
5646 SMESH_Actor* aSmeshActor = 0;
5647 if (actor->IsA("SMESH_Actor"))
5648 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5649 if (aSmeshActor && aSmeshActor->hasIO())
5651 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5654 // entry is "encoded" = it does NOT contain component adress,
5655 // since it is a subject to change on next component loading
5656 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5658 std::string param, vtkParam = vType.toLatin1().data();
5659 vtkParam += gSeparator;
5660 vtkParam += QString::number(vtkViewers).toLatin1().data();
5661 vtkParam += gSeparator;
5664 param = vtkParam + "Visibility";
5665 ip->setParameter(entry, param, "On");
5668 param = vtkParam + "Representation";
5669 ip->setParameter(entry, param, QString::number
5670 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5673 param = vtkParam + "IsShrunk";
5674 ip->setParameter(entry, param, QString::number
5675 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5677 // Displayed entities
5678 unsigned int aMode = aSmeshActor->GetEntityMode();
5679 bool isE = aMode & SMESH_Actor::eEdges;
5680 bool isF = aMode & SMESH_Actor::eFaces;
5681 bool isV = aMode & SMESH_Actor::eVolumes;
5682 bool is0d = aMode & SMESH_Actor::e0DElements;
5683 bool isB = aMode & SMESH_Actor::eBallElem;
5685 QString modeStr ("e");
5686 modeStr += gDigitsSep; modeStr += QString::number(isE);
5687 modeStr += gDigitsSep; modeStr += "f";
5688 modeStr += gDigitsSep; modeStr += QString::number(isF);
5689 modeStr += gDigitsSep; modeStr += "v";
5690 modeStr += gDigitsSep; modeStr += QString::number(isV);
5691 modeStr += gDigitsSep; modeStr += "0d";
5692 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5693 modeStr += gDigitsSep; modeStr += "b";
5694 modeStr += gDigitsSep; modeStr += QString::number(isB);
5696 param = vtkParam + "Entities";
5697 ip->setParameter(entry, param, modeStr.toLatin1().data());
5703 aSmeshActor->GetSufaceColor(r, g, b, delta);
5704 QStringList colorStr;
5705 colorStr << "surface";
5706 colorStr << QString::number(r);
5707 colorStr << QString::number(g);
5708 colorStr << QString::number(b);
5710 colorStr << "backsurface";
5711 colorStr << QString::number(delta);
5713 aSmeshActor->GetVolumeColor(r, g, b, delta);
5714 colorStr << "volume";
5715 colorStr << QString::number(r);
5716 colorStr << QString::number(g);
5717 colorStr << QString::number(b);
5718 colorStr << QString::number(delta);
5720 aSmeshActor->GetEdgeColor(r, g, b);
5722 colorStr << QString::number(r);
5723 colorStr << QString::number(g);
5724 colorStr << QString::number(b);
5726 aSmeshActor->GetNodeColor(r, g, b);
5728 colorStr << QString::number(r);
5729 colorStr << QString::number(g);
5730 colorStr << QString::number(b);
5732 aSmeshActor->GetOutlineColor(r, g, b);
5733 colorStr << "outline";
5734 colorStr << QString::number(r);
5735 colorStr << QString::number(g);
5736 colorStr << QString::number(b);
5738 aSmeshActor->Get0DColor(r, g, b);
5739 colorStr << "elem0d";
5740 colorStr << QString::number(r);
5741 colorStr << QString::number(g);
5742 colorStr << QString::number(b);
5744 aSmeshActor->GetBallColor(r, g, b);
5746 colorStr << QString::number(r);
5747 colorStr << QString::number(g);
5748 colorStr << QString::number(b);
5750 aSmeshActor->GetFacesOrientationColor(r, g, b);
5751 colorStr << "orientation";
5752 colorStr << QString::number(r);
5753 colorStr << QString::number(g);
5754 colorStr << QString::number(b);
5756 param = vtkParam + "Colors";
5757 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5760 QStringList sizeStr;
5762 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5763 sizeStr << "outline";
5764 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5765 sizeStr << "elem0d";
5766 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5768 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5769 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5770 sizeStr << "shrink";
5771 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5772 sizeStr << "orientation";
5773 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5774 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5776 param = vtkParam + "Sizes";
5777 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5782 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5783 if( aMarkerType == VTK::MT_USER ) {
5784 markerStr += "custom";
5785 markerStr += gDigitsSep;
5786 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5790 markerStr += gDigitsSep;
5791 markerStr += QString::number( (int)aMarkerType );
5792 markerStr += gDigitsSep;
5793 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5796 param = vtkParam + "PointMarker";
5797 ip->setParameter(entry, param, markerStr.toLatin1().data());
5800 param = vtkParam + "Opacity";
5801 ip->setParameter(entry, param,
5802 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5805 param = vtkParam + "ClippingPlane";
5807 if( !aClippingPlaneInfoList.empty() ) {
5808 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5809 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5811 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5812 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5813 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5814 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5815 if( aSmeshActor == *anIter2 ) {
5816 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5817 QString::number( anId ).toLatin1().constData() );
5824 ip->setParameter( entry, param, "Off" );
5825 } // if (io->hasEntry())
5826 } // SMESH_Actor && hasIO
5828 } // while.. actors traversal
5832 } // if (SVTK view model)
5833 } // for (viewManagers)
5836 // data structures for clipping planes processing
5840 bool isOpenGLClipping;
5841 vtkIdType RelativeOrientation;
5844 int AbsoluteOrientation;
5845 double X, Y, Z, Dx, Dy, Dz;
5847 typedef std::list<TPlaneData> TPlaneDataList;
5848 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5850 typedef std::list<vtkActor*> TActorList;
5853 TActorList ActorList;
5854 SUIT_ViewManager* ViewManager;
5856 typedef std::list<TPlaneInfo> TPlaneInfoList;
5857 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5860 * \brief Restore visual parameters
5862 * This method is called after the study document is opened.
5863 * Restore visual parameters from AttributeParameter attribue(s)
5865 void SMESHGUI::restoreVisualParameters (int savePoint)
5868 Kernel_Utils::Localizer loc;
5870 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5871 if (!appStudy || !appStudy->studyDS())
5873 _PTR(Study) studyDS = appStudy->studyDS();
5875 // componentName is used for encoding of entries when storing them in IParameters
5876 std::string componentName = myComponentSMESH->ComponentDataType();
5877 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5878 //if (!aSComponent) return;
5881 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5882 componentName.c_str(),
5884 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5886 // restore map of custom markers and map of clipping planes
5887 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5888 TPlaneDataMap aPlaneDataMap;
5890 std::vector<std::string> properties = ip->getProperties();
5891 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5893 std::string property = *propIt;
5894 QString aPropertyName( property.c_str() );
5895 QString aPropertyValue( ip->getProperty( property ).c_str() );
5897 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5898 if( aPropertyNameList.isEmpty() )
5901 QString aPropertyType = aPropertyNameList[0];
5902 if( aPropertyType == "texture" )
5904 if( aPropertyNameList.size() != 2 )
5908 int anId = aPropertyNameList[1].toInt( &ok );
5909 if( !ok || anId < 1 )
5912 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5913 if( aPropertyValueList.size() != 2 )
5916 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5917 QString aMarkerTextureString = aPropertyValueList[1];
5918 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5919 if( aMarkerTextureStringList.size() != 3 )
5923 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5928 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5932 VTK::MarkerTexture aMarkerTexture;
5933 aMarkerTexture.push_back( aWidth );
5934 aMarkerTexture.push_back( aHeight );
5936 QString aMarkerTextureData = aMarkerTextureStringList[2];
5937 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5939 QChar aChar = aMarkerTextureData.at( i );
5940 if( aChar.isDigit() )
5941 aMarkerTexture.push_back( aChar.digitValue() );
5944 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5946 else if( aPropertyType == "ClippingPlane" )
5948 if( aPropertyNameList.size() != 3 )
5952 int aViewId = aPropertyNameList[1].toInt( &ok );
5953 if( !ok || aViewId < 0 )
5957 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5958 if( !ok || aClippingPlaneId < 0 )
5961 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5962 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
5965 TPlaneData aPlaneData;
5966 aPlaneData.Id = aClippingPlaneId;
5969 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
5974 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
5978 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
5981 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
5986 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
5991 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
5996 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6001 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6006 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6011 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6015 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6017 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6022 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6027 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6032 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6037 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6038 aPlaneDataList.push_back( aPlaneData );
6042 TPlaneInfoMap aPlaneInfoMap;
6044 std::vector<std::string> entries = ip->getEntries();
6046 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6048 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6049 QString entry (ip->decodeEntry(*entIt).c_str());
6051 // Check that the entry corresponds to a real object in the Study
6052 // as the object may be deleted or modified after the visual state is saved.
6053 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6054 if (!so) continue; //Skip the not existent entry
6056 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6057 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6059 std::vector<std::string>::iterator namesIt = paramNames.begin();
6060 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6062 // actors are stored in a map after displaying of them for
6063 // quicker access in the future: map < viewID to actor >
6064 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6066 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6068 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6069 // '_' is used as separator and should not be used in viewer type or parameter names.
6070 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6071 if (lst.size() != 3)
6074 QString viewerTypStr = lst[0];
6075 QString viewIndexStr = lst[1];
6076 QString paramNameStr = lst[2];
6079 int viewIndex = viewIndexStr.toUInt(&ok);
6080 if (!ok) // bad conversion of view index to integer
6084 if (viewerTypStr == SVTK_Viewer::Type())
6086 SMESH_Actor* aSmeshActor = 0;
6087 if (vtkActors.IsBound(viewIndex))
6088 aSmeshActor = vtkActors.Find(viewIndex);
6090 QList<SUIT_ViewManager*> lst;
6091 getApp()->viewManagers(viewerTypStr, lst);
6093 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6094 SUIT_ViewManager* vman = NULL;
6095 if (viewIndex >= 0 && viewIndex < lst.count())
6096 vman = lst.at(viewIndex);
6098 if (paramNameStr == "Visibility")
6100 if (!aSmeshActor && displayer() && vman)
6102 SUIT_ViewModel* vmodel = vman->getViewModel();
6103 // SVTK view model can be casted to SALOME_View
6104 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6106 // store displayed actor in a temporary map for quicker
6107 // access later when restoring other parameters
6108 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6109 vtkRenderer* Renderer = vtkView->getRenderer();
6110 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6111 vtkActorCollection* theActors = aCopy.GetActors();
6112 theActors->InitTraversal();
6113 bool isFound = false;
6114 vtkActor *ac = theActors->GetNextActor();
6115 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6116 if (ac->IsA("SMESH_Actor")) {
6117 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6118 if (aGeomAc->hasIO()) {
6119 Handle(SALOME_InteractiveObject) io =
6120 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6121 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6123 vtkActors.Bind(viewIndex, aGeomAc);
6129 } // if (paramNameStr == "Visibility")
6132 // the rest properties "work" with SMESH_Actor
6135 QString val ((*valuesIt).c_str());
6138 if (paramNameStr == "Representation") {
6139 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6142 else if (paramNameStr == "IsShrunk") {
6144 if (!aSmeshActor->IsShrunk())
6145 aSmeshActor->SetShrink();
6148 if (aSmeshActor->IsShrunk())
6149 aSmeshActor->UnShrink();
6152 // Displayed entities
6153 else if (paramNameStr == "Entities") {
6154 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6155 int aEntityMode = SMESH_Actor::eAllEntity;
6156 for ( int i = 0; i < mode.count(); i+=2 ) {
6157 if ( i < mode.count()-1 ) {
6158 QString type = mode[i];
6159 bool val = mode[i+1].toInt();
6160 if ( type == "e" && !val )
6161 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6162 else if ( type == "f" && !val )
6163 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6164 else if ( type == "v" && !val )
6165 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6166 else if ( type == "0d" && !val )
6167 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6168 else if ( type == "b" && !val )
6169 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6172 aSmeshActor->SetEntityMode( aEntityMode );
6175 else if (paramNameStr == "Colors") {
6176 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6183 QColor outlineColor;
6184 QColor orientationColor;
6190 // below lines are required to get default values for delta coefficients
6191 // of backface color for faces and color of reversed volumes
6192 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6193 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6194 for ( int i = 0; i < colors.count(); i++ ) {
6195 QString type = colors[i];
6196 if ( type == "surface" ) {
6197 // face color is set by 3 values r:g:b, where
6198 // - r,g,b - is rgb color components
6199 if ( i+1 >= colors.count() ) break; // format error
6200 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6201 if ( i+2 >= colors.count() ) break; // format error
6202 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6203 if ( i+3 >= colors.count() ) break; // format error
6204 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6205 faceColor.setRgbF( r, g, b );
6208 else if ( type == "backsurface" ) {
6209 // backface color can be defined in several ways
6210 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6211 // - in latest versions, it is set as delta coefficient
6212 bool rgbOk = false, deltaOk;
6213 if ( i+1 >= colors.count() ) break; // format error
6214 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6215 int delta = colors[i+1].toInt( &deltaOk );
6217 if ( i+1 < colors.count() ) // index is shifted to 1
6218 g = colors[i+1].toDouble( &rgbOk );
6219 if ( rgbOk ) i++; // shift index
6220 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6221 b = colors[i+1].toDouble( &rgbOk );
6223 // - as currently there's no way to set directly backsurface color as it was before,
6224 // we ignore old dump where r,g,b triple was set
6225 // - also we check that delta parameter is set properly
6226 if ( !rgbOk && deltaOk )
6229 else if ( type == "volume" ) {
6230 // volume color is set by 4 values r:g:b:delta, where
6231 // - r,g,b - is a normal volume rgb color components
6232 // - delta - is a reversed volume color delta coefficient
6233 if ( i+1 >= colors.count() ) break; // format error
6234 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6235 if ( i+2 >= colors.count() ) break; // format error
6236 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6237 if ( i+3 >= colors.count() ) break; // format error
6238 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6239 if ( i+4 >= colors.count() ) break; // format error
6240 int delta = colors[i+4].toInt( &bOk );
6241 if ( !bOk ) break; // format error
6242 volumeColor.setRgbF( r, g, b );
6246 else if ( type == "edge" ) {
6247 // edge color is set by 3 values r:g:b, where
6248 // - r,g,b - is rgb color components
6249 if ( i+1 >= colors.count() ) break; // format error
6250 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6251 if ( i+2 >= colors.count() ) break; // format error
6252 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6253 if ( i+3 >= colors.count() ) break; // format error
6254 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6255 edgeColor.setRgbF( r, g, b );
6258 else if ( type == "node" ) {
6259 // node color is set by 3 values r:g:b, where
6260 // - r,g,b - is rgb color components
6261 if ( i+1 >= colors.count() ) break; // format error
6262 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6263 if ( i+2 >= colors.count() ) break; // format error
6264 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6265 if ( i+3 >= colors.count() ) break; // format error
6266 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6267 nodeColor.setRgbF( r, g, b );
6270 else if ( type == "elem0d" ) {
6271 // 0d element color is set by 3 values r:g:b, where
6272 // - r,g,b - is rgb color components
6273 if ( i+1 >= colors.count() ) break; // format error
6274 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6275 if ( i+2 >= colors.count() ) break; // format error
6276 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6277 if ( i+3 >= colors.count() ) break; // format error
6278 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6279 elem0dColor.setRgbF( r, g, b );
6282 else if ( type == "ball" ) {
6283 // ball color is set by 3 values r:g:b, where
6284 // - r,g,b - is rgb color components
6285 if ( i+1 >= colors.count() ) break; // format error
6286 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6287 if ( i+2 >= colors.count() ) break; // format error
6288 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6289 if ( i+3 >= colors.count() ) break; // format error
6290 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6291 ballColor.setRgbF( r, g, b );
6294 else if ( type == "outline" ) {
6295 // outline color is set by 3 values r:g:b, where
6296 // - r,g,b - is rgb color components
6297 if ( i+1 >= colors.count() ) break; // format error
6298 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6299 if ( i+2 >= colors.count() ) break; // format error
6300 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6301 if ( i+3 >= colors.count() ) break; // format error
6302 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6303 outlineColor.setRgbF( r, g, b );
6306 else if ( type == "orientation" ) {
6307 // orientation color is set by 3 values r:g:b, where
6308 // - r,g,b - is rgb color components
6309 if ( i+1 >= colors.count() ) break; // format error
6310 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6311 if ( i+2 >= colors.count() ) break; // format error
6312 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6313 if ( i+3 >= colors.count() ) break; // format error
6314 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6315 orientationColor.setRgbF( r, g, b );
6320 if ( nodeColor.isValid() )
6321 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6323 if ( edgeColor.isValid() )
6324 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6326 if ( faceColor.isValid() )
6327 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6329 if ( volumeColor.isValid() )
6330 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6331 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6332 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6334 if ( elem0dColor.isValid() )
6335 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6337 if ( ballColor.isValid() )
6338 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6340 if ( outlineColor.isValid() )
6341 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6342 // orientation color
6343 if ( orientationColor.isValid() )
6344 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6347 else if (paramNameStr == "Sizes") {
6348 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6351 int outlineWidth = -1;
6352 int elem0dSize = -1;
6354 double ballScale = -1.0;
6355 double shrinkSize = -1;
6356 double orientationSize = -1;
6357 bool orientation3d = false;
6358 for ( int i = 0; i < sizes.count(); i++ ) {
6359 QString type = sizes[i];
6360 if ( type == "line" ) {
6361 // line (wireframe) width is given as single integer value
6362 if ( i+1 >= sizes.count() ) break; // format error
6363 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6367 if ( type == "outline" ) {
6368 // outline width is given as single integer value
6369 if ( i+1 >= sizes.count() ) break; // format error
6370 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6374 else if ( type == "elem0d" ) {
6375 // 0d element size is given as single integer value
6376 if ( i+1 >= sizes.count() ) break; // format error
6377 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6381 else if ( type == "ball" ) {
6382 // balls are specified by two values: size:scale, where
6383 // - size - is a integer value specifying size
6384 // - scale - is a double value specifying scale factor
6385 if ( i+1 >= sizes.count() ) break; // format error
6386 int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6387 if ( i+2 >= sizes.count() ) break; // format error
6388 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6393 else if ( type == "shrink" ) {
6394 // shrink factor is given as single floating point value
6395 if ( i+1 >= sizes.count() ) break; // format error
6396 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6400 else if ( type == "orientation" ) {
6401 // orientation vectors are specified by two values size:3d, where
6402 // - size - is a floating point value specifying scale factor
6403 // - 3d - is a boolean
6404 if ( i+1 >= sizes.count() ) break; // format error
6405 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6406 if ( i+2 >= sizes.count() ) break; // format error
6407 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6408 orientationSize = v1;
6409 orientation3d = (bool)v2;
6413 // line (wireframe) width
6414 if ( lineWidth > 0 )
6415 aSmeshActor->SetLineWidth( lineWidth );
6417 if ( outlineWidth > 0 )
6418 aSmeshActor->SetOutlineWidth( outlineWidth );
6419 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6420 aSmeshActor->SetOutlineWidth( lineWidth );
6422 if ( elem0dSize > 0 )
6423 aSmeshActor->Set0DSize( elem0dSize );
6426 aSmeshActor->SetBallSize( ballSize );
6428 if ( ballScale > 0.0 )
6429 aSmeshActor->SetBallScale( ballScale );
6431 if ( shrinkSize > 0 )
6432 aSmeshActor->SetShrinkFactor( shrinkSize );
6433 // orientation vectors
6434 if ( orientationSize > 0 ) {
6435 aSmeshActor->SetFacesOrientationScale( orientationSize );
6436 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6440 else if (paramNameStr == "PointMarker") {
6441 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6442 if( data.count() >= 2 ) {
6444 int aParam1 = data[1].toInt( &ok );
6446 if( data[0] == "std" && data.count() == 3 ) {
6447 int aParam2 = data[2].toInt( &ok );
6448 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6450 else if( data[0] == "custom" ) {
6451 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6452 if( markerIt != aMarkerMap.end() ) {
6453 VTK::MarkerData aMarkerData = markerIt->second;
6454 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6461 else if (paramNameStr == "Opacity") {
6462 aSmeshActor->SetOpacity(val.toFloat());
6465 else if (paramNameStr.startsWith("ClippingPlane")) {
6466 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6467 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6468 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6469 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6470 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6471 // new format - val looks like "Off" or "0" (plane id)
6472 // (note: in new format "Off" value is used only for consistency,
6473 // so it is processed together with values in old format)
6474 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6475 if( anIsOldFormat ) {
6476 if (paramNameStr == "ClippingPlane1" || val == "Off")
6477 aSmeshActor->RemoveAllClippingPlanes();
6479 QList<SUIT_ViewManager*> lst;
6480 getApp()->viewManagers(viewerTypStr, lst);
6481 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6482 if (viewIndex >= 0 && viewIndex < lst.count()) {
6483 SUIT_ViewManager* vman = lst.at(viewIndex);
6484 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6486 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6488 SMESH::TActorList anActorList;
6489 anActorList.push_back( aSmeshActor );
6490 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6491 aPlane->myViewWindow = vtkView;
6492 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6493 aPlane->PlaneMode = aMode;
6494 bool isOpenGLClipping = ( bool )vals[1].toInt();
6495 aPlane->IsOpenGLClipping = isOpenGLClipping;
6496 if ( aMode == SMESH::Absolute ) {
6497 aPlane->myAbsoluteOrientation = vals[2].toInt();
6498 aPlane->X = vals[3].toFloat();
6499 aPlane->Y = vals[4].toFloat();
6500 aPlane->Z = vals[5].toFloat();
6501 aPlane->Dx = vals[6].toFloat();
6502 aPlane->Dy = vals[7].toFloat();
6503 aPlane->Dz = vals[8].toFloat();
6505 else if ( aMode == SMESH::Relative ) {
6506 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6507 aPlane->myDistance = vals[3].toFloat();
6508 aPlane->myAngle[0] = vals[4].toFloat();
6509 aPlane->myAngle[1] = vals[5].toFloat();
6513 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6514 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6515 aClippingPlaneInfo.Plane = aPlane;
6516 aClippingPlaneInfo.ActorList = anActorList;
6517 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6525 int aPlaneId = val.toInt( &ok );
6526 if( ok && aPlaneId >= 0 ) {
6527 bool anIsDefinedPlane = false;
6528 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6529 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6530 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6531 TPlaneInfo& aPlaneInfo = *anIter;
6532 if( aPlaneInfo.PlaneId == aPlaneId ) {
6533 aPlaneInfo.ActorList.push_back( aSmeshActor );
6534 anIsDefinedPlane = true;
6538 if( !anIsDefinedPlane ) {
6539 TPlaneInfo aPlaneInfo;
6540 aPlaneInfo.PlaneId = aPlaneId;
6541 aPlaneInfo.ActorList.push_back( aSmeshActor );
6542 aPlaneInfo.ViewManager = vman;
6544 // to make the list sorted by plane id
6545 anIter = aPlaneInfoList.begin();
6546 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6547 const TPlaneInfo& aPlaneInfoRef = *anIter;
6548 if( aPlaneInfoRef.PlaneId > aPlaneId )
6551 aPlaneInfoList.insert( anIter, aPlaneInfo );
6556 } // if (aSmeshActor)
6557 } // other parameters than Visibility
6559 } // for names/parameters iterator
6560 } // for entries iterator
6562 // take into account planes with empty list of actors referred to them
6563 QList<SUIT_ViewManager*> aVMList;
6564 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6566 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6567 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6568 int aViewId = aPlaneDataIter->first;
6569 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6570 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6572 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6574 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6575 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6576 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6577 const TPlaneData& aPlaneData = *anIter2;
6578 int aPlaneId = aPlaneData.Id;
6580 bool anIsFound = false;
6581 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6582 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6583 const TPlaneInfo& aPlaneInfo = *anIter3;
6584 if( aPlaneInfo.PlaneId == aPlaneId ) {
6591 TPlaneInfo aPlaneInfo; // ActorList field is empty
6592 aPlaneInfo.PlaneId = aPlaneId;
6593 aPlaneInfo.ViewManager = aViewManager;
6595 // to make the list sorted by plane id
6596 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6597 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6598 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6599 if( aPlaneInfoRef.PlaneId > aPlaneId )
6602 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6608 // add clipping planes to actors according to the restored parameters
6609 // and update the clipping plane map
6610 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6611 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6612 int aViewId = anIter1->first;
6613 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6615 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6616 if( anIter2 == aPlaneDataMap.end() )
6618 const TPlaneDataList& aPlaneDataList = anIter2->second;
6620 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6621 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6622 const TPlaneInfo& aPlaneInfo = *anIter3;
6623 int aPlaneId = aPlaneInfo.PlaneId;
6624 const TActorList& anActorList = aPlaneInfo.ActorList;
6625 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6629 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6633 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6635 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6636 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6637 const TPlaneData& aPlaneData = *anIter4;
6638 if( aPlaneData.Id == aPlaneId ) {
6639 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6640 aPlane->myViewWindow = aViewWindow;
6641 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6642 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6643 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6644 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6645 aPlane->X = aPlaneData.X;
6646 aPlane->Y = aPlaneData.Y;
6647 aPlane->Z = aPlaneData.Z;
6648 aPlane->Dx = aPlaneData.Dx;
6649 aPlane->Dy = aPlaneData.Dy;
6650 aPlane->Dz = aPlaneData.Dz;
6652 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6653 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6654 aPlane->myDistance = aPlaneData.Distance;
6655 aPlane->myAngle[0] = aPlaneData.Angle[0];
6656 aPlane->myAngle[1] = aPlaneData.Angle[1];
6659 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6660 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6661 aClippingPlaneInfo.Plane = aPlane;
6662 aClippingPlaneInfo.ActorList = anActorList;
6663 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6674 // update all VTK views
6675 QList<SUIT_ViewManager*> lst;
6676 getApp()->viewManagers(lst);
6677 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6678 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6679 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6680 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6681 // set OpenGL clipping planes
6682 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6683 vtkActorCollection* anAllActors = aCopy.GetActors();
6684 anAllActors->InitTraversal();
6685 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6686 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6687 anActor->SetOpenGLClippingPlane();
6689 vtkView->getRenderer()->ResetCameraClippingRange();
6696 \brief Adds preferences for dfont of VTK viewer
6698 \param pIf group identifier
6699 \param param parameter
6700 \return identifier of preferences
6702 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6704 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6706 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6709 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6710 fam.append( tr( "SMESH_FONT_COURIER" ) );
6711 fam.append( tr( "SMESH_FONT_TIMES" ) );
6713 setPreferenceProperty( tfont, "fonts", fam );
6715 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6716 if ( needSize ) f = f | QtxFontEdit::Size;
6717 setPreferenceProperty( tfont, "features", f );
6723 \brief Actions after hypothesis edition
6724 Updates object browser after hypothesis edition
6726 void SMESHGUI::onHypothesisEdit( int result )
6729 SMESHGUI::Modified();
6730 updateObjBrowser( true );
6735 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6736 \param pview view being closed
6738 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6739 #ifndef DISABLE_PLOT2DVIEWER
6740 //Crear all Plot2d Viewers if need.
6741 SMESH::ClearPlot2Viewers(pview);
6745 void SMESHGUI::message( const QString& msg )
6748 QStringList data = msg.split("/");
6749 if ( data.count() > 0 ) {
6750 if ( data.first() == "mesh_loading" ) {
6752 QString entry = data.count() > 1 ? data[1] : QString();
6753 if ( entry.isEmpty() )
6756 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6758 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6761 name = QString::fromUtf8(obj->GetName().c_str());
6762 if ( name.isEmpty() )
6765 if ( data.last() == "stop" )
6766 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6768 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6769 QApplication::processEvents();
6775 \brief Connects or disconnects signals about activating and cloning view on the module slots
6776 \param pview view which is connected/disconnected
6778 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6782 SUIT_ViewManager* viewMgr = pview->getViewManager();
6784 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6785 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6787 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6788 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6793 \brief Return \c true if object can be renamed
6795 bool SMESHGUI::renameAllowed( const QString& entry) const {
6796 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6800 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6804 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6809 if(appStudy->isComponent(entry) || obj->isReference())
6812 // check type to prevent renaming of inappropriate objects
6813 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6814 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6815 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6816 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6817 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6818 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6825 Rename object by entry.
6826 \param entry entry of the object
6827 \param name new name of the object
6828 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6830 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6832 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6836 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6841 _PTR(Study) aStudy = appStudy->studyDS();
6846 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6848 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6853 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6854 _PTR(GenericAttribute) anAttr;
6855 _PTR(AttributeName) aName;
6857 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6859 // check type to prevent renaming of inappropriate objects
6860 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6861 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6862 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6863 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6864 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6865 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6866 if ( !name.isEmpty() ) {
6867 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6869 // update name of group object and its actor
6870 Handle(SALOME_InteractiveObject) IObject =
6871 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6873 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6874 if( !aGroupObject->_is_nil() ) {
6875 aGroupObject->SetName( qPrintable(name) );
6876 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6877 anActor->setName( qPrintable(name) );
6887 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6889 static QList<QColor> colors;
6891 if ( colors.isEmpty() ) {
6893 for (int s = 0; s < 2 ; s++)
6895 for (int v = 100; v >= 40; v = v - 20)
6897 for (int h = 0; h < 359 ; h = h + 60)
6899 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
6904 static int currentColor = 0;
6906 SALOMEDS::Color color;
6907 color.R = (double)colors[currentColor].red() / 255.0;
6908 color.G = (double)colors[currentColor].green() / 255.0;
6909 color.B = (double)colors[currentColor].blue() / 255.0;
6911 currentColor = (currentColor+1) % colors.count();