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"
84 #include "SMESHGUI_DisplayEntitiesDlg.h"
86 #include "SMESHGUI_FilterUtils.h"
87 #include "SMESHGUI_GEOMGenUtils.h"
88 #include "SMESHGUI_GroupUtils.h"
89 #include "SMESHGUI_HypothesesUtils.h"
90 #include "SMESHGUI_MeshUtils.h"
91 #include "SMESHGUI_PatternUtils.h"
92 #include "SMESHGUI_Utils.h"
93 #include "SMESHGUI_VTKUtils.h"
95 #include <SMESH_version.h>
97 #include "SMESH_ControlsDef.hxx"
98 #include <SMESH_Actor.h>
99 #include <SMESH_ActorUtils.h>
100 #include <SMESH_Client.hxx>
101 #include <SMESH_ScalarBarActor.h>
102 #include <SMESH_TypeFilter.hxx>
104 // SALOME GUI includes
105 #include <SalomeApp_Application.h>
106 #include <SalomeApp_CheckFileDlg.h>
107 #include <SalomeApp_DataObject.h>
108 #include <SalomeApp_Study.h>
109 #include <SalomeApp_Tools.h>
111 #include <LightApp_DataOwner.h>
112 #include <LightApp_NameDlg.h>
113 #include <LightApp_Preferences.h>
114 #include <LightApp_SelectionMgr.h>
115 #include <LightApp_UpdateFlags.h>
117 #include <SVTK_ViewManager.h>
118 #include <SVTK_ViewModel.h>
119 #include <SVTK_ViewWindow.h>
121 #include <VTKViewer_Algorithm.h>
123 #include <PyInterp_Interp.h>
125 #include <SUIT_Desktop.h>
126 #include <SUIT_FileDlg.h>
127 #include <SUIT_MessageBox.h>
128 #include <SUIT_OverrideCursor.h>
129 #include <SUIT_ResourceMgr.h>
130 #include <SUIT_Session.h>
132 #include <QtxPopupMgr.h>
133 #include <QtxFontEdit.h>
135 #include <SALOME_ListIO.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 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1570 switch ( theCommandID ){
1571 case SMESHOp::OpFreeNode:
1572 aControl = SMESH_Actor::eFreeNodes;
1574 case SMESHOp::OpEqualNode:
1575 aControl = SMESH_Actor::eCoincidentNodes;
1577 case SMESHOp::OpFreeEdge:
1578 aControl = SMESH_Actor::eFreeEdges;
1580 case SMESHOp::OpFreeBorder:
1581 aControl = SMESH_Actor::eFreeBorders;
1583 case SMESHOp::OpLength:
1584 aControl = SMESH_Actor::eLength;
1586 case SMESHOp::OpConnection:
1587 aControl = SMESH_Actor::eMultiConnection;
1589 case SMESHOp::OpEqualEdge:
1590 aControl = SMESH_Actor::eCoincidentElems1D;
1592 case SMESHOp::OpFreeFace:
1593 aControl = SMESH_Actor::eFreeFaces;
1595 case SMESHOp::OpBareBorderFace:
1596 aControl = SMESH_Actor::eBareBorderFace;
1598 case SMESHOp::OpOverConstrainedFace:
1599 aControl = SMESH_Actor::eOverConstrainedFace;
1601 case SMESHOp::OpLength2D:
1602 aControl = SMESH_Actor::eLength2D;
1604 case SMESHOp::OpConnection2D:
1605 aControl = SMESH_Actor::eMultiConnection2D;
1607 case SMESHOp::OpArea:
1608 aControl = SMESH_Actor::eArea;
1610 case SMESHOp::OpTaper:
1611 aControl = SMESH_Actor::eTaper;
1613 case SMESHOp::OpAspectRatio:
1614 aControl = SMESH_Actor::eAspectRatio;
1616 case SMESHOp::OpMinimumAngle:
1617 aControl = SMESH_Actor::eMinimumAngle;
1619 case SMESHOp::OpWarpingAngle:
1620 aControl = SMESH_Actor::eWarping;
1622 case SMESHOp::OpSkew:
1623 aControl = SMESH_Actor::eSkew;
1625 case SMESHOp::OpMaxElementLength2D:
1626 aControl = SMESH_Actor::eMaxElementLength2D;
1628 case SMESHOp::OpEqualFace:
1629 aControl = SMESH_Actor:: eCoincidentElems2D;
1631 case SMESHOp::OpAspectRatio3D:
1632 aControl = SMESH_Actor::eAspectRatio3D;
1634 case SMESHOp::OpVolume:
1635 aControl = SMESH_Actor::eVolume3D;
1637 case SMESHOp::OpMaxElementLength3D:
1638 aControl = SMESH_Actor::eMaxElementLength3D;
1640 case SMESHOp::OpBareBorderVolume:
1641 aControl = SMESH_Actor::eBareBorderVolume;
1643 case SMESHOp::OpOverConstrainedVolume:
1644 aControl = SMESH_Actor::eOverConstrainedVolume;
1646 case SMESHOp::OpEqualVolume:
1647 aControl = SMESH_Actor::eCoincidentElems3D;
1650 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1651 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1652 SALOME_ListIO selected;
1654 aSel->selectedObjects( selected );
1656 if( !selected.IsEmpty() ){
1657 SALOME_ListIteratorOfListIO It(selected);
1658 for ( ; It.More(); It.Next())
1660 Handle(SALOME_InteractiveObject) anIO = It.Value();
1662 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1664 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1665 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
1666 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
1667 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
1668 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
1669 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1670 anActor->SetControlMode(aControl);
1671 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1672 SMESH::RepaintCurrentView();
1673 #ifndef DISABLE_PLOT2DVIEWER
1674 if(anActor->GetPlot2Histogram()) {
1675 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1676 QString functorName = functorToString( anActor->GetFunctor());
1677 QString aHistogramName("%1 : %2");
1678 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1679 aHistogram->setName(aHistogramName);
1680 aHistogram->setHorTitle(functorName);
1681 SMESH::ProcessIn2DViewers(anActor);
1693 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1694 SMESH::MeshObjectType theType,
1695 const QString theInTypeName,
1696 QString & theOutTypeName)
1698 SMESH_TypeFilter aTypeFilter( theType );
1700 if( !theIO.IsNull() )
1702 entry = theIO->getEntry();
1703 LightApp_DataOwner owner( entry );
1704 if ( aTypeFilter.isOk( &owner )) {
1705 theOutTypeName = theInTypeName;
1713 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1715 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1716 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1718 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1719 CORBA::String_var anID = aSComp->GetID().c_str();
1720 if (!strcmp(anID.in(),theIO->getEntry()))
1726 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1727 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1728 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1729 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1730 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1738 QString CheckHomogeneousSelection()
1740 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1741 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1742 SALOME_ListIO selected;
1744 aSel->selectedObjects( selected );
1746 QString RefType = CheckTypeObject(selected.First());
1747 SALOME_ListIteratorOfListIO It(selected);
1748 for ( ; It.More(); It.Next())
1750 Handle(SALOME_InteractiveObject) IObject = It.Value();
1751 QString Type = CheckTypeObject(IObject);
1752 if (Type.compare(RefType) != 0)
1753 return "Heterogeneous Selection";
1761 void SMESHGUI::OnEditDelete()
1763 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1764 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1765 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1767 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1768 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1769 _PTR(GenericAttribute) anAttr;
1770 _PTR(AttributeIOR) anIOR;
1772 int objectCount = 0;
1774 QString aParentComponent = QString::null;
1775 Handle(SALOME_InteractiveObject) anIO;
1776 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1778 anIO = anIt.Value();
1779 QString cur = anIO->getComponentDataType();
1780 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1782 // check if object is reference
1783 _PTR(SObject) aRefSObj;
1784 aNameList.append("\n - ");
1785 if ( aSO->ReferencedObject( aRefSObj ) ) {
1786 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1787 aNameList.append( aRefName );
1788 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1791 aNameList.append(anIO->getName());
1795 if( aParentComponent.isNull() )
1796 aParentComponent = cur;
1797 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1798 aParentComponent = "";
1801 if ( objectCount == 0 )
1802 return; // No Valid Objects Selected
1804 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1805 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1806 QObject::tr("ERR_ERROR"),
1807 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1810 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1811 if (SUIT_MessageBox::warning
1812 (SMESHGUI::desktop(),
1813 QObject::tr("SMESH_WRN_WARNING"),
1814 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1815 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1816 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1819 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1821 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1822 // then treat them all starting from the deepest objects (at list back)
1823 std::list< _PTR(SObject) > listSO;
1824 SALOME_ListIteratorOfListIO It(selected);
1825 for( ; It.More(); It.Next()) // loop on selected IO's
1827 Handle(SALOME_InteractiveObject) IObject = It.Value();
1828 if(IObject->hasEntry()) {
1829 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1831 // disable removal of "SMESH" component object
1832 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1834 if ( engineIOR() == anIOR->Value().c_str() )
1837 //Check the referenced object
1838 _PTR(SObject) aRefSObject;
1839 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1840 aSO = aRefSObject; // Delete main Object instead of reference
1842 listSO.push_back( aSO );
1843 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1844 for ( ; itSO != listSO.end(); ++itSO ) {
1845 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1846 for (it->InitEx(false); it->More(); it->Next())
1847 listSO.push_back( it->Value() );
1851 // Check if none of objects to delete is referred from outside
1852 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1853 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1855 _PTR(SObject) SO = *ritSO;
1856 if ( !SO ) continue;
1857 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1858 for (size_t i = 0; i < aReferences.size(); i++) {
1859 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1860 std::string type = aComponent->ComponentDataType();
1861 if ( type != "SMESH" )
1863 SUIT_MessageBox::warning( anApp->desktop(),
1864 QObject::tr("WRN_WARNING"),
1865 QObject::tr("DEP_OBJECT") );
1866 return; // outside SMESH, there is an object depending on a SMESH object
1871 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1872 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1874 Handle(SALOME_InteractiveObject) IObject = It.Value();
1875 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1876 if ( !mesh->_is_nil() )
1880 // Treat SO's in the list starting from the back
1881 aStudyBuilder->NewCommand(); // There is a transaction
1882 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1884 _PTR(SObject) SO = *ritSO;
1885 if ( !SO ) continue;
1886 std::string anEntry = SO->GetID();
1888 /** Erase graphical object and remove all its data **/
1889 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1890 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1892 /** Remove an object from data structures **/
1893 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1894 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1895 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1896 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1897 aMesh->RemoveGroup( aGroup );
1899 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1900 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1901 aMesh->RemoveSubMesh( aSubMesh );
1903 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1905 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1908 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1909 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1910 QString objType = CheckTypeObject(IObject);
1911 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1912 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1913 aStudyBuilder->RemoveObjectWithChildren( SO );
1915 else {// default action: remove SObject from the study
1916 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1917 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1919 aStudyBuilder->RemoveObjectWithChildren( SO );
1923 } /* listSO back loop */
1925 aStudyBuilder->CommitCommand();
1927 /* Clear any previous selection */
1929 aSel->setSelectedObjects( l1 );
1931 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1935 SMESHGUI_EXPORT CAM_Module* createModule()
1937 return new SMESHGUI();
1940 SMESHGUI_EXPORT char* getModuleVersion() {
1941 return (char*)SMESH_VERSION_STR;
1945 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1947 //=============================================================================
1951 //=============================================================================
1952 SMESHGUI::SMESHGUI() :
1953 SalomeApp_Module( "SMESH" )
1955 if ( CORBA::is_nil( myComponentSMESH ) )
1957 CORBA::Boolean anIsEmbeddedMode;
1958 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1959 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1961 // 0019923: EDF 765 SMESH : default values of hypothesis
1962 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1963 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1964 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1965 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1966 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1968 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1969 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1970 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1972 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1973 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1977 myActiveDialogBox = 0;
1978 myFilterLibraryDlg = 0;
1982 myEventCallbackCommand = vtkCallbackCommand::New();
1983 myEventCallbackCommand->Delete();
1984 myEventCallbackCommand->SetClientData( this );
1985 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1988 /* load resources for all available meshers */
1989 SMESH::InitAvailableHypotheses();
1992 //=============================================================================
1996 //=============================================================================
1997 SMESHGUI::~SMESHGUI()
2001 //=============================================================================
2005 //=============================================================================
2006 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2008 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2010 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2015 //=============================================================================
2019 //=============================================================================
2020 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2022 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2026 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2027 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2028 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2029 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2030 return autoUpdate && !exceeded;
2033 //=============================================================================
2037 //=============================================================================
2038 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2039 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2041 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2045 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2046 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2047 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2049 SMESH::long_array_var info = theMesh->GetMeshInfo();
2050 long nbOdElems = info[SMDSEntity_0D];
2051 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2052 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2053 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2054 info[SMDSEntity_Polygon];
2055 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2056 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2057 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2058 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
2059 info[SMDSEntity_Polyhedra] +
2060 info[SMDSEntity_Hexagonal_Prism];
2061 long nbBalls = info[SMDSEntity_Ball];
2063 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2064 *nbElements = requestedSize;
2066 *entities = SMESH_Actor::eAllEntity;
2069 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2071 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2073 if ( incrementalLimit ) {
2076 if ( nbOdElems > 0 ) {
2077 if ( total + nbOdElems > updateLimit ) {
2078 *entities = *entities & ~SMESH_Actor::e0DElements;
2079 *hidden = *hidden | SMESH_Actor::e0DElements;
2086 if ( nbEdges > 0 ) {
2087 if ( total + nbEdges > updateLimit ) {
2088 *entities = *entities & ~SMESH_Actor::eEdges;
2089 *hidden = *hidden | SMESH_Actor::eEdges;
2096 if ( nbFaces > 0 ) {
2097 if ( total + nbFaces > updateLimit ) {
2098 *entities = *entities & ~SMESH_Actor::eFaces;
2099 *hidden = *hidden | SMESH_Actor::eFaces;
2106 if ( nbVolumes > 0 ) {
2107 if ( total + nbVolumes > updateLimit ) {
2108 *entities = *entities & ~SMESH_Actor::eVolumes;
2109 *hidden = *hidden | SMESH_Actor::eVolumes;
2116 if ( nbBalls > 0 ) {
2117 if ( total + nbBalls > updateLimit ) {
2118 *entities = *entities & ~SMESH_Actor::eBallElem;
2119 *hidden = *hidden | SMESH_Actor::eBallElem;
2127 return autoUpdate && !exceeded;
2130 //=============================================================================
2134 //=============================================================================
2135 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2137 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2140 //=============================================================================
2144 //=============================================================================
2145 SMESHGUI* SMESHGUI::GetSMESHGUI()
2147 SMESHGUI* smeshMod = 0;
2148 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2151 CAM_Module* module = app->module( "Mesh" );
2152 smeshMod = dynamic_cast<SMESHGUI*>( module );
2155 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2157 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2160 _PTR(Study) aStudy = study->studyDS();
2162 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2171 Standard_EXPORT SMESHGUI* GetComponentGUI()
2173 return SMESHGUI::GetSMESHGUI();
2177 //=============================================================================
2181 //=============================================================================
2182 void SMESHGUI::SetState(int aState)
2187 //=============================================================================
2191 //=============================================================================
2192 void SMESHGUI::ResetState()
2197 //=============================================================================
2201 //=============================================================================
2202 void SMESHGUI::EmitSignalDeactivateDialog()
2204 emit SignalDeactivateActiveDialog();
2207 //=============================================================================
2211 //=============================================================================
2212 void SMESHGUI::EmitSignalStudyFrameChanged()
2214 emit SignalStudyFrameChanged();
2217 //=============================================================================
2221 //=============================================================================
2222 void SMESHGUI::EmitSignalCloseAllDialogs()
2224 emit SignalCloseAllDialogs();
2227 //=============================================================================
2231 //=============================================================================
2232 void SMESHGUI::EmitSignalVisibilityChanged()
2234 emit SignalVisibilityChanged();
2237 //=============================================================================
2241 //=============================================================================
2242 QDialog *SMESHGUI::GetActiveDialogBox()
2244 return myActiveDialogBox;
2247 //=============================================================================
2251 //=============================================================================
2252 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2254 myActiveDialogBox = (QDialog *) aDlg;
2258 //=============================================================================
2262 //=============================================================================
2263 SUIT_Desktop* SMESHGUI::desktop()
2265 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2267 return app->desktop();
2272 //=============================================================================
2276 //=============================================================================
2277 SalomeApp_Study* SMESHGUI::activeStudy()
2279 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2281 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2286 //=============================================================================
2290 //=============================================================================
2291 void SMESHGUI::Modified( bool theIsUpdateActions )
2293 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2294 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2295 appStudy->Modified();
2296 if( theIsUpdateActions )
2297 app->updateActions();
2302 //=============================================================================
2306 //=============================================================================
2307 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2309 /* Here the position is on the bottom right corner - 10 */
2310 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2312 SUIT_Desktop *PP = desktop();
2313 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2314 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2318 //=============================================================================
2322 //=============================================================================
2323 static int isStudyLocked(_PTR(Study) theStudy){
2324 return theStudy->GetProperties()->IsLocked();
2327 static bool checkLock(_PTR(Study) theStudy) {
2328 if (isStudyLocked(theStudy)) {
2329 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2330 QObject::tr("WRN_WARNING"),
2331 QObject::tr("WRN_STUDY_LOCKED") );
2337 //=======================================================================
2338 //function : CheckActiveStudyLocked
2340 //=======================================================================
2342 bool SMESHGUI::isActiveStudyLocked()
2344 _PTR(Study) aStudy = activeStudy()->studyDS();
2345 return checkLock( aStudy );
2348 //=============================================================================
2352 //=============================================================================
2353 bool SMESHGUI::OnGUIEvent( int theCommandID )
2355 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2359 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2360 SUIT_ResourceMgr* mgr = resourceMgr();
2364 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2365 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2368 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2369 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2371 //QAction* act = action( theCommandID );
2373 switch (theCommandID) {
2374 case SMESHOp::OpDelete:
2375 if(checkLock(aStudy)) break;
2378 case SMESHOp::OpImportDAT:
2379 case SMESHOp::OpImportUNV:
2380 case SMESHOp::OpImportMED:
2381 case SMESHOp::OpImportSTL:
2383 case SMESHOp::OpImportCGNS:
2385 case SMESHOp::OpImportSAUV:
2386 case SMESHOp::OpImportGMF:
2388 if(checkLock(aStudy)) break;
2389 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2393 case SMESHOp::OpFileInformation:
2395 SALOME_ListIO selected;
2396 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2398 aSel->selectedObjects( selected );
2399 if( selected.Extent() )
2401 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2402 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2403 if ( !aMesh->_is_nil() )
2405 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2411 case SMESHOp::OpExportDAT:
2412 case SMESHOp::OpExportMED:
2413 case SMESHOp::OpExportUNV:
2414 case SMESHOp::OpExportSTL:
2416 case SMESHOp::OpExportCGNS:
2418 case SMESHOp::OpExportSAUV:
2419 case SMESHOp::OpExportGMF:
2420 case SMESHOp::OpPopupExportDAT:
2421 case SMESHOp::OpPopupExportMED:
2422 case SMESHOp::OpPopupExportUNV:
2423 case SMESHOp::OpPopupExportSTL:
2425 case SMESHOp::OpPopupExportCGNS:
2427 case SMESHOp::OpPopupExportSAUV:
2428 case SMESHOp::OpPopupExportGMF:
2430 ::ExportMeshToFile(theCommandID);
2434 case SMESHOp::OpReset: // SCALAR BAR
2436 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2437 SALOME_ListIO selected;
2439 aSel->selectedObjects( selected );
2441 if( selected.Extent() ) {
2442 Handle(SALOME_InteractiveObject) anIO = selected.First();
2443 if( anIO->hasEntry() ) {
2444 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2445 anActor->SetControlMode( SMESH_Actor::eNone );
2446 #ifndef DISABLE_PLOT2DVIEWER
2447 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2454 case SMESHOp::OpScalarBarProperties:
2456 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2459 case SMESHOp::OpSaveDistribution:
2461 // dump control distribution data to the text file
2462 ::SaveDistribution();
2466 case SMESHOp::OpShowDistribution:
2468 // show/ distribution
2469 ::ShowDistribution();
2473 #ifndef DISABLE_PLOT2DVIEWER
2474 case SMESHOp::OpPlotDistribution:
2476 // plot distribution
2477 ::PlotDistribution();
2483 case SMESHOp::OpAutoColor:
2487 case SMESHOp::OpDisableAutoColor:
2488 ::DisableAutoColor();
2491 case SMESHOp::OpClipping:
2492 case SMESHOp::OpTransparency:
2493 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2496 case SMESHOp::OpDMWireframe:
2497 case SMESHOp::OpDMShading:
2498 case SMESHOp::OpDMNodes:
2499 case SMESHOp::OpDMShrink:
2500 ::SetDisplayMode(theCommandID, myMarkerMap);
2503 //2D quadratic representation
2504 case SMESHOp::OpRepresentationLines:
2505 case SMESHOp::OpRepresentationArcs:
2506 ::SetDisplayMode(theCommandID, myMarkerMap);
2510 case SMESHOp::OpDE0DElements:
2511 case SMESHOp::OpDEEdges:
2512 case SMESHOp::OpDEFaces:
2513 case SMESHOp::OpDEVolumes:
2514 case SMESHOp::OpDEBalls:
2515 case SMESHOp::OpDEAllEntity:
2516 ::SetDisplayEntity(theCommandID);
2519 // Choose entities to be displayed
2520 case SMESHOp::OpDEChoose:
2522 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2526 case SMESHOp::OpOrientationOnFaces:
2528 LightApp_SelectionMgr* mgr = selectionMgr();
2529 SALOME_ListIO selected; mgr->selectedObjects( selected );
2531 SALOME_ListIteratorOfListIO it(selected);
2532 for( ; it.More(); it.Next()) {
2533 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2534 if(anIObject->hasEntry()) {
2535 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2536 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2543 case SMESHOp::OpUpdate:
2545 if(checkLock(aStudy)) break;
2546 SUIT_OverrideCursor wc;
2548 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2551 SMESH::UpdateView();
2553 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2554 SMESH::OnVisuException();
2556 catch (...) { // PAL16774 (Crash after display of many groups)
2557 SMESH::OnVisuException();
2561 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2562 aSel->selectedObjects( l );
2563 aSel->setSelectedObjects( l );
2567 case SMESHOp::OpHide:
2568 case SMESHOp::OpShow:
2569 case SMESHOp::OpShowOnly:
2571 SMESH::EDisplaing anAction;
2572 switch (theCommandID) {
2573 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2574 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2575 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2578 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2579 SALOME_ListIO sel_objects, to_process;
2581 aSel->selectedObjects( sel_objects );
2583 if( theCommandID==SMESHOp::OpShowOnly )
2585 MESSAGE("anAction = SMESH::eDisplayOnly");
2586 startOperation( myEraseAll );
2589 extractContainers( sel_objects, to_process );
2592 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2596 SALOME_ListIteratorOfListIO It( to_process );
2597 for ( ; It.More(); It.Next()) {
2599 Handle(SALOME_InteractiveObject) IOS = It.Value();
2600 if (IOS->hasEntry()) {
2602 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2603 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2604 break; // PAL16774 (Crash after display of many groups)
2606 if (anAction == SMESH::eDisplayOnly)
2608 MESSAGE("anAction = SMESH::eDisplayOnly");
2609 anAction = SMESH::eDisplay;
2615 // PAL13338 + PAL15161 -->
2616 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2617 MESSAGE("anAction = SMESH::eDisplayOnly");
2618 SMESH::UpdateView();
2619 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2621 // PAL13338 + PAL15161 <--
2623 catch (...) { // PAL16774 (Crash after display of many groups)
2624 SMESH::OnVisuException();
2627 if (anAction == SMESH::eErase) {
2628 MESSAGE("anAction == SMESH::eErase");
2630 aSel->setSelectedObjects( l1 );
2633 aSel->setSelectedObjects( to_process );
2638 case SMESHOp::OpNode:
2640 if(checkLock(aStudy)) break;
2643 EmitSignalDeactivateDialog();
2645 ( new SMESHGUI_NodesDlg( this ) )->show();
2648 SUIT_MessageBox::warning(desktop(),
2649 tr("SMESH_WRN_WARNING"),
2650 tr("SMESH_WRN_VIEWER_VTK"));
2655 case SMESHOp::OpCreateMesh:
2656 case SMESHOp::OpCreateSubMesh:
2657 case SMESHOp::OpEditMeshOrSubMesh:
2658 case SMESHOp::OpCompute:
2659 case SMESHOp::OpPreCompute:
2660 case SMESHOp::OpEvaluate:
2661 case SMESHOp::OpMeshOrder:
2662 startOperation( theCommandID );
2664 case SMESHOp::OpCopyMesh:
2666 if (checkLock(aStudy)) break;
2667 EmitSignalDeactivateDialog();
2668 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2671 case SMESHOp::OpBuildCompoundMesh:
2673 if (checkLock(aStudy)) break;
2674 EmitSignalDeactivateDialog();
2675 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2679 case SMESHOp::OpDiagonalInversion:
2680 case SMESHOp::OpUnionOfTwoTriangle:
2684 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2685 tr( "NOT_A_VTK_VIEWER" ) );
2689 if ( checkLock( aStudy ) )
2692 /*Standard_Boolean aRes;
2693 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2694 if ( aMesh->_is_nil() )
2696 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2697 tr( "SMESH_BAD_SELECTION" ) );
2701 EmitSignalDeactivateDialog();
2702 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2703 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2705 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2708 case SMESHOp::OpOrientation:
2709 case SMESHOp::OpUnionOfTriangles:
2710 case SMESHOp::OpCuttingOfQuadrangles:
2711 case SMESHOp::OpSplitVolumes:
2715 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2716 tr( "NOT_A_VTK_VIEWER" ) );
2720 if ( checkLock( aStudy ) )
2723 EmitSignalDeactivateDialog();
2724 SMESHGUI_MultiEditDlg* aDlg = NULL;
2725 if ( theCommandID == SMESHOp::OpOrientation )
2726 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2727 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2728 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2729 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2730 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2732 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2737 case SMESHOp::OpSmoothing:
2739 if(checkLock(aStudy)) break;
2741 EmitSignalDeactivateDialog();
2742 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2745 SUIT_MessageBox::warning(desktop(),
2746 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2750 case SMESHOp::OpExtrusion:
2752 if (checkLock(aStudy)) break;
2754 EmitSignalDeactivateDialog();
2755 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2757 SUIT_MessageBox::warning(desktop(),
2758 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2762 case SMESHOp::OpExtrusionAlongAPath:
2764 if (checkLock(aStudy)) break;
2766 EmitSignalDeactivateDialog();
2767 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2769 SUIT_MessageBox::warning(desktop(),
2770 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2774 case SMESHOp::OpRevolution:
2776 if(checkLock(aStudy)) break;
2778 EmitSignalDeactivateDialog();
2779 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2782 SUIT_MessageBox::warning(desktop(),
2783 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2787 case SMESHOp::OpPatternMapping:
2789 if ( checkLock( aStudy ) )
2793 EmitSignalDeactivateDialog();
2794 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2797 SUIT_MessageBox::warning(desktop(),
2798 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2802 case SMESHOp::OpConvertMeshToQuadratic:
2803 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2804 case SMESHOp::OpReorientFaces:
2805 case SMESHOp::OpCreateGeometryGroup:
2807 startOperation( theCommandID );
2810 case SMESHOp::OpCreateGroup:
2814 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2815 tr( "NOT_A_VTK_VIEWER" ) );
2819 if(checkLock(aStudy)) break;
2820 EmitSignalDeactivateDialog();
2821 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2823 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2824 SALOME_ListIO selected;
2826 aSel->selectedObjects( selected );
2828 int nbSel = selected.Extent();
2830 // check if mesh is selected
2831 aMesh = SMESH::GetMeshByIO( selected.First() );
2833 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2838 case SMESHOp::OpConstructGroup:
2842 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2843 tr( "NOT_A_VTK_VIEWER" ) );
2847 if(checkLock(aStudy)) break;
2848 EmitSignalDeactivateDialog();
2850 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2851 SALOME_ListIO selected;
2853 aSel->selectedObjects( selected );
2855 int nbSel = selected.Extent();
2857 // check if submesh is selected
2858 Handle(SALOME_InteractiveObject) IObject = selected.First();
2859 if (IObject->hasEntry()) {
2860 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2862 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2863 if (!aSubMesh->_is_nil()) {
2865 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2866 // get submesh elements list by types
2867 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2868 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2869 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2870 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2871 // create group for each type o elements
2872 QString aName = IObject->getName();
2873 QStringList anEntryList;
2874 if (aNodes->length() > 0) {
2875 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2876 aGroup->Add(aNodes.inout());
2877 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2878 anEntryList.append( aSObject->GetID().c_str() );
2880 if (aEdges->length() > 0) {
2881 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2882 aGroup->Add(aEdges.inout());
2883 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2884 anEntryList.append( aSObject->GetID().c_str() );
2886 if (aFaces->length() > 0) {
2887 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2888 aGroup->Add(aFaces.inout());
2889 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2890 anEntryList.append( aSObject->GetID().c_str() );
2892 if (aVolumes->length() > 0) {
2893 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2894 aGroup->Add(aVolumes.inout());
2895 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2896 anEntryList.append( aSObject->GetID().c_str() );
2899 anApp->browseObjects( anEntryList );
2901 catch(const SALOME::SALOME_Exception & S_ex){
2902 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2909 SUIT_MessageBox::warning(desktop(),
2910 tr("SMESH_WRN_WARNING"),
2911 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2916 case SMESHOp::OpEditGroup:
2920 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2921 tr( "NOT_A_VTK_VIEWER" ) );
2925 if(checkLock(aStudy)) break;
2926 EmitSignalDeactivateDialog();
2928 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2929 SALOME_ListIO selected;
2931 aSel->selectedObjects( selected );
2933 SALOME_ListIteratorOfListIO It (selected);
2934 int nbSelectedGroups = 0;
2935 for ( ; It.More(); It.Next() )
2937 SMESH::SMESH_GroupBase_var aGroup =
2938 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2939 if (!aGroup->_is_nil()) {
2941 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2945 if (nbSelectedGroups == 0)
2947 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2953 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
2955 if(checkLock(aStudy)) break;
2956 if (myState == 800) {
2957 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2958 if (aDlg) aDlg->onAdd();
2963 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
2965 if(checkLock(aStudy)) break;
2966 if (myState == 800) {
2967 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2968 if (aDlg) aDlg->onRemove();
2973 case SMESHOp::OpEditGeomGroupAsGroup:
2977 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2978 tr( "NOT_A_VTK_VIEWER" ) );
2982 if(checkLock(aStudy)) break;
2983 EmitSignalDeactivateDialog();
2985 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2986 SALOME_ListIO selected;
2988 aSel->selectedObjects( selected );
2990 SALOME_ListIteratorOfListIO It (selected);
2991 for ( ; It.More(); It.Next() )
2993 SMESH::SMESH_GroupOnGeom_var aGroup =
2994 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2995 if (!aGroup->_is_nil()) {
2996 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3001 SMESH::SMESH_GroupOnFilter_var aGroup =
3002 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3003 if (!aGroup->_is_nil()) {
3004 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3012 case SMESHOp::OpUnionGroups:
3013 case SMESHOp::OpIntersectGroups:
3014 case SMESHOp::OpCutGroups:
3018 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3019 tr( "NOT_A_VTK_VIEWER" ) );
3023 if ( checkLock( aStudy ) )
3026 EmitSignalDeactivateDialog();
3028 SMESHGUI_GroupOpDlg* aDlg = 0;
3029 if ( theCommandID == SMESHOp::OpUnionGroups )
3030 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3031 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3032 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3034 aDlg = new SMESHGUI_CutGroupsDlg( this );
3041 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3043 if ( checkLock( aStudy ) )
3046 EmitSignalDeactivateDialog();
3047 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3053 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3057 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3058 tr( "NOT_A_VTK_VIEWER" ) );
3062 if ( checkLock( aStudy ) )
3065 EmitSignalDeactivateDialog();
3067 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3071 case SMESHOp::OpMeshInformation:
3072 case SMESHOp::OpWhatIs:
3074 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3075 EmitSignalDeactivateDialog();
3076 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3077 SALOME_ListIO selected;
3079 aSel->selectedObjects( selected );
3081 if ( selected.Extent() > 1 ) { // a dlg for each IO
3082 SALOME_ListIteratorOfListIO It( selected );
3083 for ( ; It.More(); It.Next() ) {
3084 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3085 dlg->showInfo( It.Value() );
3090 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3096 case SMESHOp::OpFindElementByPoint:
3098 startOperation( theCommandID );
3102 case SMESHOp::OpEditHypothesis:
3104 if(checkLock(aStudy)) break;
3106 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3107 SALOME_ListIO selected;
3109 aSel->selectedObjects( selected );
3111 int nbSel = selected.Extent();
3114 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3115 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3117 if ( !aHypothesis->_is_nil() )
3119 SMESHGUI_GenericHypothesisCreator* aCreator =
3120 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3123 // set geometry of mesh and sub-mesh to aCreator
3124 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3125 if ( selected.Extent() == 1 )
3127 QString subGeomID, meshGeomID;
3128 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3129 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3131 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3132 aCreator->setShapeEntry( subGeomID );
3133 aCreator->setMainShapeEntry( meshGeomID );
3137 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3147 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3149 if(checkLock(aStudy)) break;
3150 SUIT_OverrideCursor wc;
3152 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3153 SALOME_ListIO selected;
3155 aSel->selectedObjects( selected, QString::null, false );
3157 SALOME_ListIteratorOfListIO It(selected);
3158 for (int i = 0; It.More(); It.Next(), i++) {
3159 Handle(SALOME_InteractiveObject) IObject = It.Value();
3160 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3163 aSel->setSelectedObjects( l1 );
3168 case SMESHOp::OpElem0D:
3169 case SMESHOp::OpBall:
3170 case SMESHOp::OpEdge:
3171 case SMESHOp::OpTriangle:
3172 case SMESHOp::OpQuadrangle:
3173 case SMESHOp::OpPolygon:
3174 case SMESHOp::OpTetrahedron:
3175 case SMESHOp::OpHexahedron:
3176 case SMESHOp::OpPentahedron:
3177 case SMESHOp::OpPyramid:
3178 case SMESHOp::OpHexagonalPrism:
3180 if(checkLock(aStudy)) break;
3182 EmitSignalDeactivateDialog();
3183 SMDSAbs_EntityType type = SMDSEntity_Edge;
3184 switch (theCommandID) {
3185 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3186 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3187 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3188 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3189 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3190 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3191 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3192 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3193 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3194 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3197 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3200 SUIT_MessageBox::warning(desktop(),
3201 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3205 case SMESHOp::OpPolyhedron:
3207 if(checkLock(aStudy)) break;
3209 EmitSignalDeactivateDialog();
3210 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3213 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3214 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3218 case SMESHOp::OpQuadraticEdge:
3219 case SMESHOp::OpQuadraticTriangle:
3220 case SMESHOp::OpBiQuadraticTriangle:
3221 case SMESHOp::OpQuadraticQuadrangle:
3222 case SMESHOp::OpBiQuadraticQuadrangle:
3223 case SMESHOp::OpQuadraticTetrahedron:
3224 case SMESHOp::OpQuadraticPyramid:
3225 case SMESHOp::OpQuadraticPentahedron:
3226 case SMESHOp::OpQuadraticHexahedron:
3227 case SMESHOp::OpTriQuadraticHexahedron:
3229 if(checkLock(aStudy)) break;
3231 EmitSignalDeactivateDialog();
3232 SMDSAbs_EntityType type = SMDSEntity_Last;
3234 switch (theCommandID) {
3235 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3236 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3237 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3238 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3239 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3240 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3241 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3242 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3243 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3244 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3247 if ( type != SMDSEntity_Last )
3248 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3251 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3252 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3256 case SMESHOp::OpRemoveNodes:
3258 if(checkLock(aStudy)) break;
3260 EmitSignalDeactivateDialog();
3261 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3264 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3265 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3269 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3271 if(checkLock(aStudy)) break;
3273 EmitSignalDeactivateDialog();
3274 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3278 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3279 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3283 case SMESHOp::OpClearMesh: {
3285 if(checkLock(aStudy)) break;
3287 SALOME_ListIO selected;
3288 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3289 aSel->selectedObjects( selected );
3291 SUIT_OverrideCursor wc;
3292 SALOME_ListIteratorOfListIO It (selected);
3293 for ( ; It.More(); It.Next() )
3295 Handle(SALOME_InteractiveObject) IOS = It.Value();
3296 SMESH::SMESH_Mesh_var aMesh =
3297 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3298 if ( aMesh->_is_nil()) continue;
3300 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3302 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3303 SMESH::ModifiedMesh( aMeshSObj, false, true);
3304 // hide groups and submeshes
3305 _PTR(ChildIterator) anIter =
3306 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3307 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3309 _PTR(SObject) so = anIter->Value();
3310 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3313 catch (const SALOME::SALOME_Exception& S_ex){
3315 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3319 SMESH::UpdateView();
3323 case SMESHOp::OpRemoveOrphanNodes:
3325 if(checkLock(aStudy)) break;
3326 SALOME_ListIO selected;
3327 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3328 aSel->selectedObjects( selected );
3329 if ( selected.Extent() == 1 ) {
3330 Handle(SALOME_InteractiveObject) anIO = selected.First();
3331 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3332 if ( !aMesh->_is_nil() ) {
3333 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3334 tr( "SMESH_WARNING" ),
3335 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3336 SUIT_MessageBox::Yes |
3337 SUIT_MessageBox::No,
3338 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3341 SUIT_OverrideCursor wc;
3342 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3343 int removed = aMeshEditor->RemoveOrphanNodes();
3344 SUIT_MessageBox::information(SMESHGUI::desktop(),
3345 tr("SMESH_INFORMATION"),
3346 tr("NB_NODES_REMOVED").arg(removed));
3347 if ( removed > 0 ) {
3348 SMESH::UpdateView();
3349 SMESHGUI::Modified();
3352 catch (const SALOME::SALOME_Exception& S_ex) {
3353 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3362 case SMESHOp::OpRenumberingNodes:
3364 if(checkLock(aStudy)) break;
3366 EmitSignalDeactivateDialog();
3367 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3371 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3372 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3376 case SMESHOp::OpRenumberingElements:
3378 if(checkLock(aStudy)) break;
3380 EmitSignalDeactivateDialog();
3381 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3385 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3386 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3390 case SMESHOp::OpTranslation:
3392 if(checkLock(aStudy)) break;
3394 EmitSignalDeactivateDialog();
3395 ( new SMESHGUI_TranslationDlg( this ) )->show();
3398 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3399 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3403 case SMESHOp::OpRotation:
3405 if(checkLock(aStudy)) break;
3407 EmitSignalDeactivateDialog();
3408 ( new SMESHGUI_RotationDlg( this ) )->show();
3411 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3412 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3416 case SMESHOp::OpSymmetry:
3418 if(checkLock(aStudy)) break;
3420 EmitSignalDeactivateDialog();
3421 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3424 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3425 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3429 case SMESHOp::OpScale:
3431 if(checkLock(aStudy)) break;
3433 EmitSignalDeactivateDialog();
3434 ( new SMESHGUI_ScaleDlg( this ) )->show();
3437 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3438 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3443 case SMESHOp::OpSewing:
3445 if(checkLock(aStudy)) break;
3447 EmitSignalDeactivateDialog();
3448 ( new SMESHGUI_SewingDlg( this ) )->show();
3451 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3452 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3456 case SMESHOp::OpMergeNodes:
3458 if(checkLock(aStudy)) break;
3460 EmitSignalDeactivateDialog();
3461 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3464 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3465 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3469 case SMESHOp::OpMergeElements:
3471 if (checkLock(aStudy)) break;
3473 EmitSignalDeactivateDialog();
3474 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3476 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3477 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3482 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3483 startOperation( SMESHOp::OpMoveNode );
3486 case SMESHOp::OpDuplicateNodes:
3488 if(checkLock(aStudy)) break;
3490 EmitSignalDeactivateDialog();
3491 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3494 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3495 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3500 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3501 startOperation( SMESHOp::OpElem0DOnElemNodes );
3504 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3506 static QList<int> aTypes;
3507 if ( aTypes.isEmpty() )
3509 aTypes.append( SMESH::NODE );
3510 aTypes.append( SMESH::EDGE );
3511 aTypes.append( SMESH::FACE );
3512 aTypes.append( SMESH::VOLUME );
3514 if (!myFilterLibraryDlg)
3515 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3516 else if (myFilterLibraryDlg->isHidden())
3517 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3518 myFilterLibraryDlg->raise();
3522 case SMESHOp::OpFreeNode:
3523 case SMESHOp::OpEqualNode:
3524 case SMESHOp::OpFreeEdge:
3525 case SMESHOp::OpFreeBorder:
3526 case SMESHOp::OpLength:
3527 case SMESHOp::OpConnection:
3528 case SMESHOp::OpEqualEdge:
3529 case SMESHOp::OpFreeFace:
3530 case SMESHOp::OpBareBorderFace:
3531 case SMESHOp::OpOverConstrainedFace:
3532 case SMESHOp::OpLength2D:
3533 case SMESHOp::OpConnection2D:
3534 case SMESHOp::OpArea:
3535 case SMESHOp::OpTaper:
3536 case SMESHOp::OpAspectRatio:
3537 case SMESHOp::OpMinimumAngle:
3538 case SMESHOp::OpWarpingAngle:
3539 case SMESHOp::OpSkew:
3540 case SMESHOp::OpMaxElementLength2D:
3541 case SMESHOp::OpEqualFace:
3542 case SMESHOp::OpAspectRatio3D:
3543 case SMESHOp::OpVolume:
3544 case SMESHOp::OpMaxElementLength3D:
3545 case SMESHOp::OpBareBorderVolume:
3546 case SMESHOp::OpOverConstrainedVolume:
3547 case SMESHOp::OpEqualVolume:
3550 LightApp_SelectionMgr* mgr = selectionMgr();
3551 SALOME_ListIO selected; mgr->selectedObjects( selected );
3553 if( !selected.IsEmpty() ) {
3554 SUIT_OverrideCursor wc;
3555 ::Control( theCommandID );
3558 SUIT_MessageBox::warning(desktop(),
3559 tr( "SMESH_WRN_WARNING" ),
3560 tr( "SMESH_BAD_SELECTION" ) );
3564 SUIT_MessageBox::warning(desktop(),
3565 tr( "SMESH_WRN_WARNING" ),
3566 tr( "NOT_A_VTK_VIEWER" ) );
3569 case SMESHOp::OpOverallMeshQuality:
3570 OverallMeshQuality();
3572 case SMESHOp::OpNumberingNodes:
3574 SUIT_OverrideCursor wc;
3575 LightApp_SelectionMgr* mgr = selectionMgr();
3576 SALOME_ListIO selected; mgr->selectedObjects( selected );
3578 SALOME_ListIteratorOfListIO it(selected);
3579 for( ; it.More(); it.Next()) {
3580 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3581 if(anIObject->hasEntry()) {
3582 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3583 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3589 case SMESHOp::OpNumberingElements:
3591 SUIT_OverrideCursor wc;
3592 LightApp_SelectionMgr* mgr = selectionMgr();
3593 SALOME_ListIO selected; mgr->selectedObjects( selected );
3595 SALOME_ListIteratorOfListIO it(selected);
3596 for( ; it.More(); it.Next()) {
3597 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3598 if(anIObject->hasEntry())
3599 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3600 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3605 case SMESHOp::OpPropertiesLength:
3606 case SMESHOp::OpPropertiesArea:
3607 case SMESHOp::OpPropertiesVolume:
3608 case SMESHOp::OpMinimumDistance:
3609 case SMESHOp::OpBoundingBox:
3611 int page = SMESHGUI_MeasureDlg::MinDistance;
3612 if ( theCommandID == SMESHOp::OpBoundingBox )
3613 page = SMESHGUI_MeasureDlg::BoundingBox;
3614 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3615 page = SMESHGUI_MeasureDlg::Length;
3616 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3617 page = SMESHGUI_MeasureDlg::Area;
3618 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3619 page = SMESHGUI_MeasureDlg::Volume;
3621 EmitSignalDeactivateDialog();
3622 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3626 case SMESHOp::OpSortChild:
3632 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3633 //updateObjBrowser();
3637 //=============================================================================
3641 //=============================================================================
3642 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3647 //=============================================================================
3651 //=============================================================================
3652 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3657 //=============================================================================
3661 //=============================================================================
3662 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3667 //=============================================================================
3668 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3669 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3671 //=============================================================================
3672 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3673 SUIT_ViewWindow* wnd )
3675 if(theIO->hasEntry()){
3676 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3677 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3681 //=======================================================================
3682 // function : createSMESHAction
3684 //=======================================================================
3685 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3686 const int key, const bool toggle, const QString& shortcutAction )
3689 QWidget* parent = application()->desktop();
3690 SUIT_ResourceMgr* resMgr = resourceMgr();
3692 if ( !icon_id.isEmpty() )
3693 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3695 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3696 if ( !pix.isNull() )
3697 icon = QIcon( pix );
3699 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3700 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3701 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3703 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3704 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3707 //=======================================================================
3708 // function : createPopupItem
3710 //=======================================================================
3711 void SMESHGUI::createPopupItem( const int id,
3712 const QString& clients,
3713 const QString& types,
3714 const QString& theRule,
3717 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3718 popupMgr()->insert( action( id ), pId, 0 );
3720 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3721 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3722 QString rule = "(%1) and (%2) and (%3)";
3723 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3724 if( clients.isEmpty() )
3725 rule = rule.arg( QString( "true" ) );
3727 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3728 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3731 bool cont = myRules.contains( id );
3733 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3735 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3736 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3739 //=======================================================================
3740 // function : initialize
3742 //=======================================================================
3743 void SMESHGUI::initialize( CAM_Application* app )
3745 SalomeApp_Module::initialize( app );
3747 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3749 /* Automatic Update flag */
3750 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3752 // ----- create actions --------------
3754 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3755 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3756 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3757 //createSMESHAction( 114, "NUM" );
3758 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3760 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3762 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3763 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3764 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3765 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3766 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3767 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3769 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3771 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3772 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3773 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3774 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3775 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3776 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3778 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3780 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3781 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3782 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3783 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3784 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3785 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3786 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3787 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3788 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3789 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3790 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3791 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3792 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_COMPUTE" );
3793 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_COMPUTE" );
3794 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3795 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3796 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3797 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3798 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3799 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3800 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3801 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3802 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3803 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3804 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3805 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3806 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3807 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3808 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3809 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3811 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3812 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3813 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3814 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3815 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3816 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3817 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3818 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3819 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3820 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3821 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3822 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3823 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3824 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3825 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3826 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3827 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3828 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3829 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3830 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3831 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3832 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3833 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3834 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3835 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3836 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3837 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3839 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3840 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3841 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3842 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3843 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3844 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3845 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3846 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3847 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3848 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3849 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3850 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3851 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3852 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3853 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3854 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3855 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3856 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3857 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3858 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3859 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3860 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3861 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3862 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3864 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3865 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3866 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3867 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3869 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3870 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3872 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3873 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3874 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3875 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3876 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3877 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3878 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3879 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3880 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3881 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3882 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3883 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3884 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3885 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3886 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3887 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3888 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3889 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3890 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3891 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3892 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3893 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3894 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3896 createSMESHAction( SMESHOp::OpReset, "RESET" );
3897 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3898 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3899 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3900 #ifndef DISABLE_PLOT2DVIEWER
3901 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3903 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3904 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3905 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3906 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3907 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3908 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3909 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3910 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3911 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3912 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3913 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
3914 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
3915 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3917 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3918 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3920 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3921 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3922 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3923 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3924 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3925 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3926 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3927 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3928 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3930 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3931 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3932 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3933 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3934 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
3936 createSMESHAction( SMESHOp::OpHide, "HIDE" );
3937 createSMESHAction( SMESHOp::OpShow, "SHOW" );
3938 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
3940 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
3942 QList<int> aCtrlActions;
3943 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode // node controls
3944 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
3945 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
3946 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
3947 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
3948 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
3949 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
3950 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
3951 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
3952 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
3953 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
3954 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
3955 aCtrlGroup->setExclusive( true );
3956 for( int i = 0; i < aCtrlActions.size(); i++ )
3957 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
3959 // ----- create menu --------------
3960 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3961 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3962 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3963 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3964 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3965 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3966 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3967 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3969 createMenu( separator(), fileId );
3971 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3972 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3973 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3974 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3975 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3976 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3977 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3978 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3979 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3980 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
3981 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
3983 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
3984 createMenu( SMESHOp::OpImportUNV, importId, -1 );
3985 createMenu( SMESHOp::OpImportMED, importId, -1 );
3986 createMenu( SMESHOp::OpImportSTL, importId, -1 );
3988 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
3990 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
3991 createMenu( SMESHOp::OpImportGMF, importId, -1 );
3992 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
3993 createMenu( SMESHOp::OpExportMED, exportId, -1 );
3994 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
3995 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
3997 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
3999 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4000 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4001 createMenu( separator(), fileId, 10 );
4003 createMenu( SMESHOp::OpDelete, editId, -1 );
4005 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4007 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4008 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4009 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4010 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4011 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4012 createMenu( separator(), meshId, -1 );
4013 createMenu( SMESHOp::OpCompute, meshId, -1 );
4014 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4015 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4016 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4017 createMenu( separator(), meshId, -1 );
4018 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4019 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4020 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4021 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4022 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4023 createMenu( separator(), meshId, -1 );
4024 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4025 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4026 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4027 createMenu( separator(), meshId, -1 );
4028 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4029 createMenu( separator(), meshId, -1 );
4030 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4031 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4032 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4033 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4034 createMenu( separator(), meshId, -1 );
4036 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4037 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4038 createMenu( SMESHOp::OpFreeEdge, edgeId, -1 );
4039 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4040 createMenu( SMESHOp::OpLength, edgeId, -1 );
4041 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4042 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4043 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4044 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4045 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4046 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4047 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4048 createMenu( SMESHOp::OpArea, faceId, -1 );
4049 createMenu( SMESHOp::OpTaper, faceId, -1 );
4050 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4051 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4052 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4053 createMenu( SMESHOp::OpSkew, faceId, -1 );
4054 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4055 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4056 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4057 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4058 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4059 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4060 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4061 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4062 createMenu( separator(), ctrlId, -1 );
4063 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4064 createMenu( separator(), ctrlId, -1 );
4065 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4067 createMenu( SMESHOp::OpNode, addId, -1 );
4068 createMenu( SMESHOp::OpElem0D, addId, -1 );
4069 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4070 createMenu( SMESHOp::OpBall, addId, -1 );
4071 createMenu( SMESHOp::OpEdge, addId, -1 );
4072 createMenu( SMESHOp::OpTriangle, addId, -1 );
4073 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4074 createMenu( SMESHOp::OpPolygon, addId, -1 );
4075 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4076 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4077 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4078 createMenu( SMESHOp::OpPyramid, addId, -1 );
4079 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4080 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4081 createMenu( separator(), addId, -1 );
4082 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4083 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4084 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4085 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4086 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4087 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4088 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4089 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4090 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4091 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4093 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4094 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4095 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4096 createMenu( separator(), removeId, -1 );
4097 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4098 createMenu( separator(), removeId, -1 );
4099 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4101 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4102 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4104 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4105 createMenu( SMESHOp::OpRotation, transfId, -1 );
4106 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4107 createMenu( SMESHOp::OpScale, transfId, -1 );
4108 createMenu( SMESHOp::OpSewing, transfId, -1 );
4109 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4110 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4111 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4113 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4114 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4115 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4116 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4117 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4118 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4119 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4120 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4121 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4122 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4123 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4124 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4125 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4126 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4127 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4129 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4130 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4131 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4132 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4133 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4134 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4136 // ----- create toolbars --------------
4137 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4138 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4139 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4140 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4141 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4142 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4143 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4144 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4145 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4146 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4147 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4148 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4149 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4150 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4151 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4153 createTool( SMESHOp::OpCreateMesh, meshTb );
4154 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4155 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4156 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4157 createTool( SMESHOp::OpCopyMesh, meshTb );
4158 createTool( separator(), meshTb );
4159 createTool( SMESHOp::OpCompute, meshTb );
4160 createTool( SMESHOp::OpPreCompute, meshTb );
4161 createTool( SMESHOp::OpEvaluate, meshTb );
4162 createTool( SMESHOp::OpMeshOrder, meshTb );
4164 createTool( SMESHOp::OpCreateGroup, groupTb );
4165 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4166 createTool( SMESHOp::OpConstructGroup, groupTb );
4167 createTool( SMESHOp::OpEditGroup, groupTb );
4169 createTool( SMESHOp::OpMeshInformation, info );
4170 //createTool( SMESHOp::OpStdInfo, meshTb );
4171 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4172 createTool( SMESHOp::OpFindElementByPoint, info );
4174 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4175 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4177 createTool( SMESHOp::OpFreeEdge, ctrl1dTb );
4178 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4179 createTool( SMESHOp::OpLength, ctrl1dTb );
4180 createTool( SMESHOp::OpConnection, ctrl1dTb );
4181 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4183 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4184 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4185 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4186 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4187 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4188 createTool( SMESHOp::OpArea, ctrl2dTb );
4189 createTool( SMESHOp::OpTaper, ctrl2dTb );
4190 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4191 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4192 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4193 createTool( SMESHOp::OpSkew, ctrl2dTb );
4194 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4195 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4197 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4198 createTool( SMESHOp::OpVolume, ctrl3dTb );
4199 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4200 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4201 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4202 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4204 createTool( SMESHOp::OpNode, addElemTb );
4205 createTool( SMESHOp::OpElem0D, addElemTb );
4206 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4207 createTool( SMESHOp::OpBall, addElemTb );
4208 createTool( SMESHOp::OpEdge, addElemTb );
4209 createTool( SMESHOp::OpTriangle, addElemTb );
4210 createTool( SMESHOp::OpQuadrangle, addElemTb );
4211 createTool( SMESHOp::OpPolygon, addElemTb );
4212 createTool( SMESHOp::OpTetrahedron, addElemTb );
4213 createTool( SMESHOp::OpHexahedron, addElemTb );
4214 createTool( SMESHOp::OpPentahedron, addElemTb );
4215 createTool( SMESHOp::OpPyramid, addElemTb );
4216 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4217 createTool( SMESHOp::OpPolyhedron, addElemTb );
4219 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4220 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4221 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4222 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4223 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4224 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4225 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4226 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4227 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4228 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4230 createTool( SMESHOp::OpRemoveNodes, remTb );
4231 createTool( SMESHOp::OpRemoveElements, remTb );
4232 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4233 createTool( SMESHOp::OpClearMesh, remTb );
4235 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4236 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4238 createTool( SMESHOp::OpTranslation, transformTb );
4239 createTool( SMESHOp::OpRotation, transformTb );
4240 createTool( SMESHOp::OpSymmetry, transformTb );
4241 createTool( SMESHOp::OpScale, transformTb );
4242 createTool( SMESHOp::OpSewing, transformTb );
4243 createTool( SMESHOp::OpMergeNodes, transformTb );
4244 createTool( SMESHOp::OpMergeElements, transformTb );
4245 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4247 createTool( SMESHOp::OpMoveNode, modifyTb );
4248 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4249 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4250 createTool( SMESHOp::OpOrientation, modifyTb );
4251 createTool( SMESHOp::OpReorientFaces, modifyTb );
4252 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4253 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4254 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4255 createTool( SMESHOp::OpSmoothing, modifyTb );
4256 createTool( SMESHOp::OpExtrusion, modifyTb );
4257 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4258 createTool( SMESHOp::OpRevolution, modifyTb );
4259 createTool( SMESHOp::OpPatternMapping, modifyTb );
4260 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4261 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4263 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4265 createTool( SMESHOp::OpUpdate, dispModeTb );
4267 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4268 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4271 QString OB = "'ObjectBrowser'",
4272 View = "'" + SVTK_Viewer::Type() + "'",
4274 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4275 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4276 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4277 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4278 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4279 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4280 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4281 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4282 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4283 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4284 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4286 mesh_part = mesh + " " + subMesh + " " + group,
4287 mesh_group = mesh + " " + group,
4288 hyp_alg = hypo + " " + algo;
4290 // popup for object browser
4292 isInvisible("not( isVisible )"),
4293 isEmpty("numberOfNodes = 0"),
4294 isNotEmpty("numberOfNodes <> 0"),
4296 // has nodes, edges, etc in VISIBLE! actor
4297 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4298 hasElems("(count( elemTypes ) > 0)"),
4299 hasDifferentElems("(count( elemTypes ) > 1)"),
4300 hasBalls("({'BallElem'} in elemTypes)"),
4301 hasElems0d("({'Elem0d'} in elemTypes)"),
4302 hasEdges("({'Edge'} in elemTypes)"),
4303 hasFaces("({'Face'} in elemTypes)"),
4304 hasVolumes("({'Volume'} in elemTypes)");
4306 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4307 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& isComputable");
4308 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, mesh, "&& isComputable");
4309 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, subMesh, "&& isComputable" );
4310 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4311 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4313 popupMgr()->insert( separator(), -1, 0 );
4314 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& isComputable" );
4315 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& isComputable && isPreComputable" );
4316 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& isComputable" );
4317 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& isComputable" );
4318 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4319 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4320 createPopupItem( SMESHOp::OpFindElementByPoint, OB, mesh_group );
4321 createPopupItem( SMESHOp::OpOverallMeshQuality, OB, mesh_part );
4322 popupMgr()->insert( separator(), -1, 0 );
4323 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh );
4324 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh );
4325 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4326 popupMgr()->insert( separator(), -1, 0 );
4327 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo);
4328 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4329 popupMgr()->insert( separator(), -1, 0 );
4330 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4331 popupMgr()->insert( separator(), -1, 0 );
4332 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh + " " + subMesh ); // convert to quadratic
4333 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh + " " + group, // create 2D mesh from 3D
4335 popupMgr()->insert( separator(), -1, 0 );
4337 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4338 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4339 QString only_one_2D = only_one_non_empty + " && dim>1";
4341 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4342 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4343 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4344 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4346 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4348 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, multiple_non_empty, anId );
4349 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, multiple_non_empty, anId );
4350 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, multiple_non_empty, anId );
4351 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4352 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4353 popupMgr()->insert( separator(), -1, 0 );
4356 createPopupItem( SMESHOp::OpEditGroup, View, group );
4357 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4358 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4360 popupMgr()->insert( separator(), -1, 0 );
4361 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4362 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4363 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4364 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4365 popupMgr()->insert( separator(), -1, 0 );
4367 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4368 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4369 popupMgr()->insert( separator(), -1, 0 );
4371 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4372 QString aType = QString( "%1type in {%2}" ).arg( lc );
4373 aType = aType.arg( mesh_part );
4374 QString aMeshInVTK = aClient + "&&" + aType;
4376 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4377 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4378 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4380 //-------------------------------------------------
4382 //-------------------------------------------------
4383 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4385 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4386 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4387 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4389 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4390 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4391 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4393 popupMgr()->insert( separator(), -1, -1 );
4395 //-------------------------------------------------
4397 //-------------------------------------------------
4398 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4400 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4401 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4402 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4404 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4405 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4406 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4408 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4409 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4410 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4412 popupMgr()->insert( separator(), anId, -1 );
4414 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4415 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4416 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4418 //-------------------------------------------------
4420 //-------------------------------------------------
4421 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4423 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4425 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4426 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4427 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4429 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4430 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4431 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4433 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4434 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4435 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4437 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4438 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4439 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4441 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4442 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4443 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4445 popupMgr()->insert( separator(), anId, -1 );
4447 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4448 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4450 popupMgr()->insert( separator(), anId, -1 );
4452 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4453 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4456 //-------------------------------------------------
4457 // Representation of the 2D Quadratic elements
4458 //-------------------------------------------------
4459 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4460 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4461 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4462 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4464 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4465 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4466 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4468 //-------------------------------------------------
4469 // Orientation of faces
4470 //-------------------------------------------------
4471 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4472 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4473 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4475 //-------------------------------------------------
4477 //-------------------------------------------------
4478 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4479 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4481 //-------------------------------------------------
4483 //-------------------------------------------------
4484 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4485 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4487 //-------------------------------------------------
4489 //-------------------------------------------------
4491 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4492 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4493 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4494 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4496 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4498 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4499 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4501 popupMgr()->insert( separator(), anId, -1 );
4503 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4505 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4506 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4507 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4509 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4510 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4511 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4513 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4515 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4516 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4517 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4519 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4520 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4521 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4523 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4524 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4525 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4527 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4528 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4529 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4530 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4531 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4532 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4534 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4536 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4537 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4538 QtxPopupMgr::VisibleRule );
4539 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4541 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4542 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4543 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4545 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4546 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4547 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4549 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4550 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4551 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4553 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4554 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4555 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4557 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4558 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4559 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4561 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4562 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4563 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4565 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4566 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4567 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4569 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4570 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4571 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4573 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4574 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4575 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4577 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4578 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4579 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4581 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4582 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4583 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4584 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4585 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4586 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4588 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4590 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4591 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4592 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4594 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4595 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4596 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4598 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4599 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4600 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4602 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4603 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4604 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4606 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4607 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4608 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4610 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4611 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4612 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4614 popupMgr()->insert( separator(), anId, -1 );
4616 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4617 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4619 popupMgr()->insert( separator(), anId, -1 );
4621 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4623 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4624 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4626 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4627 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4628 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4630 #ifndef DISABLE_PLOT2DVIEWER
4631 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4632 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4635 //-------------------------------------------------
4637 //-------------------------------------------------
4638 popupMgr()->insert( separator(), -1, -1 );
4639 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4640 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4641 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4642 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4644 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4645 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4647 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4648 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4650 popupMgr()->insert( separator(), -1, -1 );
4652 //-------------------------------------------------
4654 //-------------------------------------------------
4655 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4656 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4658 popupMgr()->insert( separator(), -1, -1 );
4660 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4661 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4662 popupMgr()->insert( separator(), -1, -1 );
4664 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4665 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4667 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4668 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4671 //================================================================================
4673 * \brief Return true if SMESH or GEOM objects are selected.
4674 * Is called form LightApp_Module::activateModule() which clear selection if
4675 * not isSelectionCompatible()
4677 //================================================================================
4679 bool SMESHGUI::isSelectionCompatible()
4681 bool isCompatible = true;
4682 SALOME_ListIO selected;
4683 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4684 Sel->selectedObjects( selected );
4686 SALOME_ListIteratorOfListIO It( selected );
4687 for ( ; isCompatible && It.More(); It.Next())
4689 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4690 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4692 return isCompatible;
4696 bool SMESHGUI::reusableOperation( const int id )
4698 // compute, evaluate and precompute are not reusable operations
4699 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4702 bool SMESHGUI::activateModule( SUIT_Study* study )
4704 bool res = SalomeApp_Module::activateModule( study );
4706 setMenuShown( true );
4707 setToolShown( true );
4709 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4710 PyGILState_STATE gstate = PyGILState_Ensure();
4711 PyObjWrapper pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4712 if ( !pluginsmanager ) {
4716 PyObjWrapper result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4720 PyGILState_Release(gstate);
4721 // end of SMESH plugins loading
4723 // Reset actions accelerator keys
4724 //action(SMESHOp::OpImportDAT)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B));
4725 action(SMESHOp::OpImportUNV)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U));
4726 action(SMESHOp::OpImportMED)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M));
4728 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4730 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4731 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4732 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4733 if ( _PTR(Study) aStudy = s->studyDS()) {
4734 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4735 updateObjBrowser(); // objects can be removed
4738 // get all view currently opened in the study and connect their signals to
4739 // the corresponding slots of the class.
4740 SUIT_Desktop* aDesk = study->application()->desktop();
4742 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4743 SUIT_ViewWindow* wnd;
4744 foreach ( wnd, wndList )
4751 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4753 setMenuShown( false );
4754 setToolShown( false );
4756 EmitSignalCloseAllDialogs();
4758 // Unset actions accelerator keys
4759 //action(SMESHOp::OpImportDAT)->setShortcut(QKeySequence());
4760 action(SMESHOp::OpImportUNV)->setShortcut(QKeySequence());
4761 action(SMESHOp::OpImportMED)->setShortcut(QKeySequence());
4763 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4765 return SalomeApp_Module::deactivateModule( study );
4768 void SMESHGUI::studyClosed( SUIT_Study* s )
4772 SMESH::RemoveVisuData( s->id() );
4773 SalomeApp_Module::studyClosed( s );
4776 void SMESHGUI::OnGUIEvent()
4778 const QObject* obj = sender();
4779 if ( !obj || !obj->inherits( "QAction" ) )
4781 int id = actionId((QAction*)obj);
4786 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4788 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4789 if ( CORBA::is_nil( myComponentSMESH ) )
4791 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4793 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4794 return aGUI.myComponentSMESH;
4797 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4798 return myComponentSMESH;
4801 QString SMESHGUI::engineIOR() const
4803 CORBA::ORB_var anORB = getApp()->orb();
4804 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4805 return QString( anIOR.in() );
4808 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4810 SalomeApp_Module::contextMenuPopup( client, menu, title );
4812 selectionMgr()->selectedObjects( lst );
4813 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4814 Handle(SALOME_InteractiveObject) io = lst.First();
4815 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4816 _PTR(Study) study = appStudy->studyDS();
4817 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4819 QString aName = QString( QString::fromUtf8(obj->GetName().c_str()) );
4820 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4821 aName.remove( (aName.length() - 1), 1 );
4827 LightApp_Selection* SMESHGUI::createSelection() const
4829 return new SMESHGUI_Selection();
4832 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4834 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4835 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4836 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4839 void SMESHGUI::viewManagers( QStringList& list ) const
4841 list.append( SVTK_Viewer::Type() );
4844 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4846 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4847 SMESH::UpdateSelectionProp( this );
4849 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4850 for(int i = 0; i < aViews.count() ; i++){
4851 SUIT_ViewWindow *sf = aViews[i];
4857 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4859 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4860 myClippingPlaneInfoMap.erase( theViewManager );
4863 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4865 theActor->AddObserver( SMESH::DeleteActorEvent,
4866 myEventCallbackCommand.GetPointer(),
4870 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4871 unsigned long theEvent,
4872 void* theClientData,
4875 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4876 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4877 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4878 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4879 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4880 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4881 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4882 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4883 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4884 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4885 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4886 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4887 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4888 if( anActor == *anIter3 ) {
4889 anActorList.erase( anIter3 );
4900 void SMESHGUI::createPreferences()
4902 // General tab ------------------------------------------------------------------------
4903 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4905 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4906 setPreferenceProperty( autoUpdate, "columns", 2 );
4907 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4908 setPreferenceProperty( lim, "min", 0 );
4909 setPreferenceProperty( lim, "max", 100000000 );
4910 setPreferenceProperty( lim, "step", 1000 );
4911 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4912 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4914 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4915 setPreferenceProperty( qaGroup, "columns", 2 );
4916 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4917 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4918 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4919 setPreferenceProperty( prec, "min", 0 );
4920 setPreferenceProperty( prec, "max", 100 );
4921 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4922 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4923 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4924 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4925 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4927 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4928 setPreferenceProperty( dispgroup, "columns", 2 );
4929 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4931 modes.append( tr("MEN_WIRE") );
4932 modes.append( tr("MEN_SHADE") );
4933 modes.append( tr("MEN_NODES") );
4934 modes.append( tr("MEN_SHRINK") );
4935 QList<QVariant> indices;
4936 indices.append( 0 );
4937 indices.append( 1 );
4938 indices.append( 2 );
4939 indices.append( 3 );
4940 setPreferenceProperty( dispmode, "strings", modes );
4941 setPreferenceProperty( dispmode, "indexes", indices );
4943 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4944 setPreferenceProperty( arcgroup, "columns", 2 );
4945 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4946 QStringList quadraticModes;
4947 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4948 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4950 indices.append( 0 );
4951 indices.append( 1 );
4952 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4953 setPreferenceProperty( quadraticmode, "indexes", indices );
4955 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4956 "SMESH", "max_angle" );
4957 setPreferenceProperty( maxAngle, "min", 1 );
4958 setPreferenceProperty( maxAngle, "max", 90 );
4962 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4963 setPreferenceProperty( exportgroup, "columns", 2 );
4964 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4965 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4967 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4968 setPreferenceProperty( computeGroup, "columns", 2 );
4969 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4971 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4972 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4973 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4975 indices.append( 0 );
4976 indices.append( 1 );
4977 indices.append( 2 );
4978 setPreferenceProperty( notifyMode, "strings", modes );
4979 setPreferenceProperty( notifyMode, "indexes", indices );
4981 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4982 setPreferenceProperty( infoGroup, "columns", 2 );
4983 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4985 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4986 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4988 indices.append( 0 );
4989 indices.append( 1 );
4990 setPreferenceProperty( elemInfo, "strings", modes );
4991 setPreferenceProperty( elemInfo, "indexes", indices );
4992 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4993 setPreferenceProperty( nodesLim, "min", 0 );
4994 setPreferenceProperty( nodesLim, "max", 10000000 );
4995 setPreferenceProperty( nodesLim, "step", 10000 );
4996 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4997 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
4998 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4999 setPreferenceProperty( ctrlLim, "min", 0 );
5000 setPreferenceProperty( ctrlLim, "max", 10000000 );
5001 setPreferenceProperty( ctrlLim, "step", 1000 );
5002 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5003 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5004 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5005 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5006 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5008 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5009 setPreferenceProperty( segGroup, "columns", 2 );
5010 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5011 "SMESH", "segmentation" );
5012 setPreferenceProperty( segLen, "min", 1 );
5013 setPreferenceProperty( segLen, "max", 10000000 );
5014 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5015 "SMESH", "nb_segments_per_edge" );
5016 setPreferenceProperty( nbSeg, "min", 1 );
5017 setPreferenceProperty( nbSeg, "max", 10000000 );
5019 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5020 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5021 "SMESH", "forget_mesh_on_hyp_modif" );
5024 // Quantities with individual precision settings
5025 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5026 setPreferenceProperty( precGroup, "columns", 2 );
5028 const int nbQuantities = 6;
5029 int precs[nbQuantities], ii = 0;
5030 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5031 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5032 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5033 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5034 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5035 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5036 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5037 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5038 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5039 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5040 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5041 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5043 // Set property for precision value for spinboxes
5044 for ( ii = 0; ii < nbQuantities; ii++ ){
5045 setPreferenceProperty( precs[ii], "min", -14 );
5046 setPreferenceProperty( precs[ii], "max", 14 );
5047 setPreferenceProperty( precs[ii], "precision", 2 );
5050 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5051 setPreferenceProperty( previewGroup, "columns", 2 );
5052 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5053 setPreferenceProperty( chunkSize, "min", 1 );
5054 setPreferenceProperty( chunkSize, "max", 1000 );
5055 setPreferenceProperty( chunkSize, "step", 50 );
5057 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5058 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5060 // Mesh tab ------------------------------------------------------------------------
5061 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5062 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5063 setPreferenceProperty( nodeGroup, "columns", 3 );
5065 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5067 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5069 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5070 QList<QVariant> aMarkerTypeIndicesList;
5071 QList<QVariant> aMarkerTypeIconsList;
5072 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5073 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5074 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5075 aMarkerTypeIndicesList << i;
5076 aMarkerTypeIconsList << pixmap;
5078 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5079 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5081 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5083 QList<QVariant> aMarkerScaleIndicesList;
5084 QStringList aMarkerScaleValuesList;
5085 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5086 aMarkerScaleIndicesList << i;
5087 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5089 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5090 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5092 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5093 //setPreferenceProperty( elemGroup, "columns", 2 );
5095 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5096 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5097 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5098 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5099 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5100 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5101 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5102 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5103 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5106 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5107 setPreferenceProperty( grpGroup, "columns", 2 );
5109 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5110 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5112 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5113 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5114 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5115 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
5116 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5117 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5118 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5119 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5120 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5121 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5122 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5123 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5125 setPreferenceProperty( size0d, "min", 1 );
5126 setPreferenceProperty( size0d, "max", 10 );
5128 setPreferenceProperty( ballSize, "min", 1 );
5129 setPreferenceProperty( ballSize, "max", 10 );
5131 setPreferenceProperty( ballScale, "min", 1e-2 );
5132 setPreferenceProperty( ballScale, "max", 1e7 );
5133 setPreferenceProperty( ballScale, "step", 0.5 );
5135 setPreferenceProperty( elemW, "min", 1 );
5136 setPreferenceProperty( elemW, "max", 5 );
5138 setPreferenceProperty( outW, "min", 1 );
5139 setPreferenceProperty( outW, "max", 5 );
5141 setPreferenceProperty( shrink, "min", 0 );
5142 setPreferenceProperty( shrink, "max", 100 );
5144 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5145 setPreferenceProperty( numGroup, "columns", 2 );
5147 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5148 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5150 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5151 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5153 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5154 setPreferenceProperty( orientGroup, "columns", 1 );
5156 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5157 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5159 setPreferenceProperty( orientScale, "min", 0.05 );
5160 setPreferenceProperty( orientScale, "max", 0.5 );
5161 setPreferenceProperty( orientScale, "step", 0.05 );
5163 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5165 // Selection tab ------------------------------------------------------------------------
5166 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5168 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5169 setPreferenceProperty( selGroup, "columns", 2 );
5171 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5172 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5174 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5175 setPreferenceProperty( preGroup, "columns", 2 );
5177 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5179 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5180 setPreferenceProperty( precSelGroup, "columns", 2 );
5182 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5183 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5184 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5186 // Scalar Bar tab ------------------------------------------------------------------------
5187 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5188 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5189 setPreferenceProperty( fontGr, "columns", 2 );
5191 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5192 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5194 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5195 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5197 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5198 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5200 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5201 setPreferenceProperty( numcol, "min", 2 );
5202 setPreferenceProperty( numcol, "max", 256 );
5204 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5205 setPreferenceProperty( numlab, "min", 2 );
5206 setPreferenceProperty( numlab, "max", 65 );
5208 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5209 setPreferenceProperty( orientGr, "columns", 2 );
5210 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5211 QStringList orients;
5212 orients.append( tr( "SMESH_VERTICAL" ) );
5213 orients.append( tr( "SMESH_HORIZONTAL" ) );
5214 indices.clear(); indices.append( 0 ); indices.append( 1 );
5215 setPreferenceProperty( orient, "strings", orients );
5216 setPreferenceProperty( orient, "indexes", indices );
5218 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5219 setPreferenceProperty( posVSizeGr, "columns", 2 );
5220 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5221 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5222 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5223 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5224 setPreferenceProperty( xv, "step", 0.1 );
5225 setPreferenceProperty( xv, "min", 0.0 );
5226 setPreferenceProperty( xv, "max", 1.0 );
5227 setPreferenceProperty( yv, "step", 0.1 );
5228 setPreferenceProperty( yv, "min", 0.0 );
5229 setPreferenceProperty( yv, "max", 1.0 );
5230 setPreferenceProperty( wv, "step", 0.1 );
5231 setPreferenceProperty( wv, "min", 0.0 );
5232 setPreferenceProperty( wv, "max", 1.0 );
5233 setPreferenceProperty( hv, "min", 0.0 );
5234 setPreferenceProperty( hv, "max", 1.0 );
5235 setPreferenceProperty( hv, "step", 0.1 );
5237 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5238 setPreferenceProperty( posHSizeGr, "columns", 2 );
5239 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5240 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5241 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5242 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5243 setPreferenceProperty( xv, "min", 0.0 );
5244 setPreferenceProperty( xv, "max", 1.0 );
5245 setPreferenceProperty( xv, "step", 0.1 );
5246 setPreferenceProperty( xh, "min", 0.0 );
5247 setPreferenceProperty( xh, "max", 1.0 );
5248 setPreferenceProperty( xh, "step", 0.1 );
5249 setPreferenceProperty( yh, "min", 0.0 );
5250 setPreferenceProperty( yh, "max", 1.0 );
5251 setPreferenceProperty( yh, "step", 0.1 );
5252 setPreferenceProperty( wh, "min", 0.0 );
5253 setPreferenceProperty( wh, "max", 1.0 );
5254 setPreferenceProperty( wh, "step", 0.1 );
5255 setPreferenceProperty( hh, "min", 0.0 );
5256 setPreferenceProperty( hh, "max", 1.0 );
5257 setPreferenceProperty( hh, "step", 0.1 );
5259 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5260 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5261 setPreferenceProperty( distributionGr, "columns", 3 );
5263 types.append( tr( "SMESH_MONOCOLOR" ) );
5264 types.append( tr( "SMESH_MULTICOLOR" ) );
5265 indices.clear(); indices.append( 0 ); indices.append( 1 );
5266 setPreferenceProperty( coloringType, "strings", types );
5267 setPreferenceProperty( coloringType, "indexes", indices );
5268 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5272 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5274 if( sect=="SMESH" ) {
5275 float sbX1,sbY1,sbW,sbH;
5276 float aTol = 1.00000009999999;
5277 std::string aWarning;
5278 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5279 if( name=="selection_object_color" || name=="selection_element_color" ||
5280 name=="highlight_color" ||
5281 name=="selection_precision_node" || name=="selection_precision_element" ||
5282 name=="selection_precision_object")
5283 SMESH::UpdateSelectionProp( this );
5284 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5285 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5286 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5287 if(sbX1+sbW > aTol){
5288 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5291 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5292 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5295 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5296 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5297 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5298 if(sbY1+sbH > aTol){
5299 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5300 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5301 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5304 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5305 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5306 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5307 if(sbX1+sbW > aTol){
5308 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5311 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5312 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5315 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5316 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5317 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5318 if(sbY1+sbH > aTol){
5319 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5322 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5323 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5326 else if ( name == "segmentation" ) {
5327 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5328 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5330 else if ( name == "nb_segments_per_edge" ) {
5331 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5332 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5334 else if ( name == "historical_python_dump" ||
5335 name == "forget_mesh_on_hyp_modif") {
5336 QString val = aResourceMgr->stringValue( "SMESH", name );
5337 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5339 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5340 SMESH::UpdateFontProp( this );
5342 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5343 SMESH::UpdateFontProp( this );
5346 if(aWarning.size() != 0){
5347 aWarning += "The default values are applied instead.";
5348 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5349 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5350 QObject::tr(aWarning.c_str()));
5355 //================================================================================
5357 * \brief Update something in accordance with update flags
5358 * \param theFlags - update flags
5360 * Update viewer or/and object browser etc. in accordance with update flags ( see
5361 * LightApp_UpdateFlags enumeration ).
5363 //================================================================================
5364 void SMESHGUI::update( const int flags )
5366 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5367 SMESH::UpdateView();
5369 SalomeApp_Module::update( flags );
5372 //================================================================================
5374 * \brief Set default selection mode
5376 * SLOT called when operation commited. Sets default selection mode
5378 //================================================================================
5379 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5381 SVTK_ViewWindow* vtkWnd =
5382 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5384 vtkWnd->SetSelectionMode( ActorSelection );
5387 //================================================================================
5389 * \brief Set default selection mode
5391 * SLOT called when operation aborted. Sets default selection mode
5393 //================================================================================
5394 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5396 SVTK_ViewWindow* vtkWnd =
5397 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5399 vtkWnd->SetSelectionMode( ActorSelection );
5402 //================================================================================
5404 * \brief Creates operation with given identifier
5405 * \param id - identifier of operation to be started
5406 * \return Pointer on created operation or NULL if operation is not created
5408 * Virtual method redefined from the base class creates operation with given id.
5409 * It is called called automatically from startOperation method of base class.
5411 //================================================================================
5412 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5414 LightApp_Operation* op = 0;
5415 // to do : create operation here
5418 case SMESHOp::OpConvertMeshToQuadratic:
5419 op = new SMESHGUI_ConvToQuadOp();
5421 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5422 op = new SMESHGUI_Make2DFrom3DOp();
5424 case SMESHOp::OpReorientFaces:
5425 op = new SMESHGUI_ReorientFacesOp();
5427 case SMESHOp::OpCreateMesh:
5428 op = new SMESHGUI_MeshOp( true, true );
5430 case SMESHOp::OpCreateSubMesh:
5431 op = new SMESHGUI_MeshOp( true, false );
5433 case SMESHOp::OpEditMeshOrSubMesh:
5434 op = new SMESHGUI_MeshOp( false );
5436 case SMESHOp::OpCompute:
5437 op = new SMESHGUI_ComputeOp();
5439 case SMESHOp::OpPreCompute:
5440 op = new SMESHGUI_PrecomputeOp();
5442 case SMESHOp::OpEvaluate:
5443 op = new SMESHGUI_EvaluateOp();
5445 case SMESHOp::OpMeshOrder:
5446 op = new SMESHGUI_MeshOrderOp();
5448 case SMESHOp::OpCreateGeometryGroup:
5449 op = new SMESHGUI_GroupOnShapeOp();
5451 case SMESHOp::OpFindElementByPoint:
5452 op = new SMESHGUI_FindElemByPointOp();
5454 case SMESHOp::OpMoveNode: // Make mesh pass through point
5455 op = new SMESHGUI_MakeNodeAtPointOp();
5457 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5458 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5465 op = SalomeApp_Module::createOperation( id );
5469 //================================================================================
5471 * \brief Stops current operations and starts a given one
5472 * \param id - The id of the operation to start
5474 //================================================================================
5476 void SMESHGUI::switchToOperation(int id)
5478 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5479 activeStudy()->abortAllOperations();
5480 startOperation( id );
5483 LightApp_Displayer* SMESHGUI::displayer()
5486 myDisplayer = new SMESHGUI_Displayer( getApp() );
5490 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5493 int aTolerance = 64;
5494 int anIterations = 0;
5500 if( anIterations % aPeriod == 0 )
5503 if( aTolerance < 1 )
5507 aHue = (int)( 360.0 * rand() / RAND_MAX );
5510 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5511 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5512 for( ; it != itEnd; ++it )
5514 SALOMEDS::Color anAutoColor = *it;
5515 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5518 aQColor.getHsv( &h, &s, &v );
5519 if( abs( h - aHue ) < aTolerance )
5531 aColor.setHsv( aHue, 255, 255 );
5533 SALOMEDS::Color aSColor;
5534 aSColor.R = aColor.redF();
5535 aSColor.G = aColor.greenF();
5536 aSColor.B = aColor.blueF();
5541 const char* gSeparator = "_"; // character used to separate parameter names
5542 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5543 const char* gPathSep = "|"; // character used to separate paths
5546 * \brief Store visual parameters
5548 * This method is called just before the study document is saved.
5549 * Store visual parameters in AttributeParameter attribue(s)
5551 void SMESHGUI::storeVisualParameters (int savePoint)
5554 Kernel_Utils::Localizer loc;
5556 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5557 if (!appStudy || !appStudy->studyDS())
5559 _PTR(Study) studyDS = appStudy->studyDS();
5561 // componentName is used for encoding of entries when storing them in IParameters
5562 std::string componentName = myComponentSMESH->ComponentDataType();
5563 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5564 //if (!aSComponent) return;
5567 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5568 componentName.c_str(),
5570 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5572 // store map of custom markers
5573 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5574 if( !aMarkerMap.empty() )
5576 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5577 for( ; anIter != aMarkerMap.end(); anIter++ )
5579 int anId = anIter->first;
5580 VTK::MarkerData aMarkerData = anIter->second;
5581 std::string aMarkerFileName = aMarkerData.first;
5582 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5583 if( aMarkerTexture.size() < 3 )
5584 continue; // should contain at least width, height and the first value
5586 QString aPropertyName( "texture" );
5587 aPropertyName += gSeparator;
5588 aPropertyName += QString::number( anId );
5590 QString aPropertyValue = aMarkerFileName.c_str();
5591 aPropertyValue += gPathSep;
5593 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5594 ushort aWidth = *aTextureIter++;
5595 ushort aHeight = *aTextureIter++;
5596 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5597 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5598 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5599 aPropertyValue += QString::number( *aTextureIter );
5601 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5605 // viewers counters are used for storing view_numbers in IParameters
5608 // main cycle to store parameters of displayed objects
5609 QList<SUIT_ViewManager*> lst;
5610 QList<SUIT_ViewManager*>::Iterator it;
5611 getApp()->viewManagers(lst);
5612 for (it = lst.begin(); it != lst.end(); it++)
5614 SUIT_ViewManager* vman = *it;
5615 QString vType = vman->getType();
5617 // saving VTK actors properties
5618 if (vType == SVTK_Viewer::Type())
5620 // store the clipping planes attached to the view manager
5621 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5622 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5623 if( anIter != myClippingPlaneInfoMap.end() )
5624 aClippingPlaneInfoList = anIter->second;
5626 if( !aClippingPlaneInfoList.empty() ) {
5627 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5628 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5630 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5631 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5633 QString aPropertyName( "ClippingPlane" );
5634 aPropertyName += gSeparator;
5635 aPropertyName += QString::number( vtkViewers );
5636 aPropertyName += gSeparator;
5637 aPropertyName += QString::number( anId );
5639 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5640 aPropertyValue += gDigitsSep;
5641 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5642 aPropertyValue += gDigitsSep;
5643 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5644 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5645 aPropertyValue += gDigitsSep;
5646 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5647 aPropertyValue += gDigitsSep;
5648 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5649 aPropertyValue += gDigitsSep;
5650 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5651 aPropertyValue += gDigitsSep;
5652 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5653 aPropertyValue += gDigitsSep;
5654 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5655 aPropertyValue += gDigitsSep;
5656 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5658 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5659 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5660 aPropertyValue += gDigitsSep;
5661 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5662 aPropertyValue += gDigitsSep;
5663 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5664 aPropertyValue += gDigitsSep;
5665 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5668 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5672 QVector<SUIT_ViewWindow*> views = vman->getViews();
5673 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5675 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5677 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5678 vtkActorCollection* allActors = aCopy.GetActors();
5679 allActors->InitTraversal();
5680 while (vtkActor* actor = allActors->GetNextActor())
5682 if (actor->GetVisibility()) // store only visible actors
5684 SMESH_Actor* aSmeshActor = 0;
5685 if (actor->IsA("SMESH_Actor"))
5686 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5687 if (aSmeshActor && aSmeshActor->hasIO())
5689 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5692 // entry is "encoded" = it does NOT contain component adress,
5693 // since it is a subject to change on next component loading
5694 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5696 std::string param, vtkParam = vType.toLatin1().data();
5697 vtkParam += gSeparator;
5698 vtkParam += QString::number(vtkViewers).toLatin1().data();
5699 vtkParam += gSeparator;
5702 param = vtkParam + "Visibility";
5703 ip->setParameter(entry, param, "On");
5706 param = vtkParam + "Representation";
5707 ip->setParameter(entry, param, QString::number
5708 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5711 param = vtkParam + "IsShrunk";
5712 ip->setParameter(entry, param, QString::number
5713 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5715 // Displayed entities
5716 unsigned int aMode = aSmeshActor->GetEntityMode();
5717 bool isE = aMode & SMESH_Actor::eEdges;
5718 bool isF = aMode & SMESH_Actor::eFaces;
5719 bool isV = aMode & SMESH_Actor::eVolumes;
5720 bool is0d = aMode & SMESH_Actor::e0DElements;
5721 bool isB = aMode & SMESH_Actor::eBallElem;
5723 QString modeStr ("e");
5724 modeStr += gDigitsSep; modeStr += QString::number(isE);
5725 modeStr += gDigitsSep; modeStr += "f";
5726 modeStr += gDigitsSep; modeStr += QString::number(isF);
5727 modeStr += gDigitsSep; modeStr += "v";
5728 modeStr += gDigitsSep; modeStr += QString::number(isV);
5729 modeStr += gDigitsSep; modeStr += "0d";
5730 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5731 modeStr += gDigitsSep; modeStr += "b";
5732 modeStr += gDigitsSep; modeStr += QString::number(isB);
5734 param = vtkParam + "Entities";
5735 ip->setParameter(entry, param, modeStr.toLatin1().data());
5741 aSmeshActor->GetSufaceColor(r, g, b, delta);
5742 QStringList colorStr;
5743 colorStr << "surface";
5744 colorStr << QString::number(r);
5745 colorStr << QString::number(g);
5746 colorStr << QString::number(b);
5748 colorStr << "backsurface";
5749 colorStr << QString::number(delta);
5751 aSmeshActor->GetVolumeColor(r, g, b, delta);
5752 colorStr << "volume";
5753 colorStr << QString::number(r);
5754 colorStr << QString::number(g);
5755 colorStr << QString::number(b);
5756 colorStr << QString::number(delta);
5758 aSmeshActor->GetEdgeColor(r, g, b);
5760 colorStr << QString::number(r);
5761 colorStr << QString::number(g);
5762 colorStr << QString::number(b);
5764 aSmeshActor->GetNodeColor(r, g, b);
5766 colorStr << QString::number(r);
5767 colorStr << QString::number(g);
5768 colorStr << QString::number(b);
5770 aSmeshActor->GetOutlineColor(r, g, b);
5771 colorStr << "outline";
5772 colorStr << QString::number(r);
5773 colorStr << QString::number(g);
5774 colorStr << QString::number(b);
5776 aSmeshActor->Get0DColor(r, g, b);
5777 colorStr << "elem0d";
5778 colorStr << QString::number(r);
5779 colorStr << QString::number(g);
5780 colorStr << QString::number(b);
5782 aSmeshActor->GetBallColor(r, g, b);
5784 colorStr << QString::number(r);
5785 colorStr << QString::number(g);
5786 colorStr << QString::number(b);
5788 aSmeshActor->GetFacesOrientationColor(r, g, b);
5789 colorStr << "orientation";
5790 colorStr << QString::number(r);
5791 colorStr << QString::number(g);
5792 colorStr << QString::number(b);
5794 param = vtkParam + "Colors";
5795 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5798 QStringList sizeStr;
5800 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5801 sizeStr << "outline";
5802 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5803 sizeStr << "elem0d";
5804 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5806 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5807 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5808 sizeStr << "shrink";
5809 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5810 sizeStr << "orientation";
5811 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5812 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5814 param = vtkParam + "Sizes";
5815 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5820 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5821 if( aMarkerType == VTK::MT_USER ) {
5822 markerStr += "custom";
5823 markerStr += gDigitsSep;
5824 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5828 markerStr += gDigitsSep;
5829 markerStr += QString::number( (int)aMarkerType );
5830 markerStr += gDigitsSep;
5831 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5834 param = vtkParam + "PointMarker";
5835 ip->setParameter(entry, param, markerStr.toLatin1().data());
5838 param = vtkParam + "Opacity";
5839 ip->setParameter(entry, param,
5840 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5843 param = vtkParam + "ClippingPlane";
5845 if( !aClippingPlaneInfoList.empty() ) {
5846 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5847 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5849 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5850 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5851 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5852 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5853 if( aSmeshActor == *anIter2 ) {
5854 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5855 QString::number( anId ).toLatin1().constData() );
5862 ip->setParameter( entry, param, "Off" );
5863 } // if (io->hasEntry())
5864 } // SMESH_Actor && hasIO
5866 } // while.. actors traversal
5870 } // if (SVTK view model)
5871 } // for (viewManagers)
5874 // data structures for clipping planes processing
5878 bool isOpenGLClipping;
5879 vtkIdType RelativeOrientation;
5882 int AbsoluteOrientation;
5883 double X, Y, Z, Dx, Dy, Dz;
5885 typedef std::list<TPlaneData> TPlaneDataList;
5886 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5888 typedef std::list<vtkActor*> TActorList;
5891 TActorList ActorList;
5892 SUIT_ViewManager* ViewManager;
5894 typedef std::list<TPlaneInfo> TPlaneInfoList;
5895 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5898 * \brief Restore visual parameters
5900 * This method is called after the study document is opened.
5901 * Restore visual parameters from AttributeParameter attribue(s)
5903 void SMESHGUI::restoreVisualParameters (int savePoint)
5906 Kernel_Utils::Localizer loc;
5908 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5909 if (!appStudy || !appStudy->studyDS())
5911 _PTR(Study) studyDS = appStudy->studyDS();
5913 // componentName is used for encoding of entries when storing them in IParameters
5914 std::string componentName = myComponentSMESH->ComponentDataType();
5915 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5916 //if (!aSComponent) return;
5919 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5920 componentName.c_str(),
5922 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5924 // restore map of custom markers and map of clipping planes
5925 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5926 TPlaneDataMap aPlaneDataMap;
5928 std::vector<std::string> properties = ip->getProperties();
5929 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5931 std::string property = *propIt;
5932 QString aPropertyName( property.c_str() );
5933 QString aPropertyValue( ip->getProperty( property ).c_str() );
5935 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5936 if( aPropertyNameList.isEmpty() )
5939 QString aPropertyType = aPropertyNameList[0];
5940 if( aPropertyType == "texture" )
5942 if( aPropertyNameList.size() != 2 )
5946 int anId = aPropertyNameList[1].toInt( &ok );
5947 if( !ok || anId < 1 )
5950 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5951 if( aPropertyValueList.size() != 2 )
5954 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5955 QString aMarkerTextureString = aPropertyValueList[1];
5956 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5957 if( aMarkerTextureStringList.size() != 3 )
5961 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5966 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5970 VTK::MarkerTexture aMarkerTexture;
5971 aMarkerTexture.push_back( aWidth );
5972 aMarkerTexture.push_back( aHeight );
5974 QString aMarkerTextureData = aMarkerTextureStringList[2];
5975 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5977 QChar aChar = aMarkerTextureData.at( i );
5978 if( aChar.isDigit() )
5979 aMarkerTexture.push_back( aChar.digitValue() );
5982 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5984 else if( aPropertyType == "ClippingPlane" )
5986 if( aPropertyNameList.size() != 3 )
5990 int aViewId = aPropertyNameList[1].toInt( &ok );
5991 if( !ok || aViewId < 0 )
5995 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5996 if( !ok || aClippingPlaneId < 0 )
5999 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6000 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6003 TPlaneData aPlaneData;
6004 aPlaneData.Id = aClippingPlaneId;
6007 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6012 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6016 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6019 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6024 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6029 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6034 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6039 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6044 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6049 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6053 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6055 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6060 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6065 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6070 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6075 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6076 aPlaneDataList.push_back( aPlaneData );
6080 TPlaneInfoMap aPlaneInfoMap;
6082 std::vector<std::string> entries = ip->getEntries();
6084 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6086 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6087 QString entry (ip->decodeEntry(*entIt).c_str());
6089 // Check that the entry corresponds to a real object in the Study
6090 // as the object may be deleted or modified after the visual state is saved.
6091 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6092 if (!so) continue; //Skip the not existent entry
6094 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6095 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6097 std::vector<std::string>::iterator namesIt = paramNames.begin();
6098 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6100 // actors are stored in a map after displaying of them for
6101 // quicker access in the future: map < viewID to actor >
6102 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6104 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6106 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6107 // '_' is used as separator and should not be used in viewer type or parameter names.
6108 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6109 if (lst.size() != 3)
6112 QString viewerTypStr = lst[0];
6113 QString viewIndexStr = lst[1];
6114 QString paramNameStr = lst[2];
6117 int viewIndex = viewIndexStr.toUInt(&ok);
6118 if (!ok) // bad conversion of view index to integer
6122 if (viewerTypStr == SVTK_Viewer::Type())
6124 SMESH_Actor* aSmeshActor = 0;
6125 if (vtkActors.IsBound(viewIndex))
6126 aSmeshActor = vtkActors.Find(viewIndex);
6128 QList<SUIT_ViewManager*> lst;
6129 getApp()->viewManagers(viewerTypStr, lst);
6131 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6132 SUIT_ViewManager* vman = NULL;
6133 if (viewIndex >= 0 && viewIndex < lst.count())
6134 vman = lst.at(viewIndex);
6136 if (paramNameStr == "Visibility")
6138 if (!aSmeshActor && displayer() && vman)
6140 SUIT_ViewModel* vmodel = vman->getViewModel();
6141 // SVTK view model can be casted to SALOME_View
6142 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6144 // store displayed actor in a temporary map for quicker
6145 // access later when restoring other parameters
6146 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6147 vtkRenderer* Renderer = vtkView->getRenderer();
6148 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6149 vtkActorCollection* theActors = aCopy.GetActors();
6150 theActors->InitTraversal();
6151 bool isFound = false;
6152 vtkActor *ac = theActors->GetNextActor();
6153 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6154 if (ac->IsA("SMESH_Actor")) {
6155 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6156 if (aGeomAc->hasIO()) {
6157 Handle(SALOME_InteractiveObject) io =
6158 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6159 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6161 vtkActors.Bind(viewIndex, aGeomAc);
6167 } // if (paramNameStr == "Visibility")
6170 // the rest properties "work" with SMESH_Actor
6173 QString val ((*valuesIt).c_str());
6176 if (paramNameStr == "Representation") {
6177 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6180 else if (paramNameStr == "IsShrunk") {
6182 if (!aSmeshActor->IsShrunk())
6183 aSmeshActor->SetShrink();
6186 if (aSmeshActor->IsShrunk())
6187 aSmeshActor->UnShrink();
6190 // Displayed entities
6191 else if (paramNameStr == "Entities") {
6192 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6193 int aEntityMode = SMESH_Actor::eAllEntity;
6194 for ( int i = 0; i < mode.count(); i+=2 ) {
6195 if ( i < mode.count()-1 ) {
6196 QString type = mode[i];
6197 bool val = mode[i+1].toInt();
6198 if ( type == "e" && !val )
6199 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6200 else if ( type == "f" && !val )
6201 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6202 else if ( type == "v" && !val )
6203 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6204 else if ( type == "0d" && !val )
6205 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6206 else if ( type == "b" && !val )
6207 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6210 aSmeshActor->SetEntityMode( aEntityMode );
6213 else if (paramNameStr == "Colors") {
6214 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6221 QColor outlineColor;
6222 QColor orientationColor;
6228 // below lines are required to get default values for delta coefficients
6229 // of backface color for faces and color of reversed volumes
6230 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6231 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6232 for ( int i = 0; i < colors.count(); i++ ) {
6233 QString type = colors[i];
6234 if ( type == "surface" ) {
6235 // face color is set by 3 values r:g:b, where
6236 // - r,g,b - is rgb color components
6237 if ( i+1 >= colors.count() ) break; // format error
6238 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6239 if ( i+2 >= colors.count() ) break; // format error
6240 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6241 if ( i+3 >= colors.count() ) break; // format error
6242 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6243 faceColor.setRgbF( r, g, b );
6246 else if ( type == "backsurface" ) {
6247 // backface color can be defined in several ways
6248 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6249 // - in latest versions, it is set as delta coefficient
6250 bool rgbOk = false, deltaOk;
6251 if ( i+1 >= colors.count() ) break; // format error
6252 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6253 int delta = colors[i+1].toInt( &deltaOk );
6255 if ( i+1 < colors.count() ) // index is shifted to 1
6256 g = colors[i+1].toDouble( &rgbOk );
6257 if ( rgbOk ) i++; // shift index
6258 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6259 b = colors[i+1].toDouble( &rgbOk );
6261 // - as currently there's no way to set directly backsurface color as it was before,
6262 // we ignore old dump where r,g,b triple was set
6263 // - also we check that delta parameter is set properly
6264 if ( !rgbOk && deltaOk )
6267 else if ( type == "volume" ) {
6268 // volume color is set by 4 values r:g:b:delta, where
6269 // - r,g,b - is a normal volume rgb color components
6270 // - delta - is a reversed volume color delta coefficient
6271 if ( i+1 >= colors.count() ) break; // format error
6272 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6273 if ( i+2 >= colors.count() ) break; // format error
6274 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6275 if ( i+3 >= colors.count() ) break; // format error
6276 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6277 if ( i+4 >= colors.count() ) break; // format error
6278 int delta = colors[i+4].toInt( &bOk );
6279 if ( !bOk ) break; // format error
6280 volumeColor.setRgbF( r, g, b );
6284 else if ( type == "edge" ) {
6285 // edge color is set by 3 values r:g:b, where
6286 // - r,g,b - is rgb color components
6287 if ( i+1 >= colors.count() ) break; // format error
6288 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6289 if ( i+2 >= colors.count() ) break; // format error
6290 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6291 if ( i+3 >= colors.count() ) break; // format error
6292 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6293 edgeColor.setRgbF( r, g, b );
6296 else if ( type == "node" ) {
6297 // node color is set by 3 values r:g:b, where
6298 // - r,g,b - is rgb color components
6299 if ( i+1 >= colors.count() ) break; // format error
6300 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6301 if ( i+2 >= colors.count() ) break; // format error
6302 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6303 if ( i+3 >= colors.count() ) break; // format error
6304 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6305 nodeColor.setRgbF( r, g, b );
6308 else if ( type == "elem0d" ) {
6309 // 0d element color is set by 3 values r:g:b, where
6310 // - r,g,b - is rgb color components
6311 if ( i+1 >= colors.count() ) break; // format error
6312 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6313 if ( i+2 >= colors.count() ) break; // format error
6314 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6315 if ( i+3 >= colors.count() ) break; // format error
6316 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6317 elem0dColor.setRgbF( r, g, b );
6320 else if ( type == "ball" ) {
6321 // ball color is set by 3 values r:g:b, where
6322 // - r,g,b - is rgb color components
6323 if ( i+1 >= colors.count() ) break; // format error
6324 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6325 if ( i+2 >= colors.count() ) break; // format error
6326 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6327 if ( i+3 >= colors.count() ) break; // format error
6328 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6329 ballColor.setRgbF( r, g, b );
6332 else if ( type == "outline" ) {
6333 // outline color is set by 3 values r:g:b, where
6334 // - r,g,b - is rgb color components
6335 if ( i+1 >= colors.count() ) break; // format error
6336 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6337 if ( i+2 >= colors.count() ) break; // format error
6338 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6339 if ( i+3 >= colors.count() ) break; // format error
6340 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6341 outlineColor.setRgbF( r, g, b );
6344 else if ( type == "orientation" ) {
6345 // orientation color is set by 3 values r:g:b, where
6346 // - r,g,b - is rgb color components
6347 if ( i+1 >= colors.count() ) break; // format error
6348 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6349 if ( i+2 >= colors.count() ) break; // format error
6350 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6351 if ( i+3 >= colors.count() ) break; // format error
6352 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6353 orientationColor.setRgbF( r, g, b );
6358 if ( nodeColor.isValid() )
6359 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6361 if ( edgeColor.isValid() )
6362 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6364 if ( faceColor.isValid() )
6365 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6367 if ( volumeColor.isValid() )
6368 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6369 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6370 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6372 if ( elem0dColor.isValid() )
6373 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6375 if ( ballColor.isValid() )
6376 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6378 if ( outlineColor.isValid() )
6379 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6380 // orientation color
6381 if ( orientationColor.isValid() )
6382 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6385 else if (paramNameStr == "Sizes") {
6386 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6389 int outlineWidth = -1;
6390 int elem0dSize = -1;
6392 double ballScale = -1.0;
6393 double shrinkSize = -1;
6394 double orientationSize = -1;
6395 bool orientation3d = false;
6396 for ( int i = 0; i < sizes.count(); i++ ) {
6397 QString type = sizes[i];
6398 if ( type == "line" ) {
6399 // line (wireframe) width is given as single integer value
6400 if ( i+1 >= sizes.count() ) break; // format error
6401 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6405 if ( type == "outline" ) {
6406 // outline width is given as single integer value
6407 if ( i+1 >= sizes.count() ) break; // format error
6408 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6412 else if ( type == "elem0d" ) {
6413 // 0d element size is given as single integer value
6414 if ( i+1 >= sizes.count() ) break; // format error
6415 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6419 else if ( type == "ball" ) {
6420 // balls are specified by two values: size:scale, where
6421 // - size - is a integer value specifying size
6422 // - scale - is a double value specifying scale factor
6423 if ( i+1 >= sizes.count() ) break; // format error
6424 int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6425 if ( i+2 >= sizes.count() ) break; // format error
6426 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6431 else if ( type == "shrink" ) {
6432 // shrink factor is given as single floating point value
6433 if ( i+1 >= sizes.count() ) break; // format error
6434 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6438 else if ( type == "orientation" ) {
6439 // orientation vectors are specified by two values size:3d, where
6440 // - size - is a floating point value specifying scale factor
6441 // - 3d - is a boolean
6442 if ( i+1 >= sizes.count() ) break; // format error
6443 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6444 if ( i+2 >= sizes.count() ) break; // format error
6445 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6446 orientationSize = v1;
6447 orientation3d = (bool)v2;
6451 // line (wireframe) width
6452 if ( lineWidth > 0 )
6453 aSmeshActor->SetLineWidth( lineWidth );
6455 if ( outlineWidth > 0 )
6456 aSmeshActor->SetOutlineWidth( outlineWidth );
6457 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6458 aSmeshActor->SetOutlineWidth( lineWidth );
6460 if ( elem0dSize > 0 )
6461 aSmeshActor->Set0DSize( elem0dSize );
6464 aSmeshActor->SetBallSize( ballSize );
6466 if ( ballScale > 0.0 )
6467 aSmeshActor->SetBallScale( ballScale );
6469 if ( shrinkSize > 0 )
6470 aSmeshActor->SetShrinkFactor( shrinkSize );
6471 // orientation vectors
6472 if ( orientationSize > 0 ) {
6473 aSmeshActor->SetFacesOrientationScale( orientationSize );
6474 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6478 else if (paramNameStr == "PointMarker") {
6479 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6480 if( data.count() >= 2 ) {
6482 int aParam1 = data[1].toInt( &ok );
6484 if( data[0] == "std" && data.count() == 3 ) {
6485 int aParam2 = data[2].toInt( &ok );
6486 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6488 else if( data[0] == "custom" ) {
6489 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6490 if( markerIt != aMarkerMap.end() ) {
6491 VTK::MarkerData aMarkerData = markerIt->second;
6492 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6499 else if (paramNameStr == "Opacity") {
6500 aSmeshActor->SetOpacity(val.toFloat());
6503 else if (paramNameStr.startsWith("ClippingPlane")) {
6504 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6505 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6506 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6507 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6508 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6509 // new format - val looks like "Off" or "0" (plane id)
6510 // (note: in new format "Off" value is used only for consistency,
6511 // so it is processed together with values in old format)
6512 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6513 if( anIsOldFormat ) {
6514 if (paramNameStr == "ClippingPlane1" || val == "Off")
6515 aSmeshActor->RemoveAllClippingPlanes();
6517 QList<SUIT_ViewManager*> lst;
6518 getApp()->viewManagers(viewerTypStr, lst);
6519 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6520 if (viewIndex >= 0 && viewIndex < lst.count()) {
6521 SUIT_ViewManager* vman = lst.at(viewIndex);
6522 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6524 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6526 SMESH::TActorList anActorList;
6527 anActorList.push_back( aSmeshActor );
6528 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6529 aPlane->myViewWindow = vtkView;
6530 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6531 aPlane->PlaneMode = aMode;
6532 bool isOpenGLClipping = ( bool )vals[1].toInt();
6533 aPlane->IsOpenGLClipping = isOpenGLClipping;
6534 if ( aMode == SMESH::Absolute ) {
6535 aPlane->myAbsoluteOrientation = vals[2].toInt();
6536 aPlane->X = vals[3].toFloat();
6537 aPlane->Y = vals[4].toFloat();
6538 aPlane->Z = vals[5].toFloat();
6539 aPlane->Dx = vals[6].toFloat();
6540 aPlane->Dy = vals[7].toFloat();
6541 aPlane->Dz = vals[8].toFloat();
6543 else if ( aMode == SMESH::Relative ) {
6544 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6545 aPlane->myDistance = vals[3].toFloat();
6546 aPlane->myAngle[0] = vals[4].toFloat();
6547 aPlane->myAngle[1] = vals[5].toFloat();
6551 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6552 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6553 aClippingPlaneInfo.Plane = aPlane;
6554 aClippingPlaneInfo.ActorList = anActorList;
6555 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6563 int aPlaneId = val.toInt( &ok );
6564 if( ok && aPlaneId >= 0 ) {
6565 bool anIsDefinedPlane = false;
6566 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6567 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6568 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6569 TPlaneInfo& aPlaneInfo = *anIter;
6570 if( aPlaneInfo.PlaneId == aPlaneId ) {
6571 aPlaneInfo.ActorList.push_back( aSmeshActor );
6572 anIsDefinedPlane = true;
6576 if( !anIsDefinedPlane ) {
6577 TPlaneInfo aPlaneInfo;
6578 aPlaneInfo.PlaneId = aPlaneId;
6579 aPlaneInfo.ActorList.push_back( aSmeshActor );
6580 aPlaneInfo.ViewManager = vman;
6582 // to make the list sorted by plane id
6583 anIter = aPlaneInfoList.begin();
6584 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6585 const TPlaneInfo& aPlaneInfoRef = *anIter;
6586 if( aPlaneInfoRef.PlaneId > aPlaneId )
6589 aPlaneInfoList.insert( anIter, aPlaneInfo );
6594 } // if (aSmeshActor)
6595 } // other parameters than Visibility
6597 } // for names/parameters iterator
6598 } // for entries iterator
6600 // take into account planes with empty list of actors referred to them
6601 QList<SUIT_ViewManager*> aVMList;
6602 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6604 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6605 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6606 int aViewId = aPlaneDataIter->first;
6607 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6608 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6610 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6612 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6613 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6614 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6615 const TPlaneData& aPlaneData = *anIter2;
6616 int aPlaneId = aPlaneData.Id;
6618 bool anIsFound = false;
6619 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6620 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6621 const TPlaneInfo& aPlaneInfo = *anIter3;
6622 if( aPlaneInfo.PlaneId == aPlaneId ) {
6629 TPlaneInfo aPlaneInfo; // ActorList field is empty
6630 aPlaneInfo.PlaneId = aPlaneId;
6631 aPlaneInfo.ViewManager = aViewManager;
6633 // to make the list sorted by plane id
6634 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6635 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6636 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6637 if( aPlaneInfoRef.PlaneId > aPlaneId )
6640 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6646 // add clipping planes to actors according to the restored parameters
6647 // and update the clipping plane map
6648 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6649 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6650 int aViewId = anIter1->first;
6651 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6653 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6654 if( anIter2 == aPlaneDataMap.end() )
6656 const TPlaneDataList& aPlaneDataList = anIter2->second;
6658 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6659 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6660 const TPlaneInfo& aPlaneInfo = *anIter3;
6661 int aPlaneId = aPlaneInfo.PlaneId;
6662 const TActorList& anActorList = aPlaneInfo.ActorList;
6663 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6667 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6671 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6673 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6674 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6675 const TPlaneData& aPlaneData = *anIter4;
6676 if( aPlaneData.Id == aPlaneId ) {
6677 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6678 aPlane->myViewWindow = aViewWindow;
6679 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6680 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6681 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6682 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6683 aPlane->X = aPlaneData.X;
6684 aPlane->Y = aPlaneData.Y;
6685 aPlane->Z = aPlaneData.Z;
6686 aPlane->Dx = aPlaneData.Dx;
6687 aPlane->Dy = aPlaneData.Dy;
6688 aPlane->Dz = aPlaneData.Dz;
6690 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6691 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6692 aPlane->myDistance = aPlaneData.Distance;
6693 aPlane->myAngle[0] = aPlaneData.Angle[0];
6694 aPlane->myAngle[1] = aPlaneData.Angle[1];
6697 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6698 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6699 aClippingPlaneInfo.Plane = aPlane;
6700 aClippingPlaneInfo.ActorList = anActorList;
6701 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6712 // update all VTK views
6713 QList<SUIT_ViewManager*> lst;
6714 getApp()->viewManagers(lst);
6715 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6716 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6717 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6718 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6719 // set OpenGL clipping planes
6720 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6721 vtkActorCollection* anAllActors = aCopy.GetActors();
6722 anAllActors->InitTraversal();
6723 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6724 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6725 anActor->SetOpenGLClippingPlane();
6727 vtkView->getRenderer()->ResetCameraClippingRange();
6734 \brief Adds preferences for dfont of VTK viewer
6736 \param pIf group identifier
6737 \param param parameter
6738 \return identifier of preferences
6740 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6742 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6744 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6747 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6748 fam.append( tr( "SMESH_FONT_COURIER" ) );
6749 fam.append( tr( "SMESH_FONT_TIMES" ) );
6751 setPreferenceProperty( tfont, "fonts", fam );
6753 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6754 if ( needSize ) f = f | QtxFontEdit::Size;
6755 setPreferenceProperty( tfont, "features", f );
6761 \brief Actions after hypothesis edition
6762 Updates object browser after hypothesis edition
6764 void SMESHGUI::onHypothesisEdit( int result )
6767 SMESHGUI::Modified();
6768 updateObjBrowser( true );
6773 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6774 \param pview view being closed
6776 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6777 #ifndef DISABLE_PLOT2DVIEWER
6778 //Crear all Plot2d Viewers if need.
6779 SMESH::ClearPlot2Viewers(pview);
6783 void SMESHGUI::message( const QString& msg )
6786 QStringList data = msg.split("/");
6787 if ( data.count() > 0 ) {
6788 if ( data.first() == "mesh_loading" ) {
6790 QString entry = data.count() > 1 ? data[1] : QString();
6791 if ( entry.isEmpty() )
6794 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6796 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6799 name = QString::fromUtf8(obj->GetName().c_str());
6800 if ( name.isEmpty() )
6803 if ( data.last() == "stop" )
6804 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6806 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6807 QApplication::processEvents();
6813 \brief Connects or disconnects signals about activating and cloning view on the module slots
6814 \param pview view which is connected/disconnected
6816 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6820 SUIT_ViewManager* viewMgr = pview->getViewManager();
6822 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6823 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6825 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6826 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6831 \brief Return \c true if object can be renamed
6833 bool SMESHGUI::renameAllowed( const QString& entry) const {
6834 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6838 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6842 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6847 if(appStudy->isComponent(entry) || obj->isReference())
6850 // check type to prevent renaming of inappropriate objects
6851 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6852 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6853 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6854 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6855 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6856 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6863 Rename object by entry.
6864 \param entry entry of the object
6865 \param name new name of the object
6866 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6868 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6870 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6874 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6879 _PTR(Study) aStudy = appStudy->studyDS();
6884 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6886 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6891 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6892 _PTR(GenericAttribute) anAttr;
6893 _PTR(AttributeName) aName;
6895 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6897 // check type to prevent renaming of inappropriate objects
6898 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6899 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6900 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6901 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6902 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6903 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6904 if ( !name.isEmpty() ) {
6905 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6907 // update name of group object and its actor
6908 Handle(SALOME_InteractiveObject) IObject =
6909 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6911 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6912 if( !aGroupObject->_is_nil() ) {
6913 aGroupObject->SetName( qPrintable(name) );
6914 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6915 anActor->setName( qPrintable(name) );
6925 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6927 static QList<QColor> colors;
6929 if ( colors.isEmpty() ) {
6931 for (int s = 0; s < 2 ; s++)
6933 for (int v = 100; v >= 40; v = v - 20)
6935 for (int h = 0; h < 359 ; h = h + 60)
6937 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
6942 static int currentColor = 0;
6944 SALOMEDS::Color color;
6945 color.R = (double)colors[currentColor].red() / 255.0;
6946 color.G = (double)colors[currentColor].green() / 255.0;
6947 color.B = (double)colors[currentColor].blue() / 255.0;
6949 currentColor = (currentColor+1) % colors.count();