1 // Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FieldSelectorWdg.h"
48 #include "SMESHGUI_FileInfoDlg.h"
49 #include "SMESHGUI_FileValidator.h"
50 #include "SMESHGUI_FilterDlg.h"
51 #include "SMESHGUI_FilterLibraryDlg.h"
52 #include "SMESHGUI_FindElemByPointDlg.h"
53 #include "SMESHGUI_GroupDlg.h"
54 #include "SMESHGUI_GroupOnShapeDlg.h"
55 #include "SMESHGUI_GroupOpDlg.h"
56 #include "SMESHGUI_Hypotheses.h"
57 #include "SMESHGUI_Make2DFrom3DOp.h"
58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
59 #include "SMESHGUI_Measurements.h"
60 #include "SMESHGUI_MergeDlg.h"
61 #include "SMESHGUI_MeshInfo.h"
62 #include "SMESHGUI_MeshOp.h"
63 #include "SMESHGUI_MeshOrderOp.h"
64 #include "SMESHGUI_MeshPatternDlg.h"
65 #include "SMESHGUI_MultiEditDlg.h"
66 #include "SMESHGUI_NodesDlg.h"
67 #include "SMESHGUI_Operations.h"
68 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
69 #include "SMESHGUI_PropertiesDlg.h"
70 #include "SMESHGUI_RemoveElementsDlg.h"
71 #include "SMESHGUI_RemoveNodesDlg.h"
72 #include "SMESHGUI_RenumberingDlg.h"
73 #include "SMESHGUI_ReorientFacesDlg.h"
74 #include "SMESHGUI_RevolutionDlg.h"
75 #include "SMESHGUI_RotationDlg.h"
76 #include "SMESHGUI_ScaleDlg.h"
77 #include "SMESHGUI_Selection.h"
78 #include "SMESHGUI_SewingDlg.h"
79 #include "SMESHGUI_SingleEditDlg.h"
80 #include "SMESHGUI_SmoothingDlg.h"
81 #include "SMESHGUI_SymmetryDlg.h"
82 #include "SMESHGUI_TranslationDlg.h"
83 #include "SMESHGUI_TransparencyDlg.h"
85 #include "SMESHGUI_FilterUtils.h"
86 #include "SMESHGUI_GEOMGenUtils.h"
87 #include "SMESHGUI_GroupUtils.h"
88 #include "SMESHGUI_HypothesesUtils.h"
89 #include "SMESHGUI_MeshUtils.h"
90 #include "SMESHGUI_PatternUtils.h"
91 #include "SMESHGUI_Utils.h"
92 #include "SMESHGUI_VTKUtils.h"
94 #include <SMESH_version.h>
96 #include "SMESH_ControlsDef.hxx"
97 #include <SMESH_Actor.h>
98 #include <SMESH_ActorUtils.h>
99 #include <SMESH_Client.hxx>
100 #include <SMESH_ScalarBarActor.h>
101 #include <SMESH_TypeFilter.hxx>
103 // SALOME GUI includes
104 #include <SalomeApp_Application.h>
105 #include <SalomeApp_CheckFileDlg.h>
106 #include <SalomeApp_DataObject.h>
107 #include <SalomeApp_Study.h>
108 #include <SalomeApp_Tools.h>
110 #include <LightApp_DataOwner.h>
111 #include <LightApp_NameDlg.h>
112 #include <LightApp_Preferences.h>
113 #include <LightApp_SelectionMgr.h>
114 #include <LightApp_UpdateFlags.h>
116 #include <SVTK_ViewManager.h>
117 #include <SVTK_ViewModel.h>
118 #include <SVTK_ViewWindow.h>
120 #include <VTKViewer_Algorithm.h>
122 #include <PyInterp_Interp.h>
124 #include <SUIT_Desktop.h>
125 #include <SUIT_FileDlg.h>
126 #include <SUIT_MessageBox.h>
127 #include <SUIT_OverrideCursor.h>
128 #include <SUIT_ResourceMgr.h>
129 #include <SUIT_Session.h>
131 #include <QtxPopupMgr.h>
132 #include <QtxFontEdit.h>
134 #include <SALOME_ListIO.hxx>
135 #include <SALOME_ListIteratorOfListIO.hxx>
137 #ifndef DISABLE_PLOT2DVIEWER
138 #include <SPlot2d_ViewModel.h>
139 #include <SPlot2d_Histogram.h>
143 #include <SALOMEconfig.h>
144 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
145 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
146 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
149 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
150 #include <QApplication>
152 #include <QTextStream>
155 #include <boost/shared_ptr.hpp>
158 #include <vtkCallbackCommand.h>
159 #include <vtkCamera.h>
160 #include <vtkLookupTable.h>
161 #include <vtkPlane.h>
162 #include <vtkRenderer.h>
164 // SALOME KERNEL includes
165 #include <SALOMEDSClient_ClientFactory.hxx>
166 #include <SALOMEDSClient_IParameters.hxx>
167 #include <SALOMEDSClient_SComponent.hxx>
168 #include <SALOMEDSClient_StudyBuilder.hxx>
169 #include <SALOMEDS_Study.hxx>
170 #include <SALOMEDS_SObject.hxx>
173 #include <Standard_ErrorHandler.hxx>
174 #include <NCollection_DataMap.hxx>
176 #include <Basics_Utils.hxx>
178 //To disable automatic genericobj management, the following line should be commented.
179 //Otherwise, it should be uncommented.
180 //Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
181 #define WITHGENERICOBJ
183 // Below macro, when uncommented, switches on simplified (more performant) algorithm
184 // of auto-color picking up
185 #define SIMPLE_AUTOCOLOR
190 //=============================================================
191 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
194 void ExportMeshToFile(int theCommandID);
196 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
198 void SetDisplayEntity(int theCommandID);
200 void Control( int theCommandID );
203 //================================================================================
205 * \brief Reads meshes from file
207 //================================================================================
209 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
213 std::string myExtension;
215 if ( theCommandID == SMESHOp::OpImportMED ) {
216 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
217 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
219 else if ( theCommandID == SMESHOp::OpImportUNV ) {
220 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
222 else if ( theCommandID == SMESHOp::OpImportDAT ) {
223 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
225 else if ( theCommandID == SMESHOp::OpImportSTL ) {
226 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
229 else if ( theCommandID == SMESHOp::OpImportCGNS ) {
230 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
233 else if ( theCommandID == SMESHOp::OpImportSAUV ) {
234 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
235 filter.append( QObject::tr( "All files (*)" ) );
237 else if ( theCommandID == SMESHOp::OpImportGMF ) {
238 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
239 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
242 QString anInitialPath = "";
243 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
244 anInitialPath = QDir::currentPath();
246 QStringList filenames;
247 bool toCreateGroups = true;
249 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
250 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
251 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
252 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
253 // fd->setNameFilters( filter );
254 // fd->SetChecked( true );
256 // filenames << fd->selectedFile();
257 // toCreateGroups = fd->IsChecked();
263 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
266 QObject::tr( "SMESH_IMPORT_MESH" ) );
268 if ( filenames.count() > 0 ) {
269 SUIT_OverrideCursor wc;
270 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
273 QStringList anEntryList;
274 bool isEmpty = false;
275 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
276 QString filename = *it;
277 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
279 switch ( theCommandID ) {
280 case SMESHOp::OpImportDAT:
282 // DAT format (currently unsupported)
283 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
284 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
287 case SMESHOp::OpImportUNV:
290 aMeshes->length( 1 );
291 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
292 if ( aMeshes[0]->_is_nil() )
293 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
294 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
297 case SMESHOp::OpImportMED:
300 SMESH::DriverMED_ReadStatus res;
301 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
302 if ( res != SMESH::DRS_OK ) {
303 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
304 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
308 case SMESHOp::OpImportSTL:
311 aMeshes->length( 1 );
312 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
313 if ( aMeshes[0]->_is_nil() ) {
314 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
315 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
320 case SMESHOp::OpImportCGNS:
323 SMESH::DriverMED_ReadStatus res;
324 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
325 if ( res != SMESH::DRS_OK ) {
326 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
327 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
332 case SMESHOp::OpImportSAUV:
335 SMESH::DriverMED_ReadStatus res;
336 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
337 if ( res != SMESH::DRS_OK ) {
338 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
339 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
343 case SMESHOp::OpImportGMF:
346 SMESH::ComputeError_var res;
347 aMeshes->length( 1 );
348 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
351 if ( res->code != SMESH::DRS_OK ) {
352 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
353 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
354 if ( strlen( res->comment.in() ) > 0 ) {
355 errors.back() += ": ";
356 errors.back() += res->comment.in();
363 catch ( const SALOME::SALOME_Exception& S_ex ) {
364 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
365 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
368 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
369 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
371 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
372 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
373 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
374 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
375 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
377 anEntryList.append( aMeshSO->GetID().c_str() );
385 // update Object browser
386 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
388 // browse to the published meshes
389 if( LightApp_Application* anApp =
390 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
391 anApp->browseObjects( anEntryList );
393 // show Error message box if there were errors
394 if ( errors.count() > 0 ) {
395 SUIT_MessageBox::critical( SMESHGUI::desktop(),
396 QObject::tr( "SMESH_ERROR" ),
397 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
400 // show warning message box, if some imported mesh is empty
402 SUIT_MessageBox::warning( SMESHGUI::desktop(),
403 QObject::tr( "SMESH_WRN_WARNING" ),
404 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
409 //================================================================================
411 * \brief Export selected meshes or groups into a file
413 //================================================================================
415 void ExportMeshToFile( int theCommandID )
417 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
418 SALOME_ListIO selected;
420 aSel->selectedObjects( selected );
422 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT || theCommandID == SMESHOp::OpPopupExportDAT );
423 const bool isMED = ( theCommandID == SMESHOp::OpExportMED || theCommandID == SMESHOp::OpPopupExportMED );
424 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV || theCommandID == SMESHOp::OpPopupExportUNV );
425 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL || theCommandID == SMESHOp::OpPopupExportSTL );
427 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS || theCommandID == SMESHOp::OpPopupExportCGNS );
429 const bool isCGNS= false;
431 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV || theCommandID == SMESHOp::OpPopupExportSAUV );
432 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF || theCommandID == SMESHOp::OpPopupExportGMF );
434 // actually, the following condition can't be met (added for insurance)
435 if( selected.Extent() == 0 ||
436 ( selected.Extent() > 1 && !isMED && !isSTL ))
439 // get mesh object from selection and check duplication of their names
440 bool hasDuplicatedMeshNames = false;
441 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
442 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
443 SALOME_ListIteratorOfListIO It( selected );
444 for( ; It.More(); It.Next() )
446 Handle(SALOME_InteractiveObject) anIObject = It.Value();
447 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
448 if ( aMeshItem->_is_nil() ) {
449 SUIT_MessageBox::warning( SMESHGUI::desktop(),
450 QObject::tr( "SMESH_WRN_WARNING" ),
451 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
455 QString aMeshName = anIObject->getName();
457 // check for name duplications
458 if ( !hasDuplicatedMeshNames )
459 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
460 if( aMeshName == (*aMeshIter).second ) {
461 hasDuplicatedMeshNames = true;
466 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
469 if( hasDuplicatedMeshNames && isMED ) {
470 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
471 QObject::tr("SMESH_WRN_WARNING"),
472 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
473 QObject::tr("SMESH_BUT_YES"),
474 QObject::tr("SMESH_BUT_NO"), 0, 1);
479 aMeshIter = aMeshList.begin();
480 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
481 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
482 QString aMeshName = (*aMeshIter).second;
484 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
486 // check for equal group names within each mesh
487 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
488 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
489 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
490 int aRet = SUIT_MessageBox::warning
491 (SMESHGUI::desktop(),
492 QObject::tr("SMESH_WRN_WARNING"),
493 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
494 QObject::tr("SMESH_BUT_YES"),
495 QObject::tr("SMESH_BUT_NO"), 0, 1);
502 // Warn the user about presence of not supported elements
504 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
508 notSupportedElemTypes.push_back( SMESH::Entity_0D );
509 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
514 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
515 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
516 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
517 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
518 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
519 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
520 notSupportedElemTypes.push_back( SMESH::Entity_0D );
521 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
526 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
527 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
528 notSupportedElemTypes.push_back( SMESH::Entity_0D );
529 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
534 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
535 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
540 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
541 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
542 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
543 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
544 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
545 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
546 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
551 notSupportedElemTypes.push_back( SMESH::Entity_0D );
552 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
553 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
554 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
555 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
556 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
557 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
558 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
559 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
561 if ( ! notSupportedElemTypes.empty() )
563 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
564 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
565 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
566 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
568 if ( !presentNotSupported.empty() )
571 const char* typeMsg[SMESH::Entity_Last] = {
572 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
573 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
574 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
575 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
576 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
577 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
578 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
579 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
581 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
582 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
583 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
584 if ( iType != presentNotSupported.size() - 1 )
585 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
587 int aRet = SUIT_MessageBox::warning
588 (SMESHGUI::desktop(),
589 QObject::tr("SMESH_WRN_WARNING"),
590 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
591 QObject::tr("SMESH_BUT_YES"),
592 QObject::tr("SMESH_BUT_NO"), 0, 1);
597 // Get parameters of export operation
600 SMESH::MED_VERSION aFormat;
601 // Init the parameters with the default values
602 bool aIsASCII_STL = true;
603 bool toCreateGroups = false;
604 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
606 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
607 bool toOverwrite = true;
608 bool toFindOutDim = true;
610 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
611 QString anInitialPath = "";
612 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
613 anInitialPath = QDir::currentPath();
615 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
617 // Get a file name to write in and additional otions
618 if ( isUNV || isDAT || isGMF ) // Export w/o options
621 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
623 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
625 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
626 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
627 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
628 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
629 anInitialPath + QString("/") + aMeshName,
630 aFilter, aTitle, false);
632 else if ( isCGNS )// Export to CGNS
634 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
635 fd->setWindowTitle( aTitle );
636 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
637 if ( !anInitialPath.isEmpty() )
638 fd->setDirectory( anInitialPath );
639 fd->selectFile(aMeshName);
640 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
641 fd->setValidator( fv );
644 aFilename = fd->selectedFile();
645 toOverwrite = fv->isOverwrite();
649 else if ( isSTL ) // Export to STL
651 QMap<QString, int> aFilterMap;
652 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
653 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
656 QMap<QString, int>::const_iterator it = aFilterMap.begin();
657 for ( ; it != aFilterMap.end(); ++it )
658 filters.push_back( it.key() );
660 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
661 fd->setWindowTitle( aTitle );
662 fd->setNameFilters( filters );
663 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
664 if ( !anInitialPath.isEmpty() )
665 fd->setDirectory( anInitialPath );
666 fd->selectFile(aMeshName);
670 aFilename = fd->selectedFile();
671 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
676 else if ( isMED || isSAUV ) // Export to MED or SAUV
678 QMap<QString, SMESH::MED_VERSION> aFilterMap;
679 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
681 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
682 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
683 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
686 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
687 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
688 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
692 QString aDefaultFilter;
693 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
694 for ( ; it != aFilterMap.end(); ++it ) {
695 filters.push_back( it.key() );
696 if (it.value() == SMESH::MED_V2_2)
697 aDefaultFilter = it.key();
699 QStringList checkBoxes;
700 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
702 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
703 QList< QWidget* > wdgList;
704 if ( fieldSelWdg->GetAllFeilds( aMeshList, aFieldList ))
705 wdgList.append( fieldSelWdg );
707 SalomeApp_CheckFileDlg* fd =
708 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
709 fd->setWindowTitle( aTitle );
710 fd->setNameFilters( filters );
711 fd->selectNameFilter( aDefaultFilter );
712 fd->SetChecked( toCreateGroups, 0 );
713 fd->SetChecked( toFindOutDim, 1 );
714 if ( !anInitialPath.isEmpty() )
715 fd->setDirectory( anInitialPath );
716 fd->selectFile(aMeshName);
718 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
719 fd->setValidator( fv );
724 aFilename = fd->selectedFile();
726 aFilename = QString::null;
729 aFormat = aFilterMap[fd->selectedNameFilter()];
730 toOverwrite = fv->isOverwrite();
732 if ( !aFilename.isEmpty() ) {
733 // med-2.1 does not support poly elements
734 if ( aFormat==SMESH::MED_V2_1 )
735 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
736 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
737 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
738 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
739 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
741 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
742 QObject::tr("SMESH_WRN_WARNING"),
743 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
744 QObject::tr("SMESH_BUT_YES"),
745 QObject::tr("SMESH_BUT_NO"), 0, 1);
753 // can't append to an existing using other format
754 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
755 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
756 if( !isVersionOk || aVersion != aFormat ) {
757 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
758 QObject::tr("SMESH_WRN_WARNING"),
759 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
760 QObject::tr("SMESH_BUT_YES"),
761 QObject::tr("SMESH_BUT_NO"), 0, 1);
768 QStringList aMeshNamesCollisionList;
769 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
770 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
771 QString anExistingMeshName( aMeshNames[ i ] );
772 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
773 QString anExportMeshName = (*aMeshIter).second;
774 if( anExportMeshName == anExistingMeshName ) {
775 aMeshNamesCollisionList.append( anExportMeshName );
780 if( !aMeshNamesCollisionList.isEmpty() ) {
781 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
782 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
783 QObject::tr("SMESH_WRN_WARNING"),
784 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
785 QObject::tr("SMESH_BUT_YES"),
786 QObject::tr("SMESH_BUT_NO"),
787 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
796 toCreateGroups = fd->IsChecked(0);
797 toFindOutDim = fd->IsChecked(1);
798 fieldSelWdg->GetSelectedFeilds();
799 if ( !fieldSelWdg->parent() )
810 if ( !aFilename.isEmpty() ) {
811 // Check whether the file already exists and delete it if yes
812 QFile aFile( aFilename );
813 if ( aFile.exists() && toOverwrite )
815 SUIT_OverrideCursor wc;
818 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
819 // bool Renumber = false;
820 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
822 // Renumber= resMgr->booleanValue("renumbering");
824 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
825 // aMeshEditor->RenumberNodes();
826 // aMeshEditor->RenumberElements();
827 // if ( SMESHGUI::automaticUpdate() )
828 // SMESH::UpdateView();
832 aMeshIter = aMeshList.begin();
833 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
835 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
836 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
837 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
838 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
839 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
840 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
841 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
842 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
844 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
845 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
846 fields, geoAssFields.toLatin1().data() );
851 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
853 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
854 if( !aMeshItem->_is_nil() )
855 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
860 if ( aMeshOrGroup->_is_equivalent( aMesh ))
861 aMesh->ExportDAT( aFilename.toUtf8().data() );
863 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
867 if ( aMeshOrGroup->_is_equivalent( aMesh ))
868 aMesh->ExportUNV( aFilename.toUtf8().data() );
870 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
874 if ( aMeshOrGroup->_is_equivalent( aMesh ))
875 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
877 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
881 aMeshIter = aMeshList.begin();
882 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
884 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
885 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
886 aMeshItem->ExportCGNS( aMeshOrGroup,
887 aFilename.toUtf8().data(),
888 toOverwrite && aMeshIndex == 0 );
893 toCreateGroups = true;
894 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
897 catch (const SALOME::SALOME_Exception& S_ex){
899 SUIT_MessageBox::warning(SMESHGUI::desktop(),
900 QObject::tr("SMESH_WRN_WARNING"),
901 QObject::tr("SMESH_EXPORT_FAILED"));
907 inline void InverseEntityMode(unsigned int& theOutputMode,
908 unsigned int theMode)
910 bool anIsNotPresent = ~theOutputMode & theMode;
912 theOutputMode |= theMode;
914 theOutputMode &= ~theMode;
917 void SetDisplayEntity(int theCommandID){
918 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
919 SALOME_ListIO selected;
921 aSel->selectedObjects( selected );
923 if(selected.Extent() >= 1){
924 SALOME_ListIteratorOfListIO It( selected );
925 for( ; It.More(); It.Next()){
926 Handle(SALOME_InteractiveObject) IObject = It.Value();
927 if(IObject->hasEntry()){
928 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
929 unsigned int aMode = anActor->GetEntityMode();
930 switch(theCommandID){
931 case SMESHOp::OpDE0DElements:
932 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
934 case SMESHOp::OpDEEdges:
935 InverseEntityMode(aMode,SMESH_Actor::eEdges);
937 case SMESHOp::OpDEFaces:
938 InverseEntityMode(aMode,SMESH_Actor::eFaces);
940 case SMESHOp::OpDEVolumes:
941 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
943 case SMESHOp::OpDEBalls:
944 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
946 case SMESHOp::OpDEAllEntity:
947 aMode = SMESH_Actor::eAllEntity;
951 anActor->SetEntityMode(aMode);
960 SALOME_ListIO selected;
961 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
965 LightApp_SelectionMgr* aSel = app->selectionMgr();
966 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
967 if( !aSel || !appStudy )
970 aSel->selectedObjects( selected );
971 if( selected.IsEmpty() )
974 Handle(SALOME_InteractiveObject) anIObject = selected.First();
976 _PTR(Study) aStudy = appStudy->studyDS();
977 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
978 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
979 if( aMainObject->_is_nil() )
982 SUIT_OverrideCursor wc;
984 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
986 QList<SALOMEDS::Color> aReservedColors;
988 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
989 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
991 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
992 //SALOMEDS::Color aColor = aGroupObject->GetColor();
994 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
995 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
996 #else // old algorithm for auto-colors
997 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
998 aReservedColors.append( aColor );
999 #endif // SIMPLE_AUTOCOLOR
1000 aGroupObject->SetColor( aColor );
1002 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1003 if (aGroupSObject) {
1006 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1007 switch ( aGroupObject->GetType ()) {
1009 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1011 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1013 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1015 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1017 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1018 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1021 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1022 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1028 SMESH::RepaintCurrentView();
1031 void OverallMeshQuality() {
1032 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1033 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1034 SALOME_ListIO selected;
1036 aSel->selectedObjects( selected );
1038 if ( selected.IsEmpty() ) return;
1039 SALOME_ListIteratorOfListIO It( selected );
1040 for ( ; It.More(); It.Next() ) {
1041 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1042 ctrlDlg->showInfo( It.Value() );
1047 QString functorToString( SMESH::Controls::FunctorPtr f )
1049 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1050 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1051 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1052 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1053 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1054 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1055 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1056 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1057 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1058 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1059 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1060 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1061 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1062 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1063 type = QObject::tr( "WARP_ELEMENTS" );
1064 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1065 type = QObject::tr( "TAPER_ELEMENTS" );
1066 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1067 type = QObject::tr( "SKEW_ELEMENTS" );
1068 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1069 type = QObject::tr( "AREA_ELEMENTS" );
1070 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1071 type = QObject::tr( "LENGTH_EDGES" );
1072 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1073 type = QObject::tr( "LENGTH2D_EDGES" );
1074 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1075 type = QObject::tr( "MULTI_BORDERS" );
1076 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1077 type = QObject::tr( "MULTI2D_BORDERS" );
1078 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1079 type = QObject::tr( "FREE_NODES" );
1080 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1081 type = QObject::tr( "FREE_EDGES" );
1082 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1083 type = QObject::tr( "FREE_BORDERS" );
1084 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1085 type = QObject::tr( "FREE_FACES" );
1086 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1087 type = QObject::tr( "BARE_BORDER_VOLUME" );
1088 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1089 type = QObject::tr( "BARE_BORDER_FACE" );
1090 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1091 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1092 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1093 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1094 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1095 type = QObject::tr( "EQUAL_NODE" );
1096 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1097 type = QObject::tr( "EQUAL_EDGE" );
1098 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1099 type = QObject::tr( "EQUAL_FACE" );
1100 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1101 type = QObject::tr( "EQUAL_VOLUME" );
1105 void SaveDistribution()
1107 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1108 SALOME_ListIO selected;
1110 aSel->selectedObjects( selected );
1112 if ( selected.Extent() == 1 ) {
1113 Handle(SALOME_InteractiveObject) anIO = selected.First();
1114 if ( anIO->hasEntry() ) {
1115 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1116 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1117 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1118 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1119 if ( aScalarBarActor && aFunctor ) {
1120 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1122 std::vector<int> elements;
1123 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1124 if ( mesh->_is_nil() ) {
1125 SMESH::SMESH_IDSource_var idSource =
1126 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1127 if ( !idSource->_is_nil() )
1129 SMESH::long_array_var ids = idSource->GetIDs();
1130 elements.resize( ids->length() );
1131 for ( unsigned i = 0; i < elements.size(); ++i )
1132 elements[i] = ids[i];
1135 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1136 vtkLookupTable* lookupTable =
1137 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1138 double * minmax = lookupTable->GetRange();
1139 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1140 std::vector<int> nbEvents;
1141 std::vector<double> funValues;
1142 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
1143 QString anInitialPath = "";
1144 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1145 anInitialPath = QDir::currentPath();
1146 QString aMeshName = anIO->getName();
1148 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1149 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1150 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1151 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1152 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1155 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1157 if ( !aFilename.isEmpty() ) {
1158 QFile f( aFilename );
1159 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1160 QTextStream out( &f );
1161 out << "# Mesh: " << aMeshName << endl;
1162 out << "# Control: " << functorToString( aFunctor ) << endl;
1164 out.setFieldWidth( 10 );
1165 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1166 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1177 void ShowDistribution() {
1178 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1179 SALOME_ListIO selected;
1181 aSel->selectedObjects( selected );
1183 if ( selected.Extent() == 1 ) {
1184 Handle(SALOME_InteractiveObject) anIO = selected.First();
1185 if ( anIO->hasEntry() ) {
1186 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1187 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1188 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1189 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1195 #ifndef DISABLE_PLOT2DVIEWER
1196 void PlotDistribution() {
1197 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1201 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1202 SALOME_ListIO selected;
1204 aSel->selectedObjects( selected );
1206 if ( selected.Extent() == 1 ) {
1207 Handle(SALOME_InteractiveObject) anIO = selected.First();
1208 if ( anIO->hasEntry() ) {
1209 //Find Actor by entry before getting Plot2d viewer,
1210 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1211 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1213 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1218 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1222 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1226 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1227 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1228 QString functorName = functorToString( anActor->GetFunctor());
1229 QString aHistogramName("%1 : %2");
1230 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1231 aHistogram->setName(aHistogramName);
1232 aHistogram->setHorTitle(functorName);
1233 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1234 aPlot->displayObject(aHistogram, true);
1239 #endif //DISABLE_PLOT2DVIEWER
1241 void DisableAutoColor(){
1242 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1243 SALOME_ListIO selected;
1245 aSel->selectedObjects( selected );
1247 if(selected.Extent()){
1248 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1249 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1250 if ( !aMesh->_is_nil() ) {
1251 aMesh->SetAutoColor( false );
1256 void sortChildren(){
1257 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1258 SALOME_ListIO selected;
1260 aSel->selectedObjects( selected );
1262 if(selected.Extent()){
1263 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1264 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1265 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1267 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1268 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1275 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1277 SALOME_ListIO selected;
1278 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1282 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1283 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1284 if( !aSel || !appStudy )
1287 if( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1288 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1289 aModule->EmitSignalDeactivateDialog();
1290 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1291 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1296 _PTR(Study) aStudy = appStudy->studyDS();
1298 aSel->selectedObjects( selected );
1300 if(selected.Extent() >= 1){
1301 switch(theCommandID){
1302 case SMESHOp::OpTransparency:{
1303 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1304 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1307 case SMESHOp::OpProperties: {
1309 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1310 QColor orientationColor, outlineColor, volumeColor;
1311 int deltaF = 0, deltaV = 0;
1314 double ballScale = 1.0;
1316 int outlineWidth = 1;
1317 double shrinkCoef = 0.0;
1318 double orientationScale = 0.0;
1319 bool orientation3d = false;
1320 VTK::MarkerType markerType = VTK::MT_NONE;
1321 VTK::MarkerScale markerScale = VTK::MS_NONE;
1323 bool hasNodes = false;
1324 int presentEntities = 0;
1325 bool firstTime = true;
1327 SALOME_ListIteratorOfListIO It( selected );
1328 for ( ; It.More(); It.Next() ) {
1329 Handle(SALOME_InteractiveObject) IObject = It.Value();
1330 if ( !IObject->hasEntry() ) continue;
1331 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1332 if ( !anActor || !anActor->GetObject() ) continue;
1335 // nodes: color, marker
1336 anActor->GetNodeColor( color[0], color[1], color[2] );
1337 nodeColor.setRgbF( color[0], color[1], color[2] );
1338 markerType = anActor->GetMarkerType();
1339 markerScale = anActor->GetMarkerScale();
1340 markerId = anActor->GetMarkerTexture();
1341 // edges: color, width
1342 anActor->GetEdgeColor( color[0], color[1], color[2] );
1343 edgeColor.setRgbF( color[0], color[1], color[2] );
1344 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1345 // faces: front color, back color (delta)
1346 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1347 faceColor.setRgbF( color[0], color[1], color[2] );
1348 // faces: front color, back color (delta)
1349 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1350 volumeColor.setRgbF( color[0], color[1], color[2] );
1351 // 0d elements: color, size
1352 anActor->Get0DColor( color[0], color[1], color[2] );
1353 elem0dColor.setRgbF( color[0], color[1], color[2] );
1354 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1355 // balls: color, size
1356 anActor->GetBallColor( color[0], color[1], color[2] );
1357 ballColor.setRgbF( color[0], color[1], color[2] );
1358 ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1359 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1361 anActor->GetOutlineColor( color[0], color[1], color[2] );
1362 outlineColor.setRgbF( color[0], color[1], color[2] );
1363 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1364 // orientation vectors: color, scale, 3d flag
1365 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1366 orientationColor.setRgbF( color[0], color[1], color[2] );
1367 orientationScale = anActor->GetFacesOrientationScale();
1368 orientation3d = anActor->GetFacesOrientation3DVectors();
1370 shrinkCoef = anActor->GetShrinkFactor();
1373 firstTime = false; // we only take properties from first object (for performance reasons)
1376 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1377 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1378 presentEntities = presentEntities | SMESH_Actor::eEdges;
1379 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1380 presentEntities = presentEntities | SMESH_Actor::eFaces;
1381 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1382 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1383 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1384 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1385 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1386 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1388 // as we know that all types of elements are present, we can exit the loop
1389 if ( presentEntities == SMESH_Actor::eAllEntity )
1393 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1394 // nodes: color, marker
1395 dlg.setNodeColor( nodeColor );
1396 if( markerType != VTK::MT_USER )
1397 dlg.setNodeMarker( markerType, markerScale );
1399 dlg.setNodeCustomMarker( markerId );
1400 // edges: color, line width
1401 dlg.setEdgeColor( edgeColor );
1402 dlg.setEdgeWidth( edgeWidth );
1403 // faces: front color, back color
1404 dlg.setFaceColor( faceColor, deltaF );
1405 // volumes: normal color, reversed color
1406 dlg.setVolumeColor( volumeColor, deltaV );
1407 // outlines: color, line width
1408 dlg.setOutlineColor( outlineColor );
1409 dlg.setOutlineWidth( outlineWidth );
1410 // 0d elements: color, size
1411 dlg.setElem0dColor( elem0dColor );
1412 dlg.setElem0dSize( elem0dSize );
1413 // balls: color, size
1414 dlg.setBallColor( ballColor );
1415 dlg.setBallSize( ballSize );
1416 dlg.setBallScale( ballScale );
1417 // orientation: color, scale, 3d flag
1418 dlg.setOrientationColor( orientationColor );
1419 dlg.setOrientationSize( int( orientationScale * 100. ) );
1420 dlg.setOrientation3d( orientation3d );
1421 // shrink: scale factor
1422 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1423 // hide unused controls
1424 dlg.showControls( presentEntities, hasNodes );
1427 nodeColor = dlg.nodeColor();
1428 markerType = dlg.nodeMarkerType();
1429 markerScale = dlg.nodeMarkerScale();
1430 markerId = dlg.nodeMarkerId();
1431 edgeColor = dlg.edgeColor();
1432 edgeWidth = dlg.edgeWidth();
1433 faceColor = dlg.faceColor();
1434 deltaF = dlg.faceColorDelta();
1435 volumeColor = dlg.volumeColor();
1436 deltaV = dlg.volumeColorDelta();
1437 outlineColor = dlg.outlineColor();
1438 outlineWidth = dlg.outlineWidth();
1439 elem0dColor = dlg.elem0dColor();
1440 elem0dSize = dlg.elem0dSize();
1441 ballColor = dlg.ballColor();
1442 ballSize = dlg.ballSize();
1443 ballScale = dlg.ballScale();
1444 orientationColor = dlg.orientationColor();
1445 orientationScale = dlg.orientationSize() / 100.;
1446 orientation3d = dlg.orientation3d();
1447 shrinkCoef = dlg.shrinkCoef() / 100.;
1449 // store point markers map that might be changed by the user
1450 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1452 // set properties from dialog box to the presentations
1453 SALOME_ListIteratorOfListIO It( selected );
1454 for ( ; It.More(); It.Next() ) {
1455 Handle(SALOME_InteractiveObject) IObject = It.Value();
1456 if ( !IObject->hasEntry() ) continue;
1457 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1458 if ( !anActor ) continue;
1460 // nodes: color, marker
1461 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1462 if ( markerType != VTK::MT_USER ) {
1463 anActor->SetMarkerStd( markerType, markerScale );
1466 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1467 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1468 if ( iter != markerMap.end() )
1469 anActor->SetMarkerTexture( markerId, iter->second.second );
1471 // volumes: normal color, reversed color (delta)
1472 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1473 // faces: front color, back color (delta)
1474 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1475 // edges: color, width
1476 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1477 anActor->SetLineWidth( edgeWidth );
1479 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1480 anActor->SetOutlineWidth( outlineWidth );
1481 // 0D elements: color, size
1482 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1483 anActor->Set0DSize( elem0dSize );
1484 // balls: color, size
1485 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1486 anActor->SetBallSize( ballSize );
1487 anActor->SetBallScale( ballScale );
1488 // orientation: color, scale, 3d flag
1489 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1490 anActor->SetFacesOrientationScale( orientationScale );
1491 anActor->SetFacesOrientation3DVectors( orientation3d );
1493 anActor->SetShrinkFactor( shrinkCoef );
1495 // for groups, set also proper color
1496 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1497 if ( !aGroupObject->_is_nil() ) {
1498 SMESH::ElementType anElementType = aGroupObject->GetType();
1500 switch( anElementType ) {
1502 aColor = nodeColor; break;
1504 aColor = edgeColor; break;
1506 aColor = faceColor; break;
1508 aColor = volumeColor; break;
1510 aColor = elem0dColor; break;
1512 aColor = ballColor; break;
1516 if ( aColor.isValid() ) {
1517 SALOMEDS::Color aGroupColor;
1518 aGroupColor.R = aColor.redF();
1519 aGroupColor.G = aColor.greenF();
1520 aGroupColor.B = aColor.blueF();
1521 aGroupObject->SetColor( aGroupColor );
1523 } // if ( !aGroupObject->_is_nil() )
1524 } // for ( ; It.More(); It.Next() )
1525 SMESH::RepaintCurrentView();
1526 } // if ( dlg.exec() )
1528 } // case SMESHOp::OpProperties:
1529 } // switch(theCommandID)
1530 SALOME_ListIteratorOfListIO It( selected );
1531 for( ; It.More(); It.Next()){
1532 Handle(SALOME_InteractiveObject) IObject = It.Value();
1533 if(IObject->hasEntry()){
1534 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1535 switch(theCommandID){
1536 case SMESHOp::OpDMWireframe:
1537 anActor->SetRepresentation(SMESH_Actor::eEdge);
1539 case SMESHOp::OpDMShading:
1540 anActor->SetRepresentation(SMESH_Actor::eSurface);
1542 case SMESHOp::OpDMShrink:
1543 if(anActor->IsShrunk())
1544 anActor->UnShrink();
1546 anActor->SetShrink();
1548 case SMESHOp::OpDMNodes:
1549 anActor->SetRepresentation(SMESH_Actor::ePoint);
1551 case SMESHOp::OpRepresentationLines:
1552 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1553 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1555 case SMESHOp::OpRepresentationArcs:
1556 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1557 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1563 SMESH::RepaintCurrentView();
1567 void Control( int theCommandID )
1569 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 case SMESHOp::OpOrientationOnFaces:
2521 LightApp_SelectionMgr* mgr = selectionMgr();
2522 SALOME_ListIO selected; mgr->selectedObjects( selected );
2524 SALOME_ListIteratorOfListIO it(selected);
2525 for( ; it.More(); it.Next()) {
2526 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2527 if(anIObject->hasEntry()) {
2528 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2529 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2536 case SMESHOp::OpUpdate:
2538 if(checkLock(aStudy)) break;
2539 SUIT_OverrideCursor wc;
2541 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2544 SMESH::UpdateView();
2546 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2547 SMESH::OnVisuException();
2549 catch (...) { // PAL16774 (Crash after display of many groups)
2550 SMESH::OnVisuException();
2554 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2555 aSel->selectedObjects( l );
2556 aSel->setSelectedObjects( l );
2560 case SMESHOp::OpHide:
2561 case SMESHOp::OpShow:
2562 case SMESHOp::OpShowOnly:
2564 SMESH::EDisplaing anAction;
2565 switch (theCommandID) {
2566 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2567 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2568 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2571 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2572 SALOME_ListIO sel_objects, to_process;
2574 aSel->selectedObjects( sel_objects );
2576 if( theCommandID==SMESHOp::OpShowOnly )
2578 MESSAGE("anAction = SMESH::eDisplayOnly");
2579 startOperation( myEraseAll );
2582 extractContainers( sel_objects, to_process );
2585 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2589 SALOME_ListIteratorOfListIO It( to_process );
2590 for ( ; It.More(); It.Next()) {
2592 Handle(SALOME_InteractiveObject) IOS = It.Value();
2593 if (IOS->hasEntry()) {
2595 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2596 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2597 break; // PAL16774 (Crash after display of many groups)
2599 if (anAction == SMESH::eDisplayOnly)
2601 MESSAGE("anAction = SMESH::eDisplayOnly");
2602 anAction = SMESH::eDisplay;
2608 // PAL13338 + PAL15161 -->
2609 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2610 MESSAGE("anAction = SMESH::eDisplayOnly");
2611 SMESH::UpdateView();
2612 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2614 // PAL13338 + PAL15161 <--
2616 catch (...) { // PAL16774 (Crash after display of many groups)
2617 SMESH::OnVisuException();
2620 if (anAction == SMESH::eErase) {
2621 MESSAGE("anAction == SMESH::eErase");
2623 aSel->setSelectedObjects( l1 );
2626 aSel->setSelectedObjects( to_process );
2631 case SMESHOp::OpNode:
2633 if(checkLock(aStudy)) break;
2636 EmitSignalDeactivateDialog();
2638 ( new SMESHGUI_NodesDlg( this ) )->show();
2641 SUIT_MessageBox::warning(desktop(),
2642 tr("SMESH_WRN_WARNING"),
2643 tr("SMESH_WRN_VIEWER_VTK"));
2648 case SMESHOp::OpCreateMesh:
2649 case SMESHOp::OpCreateSubMesh:
2650 case SMESHOp::OpEditMeshOrSubMesh:
2651 case SMESHOp::OpCompute:
2652 case SMESHOp::OpPreCompute:
2653 case SMESHOp::OpEvaluate:
2654 case SMESHOp::OpMeshOrder:
2655 startOperation( theCommandID );
2657 case SMESHOp::OpCopyMesh:
2659 if (checkLock(aStudy)) break;
2660 EmitSignalDeactivateDialog();
2661 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2664 case SMESHOp::OpBuildCompoundMesh:
2666 if (checkLock(aStudy)) break;
2667 EmitSignalDeactivateDialog();
2668 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2672 case SMESHOp::OpDiagonalInversion:
2673 case SMESHOp::OpUnionOfTwoTriangle:
2677 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2678 tr( "NOT_A_VTK_VIEWER" ) );
2682 if ( checkLock( aStudy ) )
2685 /*Standard_Boolean aRes;
2686 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2687 if ( aMesh->_is_nil() )
2689 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2690 tr( "SMESH_BAD_SELECTION" ) );
2694 EmitSignalDeactivateDialog();
2695 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2696 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2698 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2701 case SMESHOp::OpOrientation:
2702 case SMESHOp::OpUnionOfTriangles:
2703 case SMESHOp::OpCuttingOfQuadrangles:
2704 case SMESHOp::OpSplitVolumes:
2708 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2709 tr( "NOT_A_VTK_VIEWER" ) );
2713 if ( checkLock( aStudy ) )
2716 EmitSignalDeactivateDialog();
2717 SMESHGUI_MultiEditDlg* aDlg = NULL;
2718 if ( theCommandID == SMESHOp::OpOrientation )
2719 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2720 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2721 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2722 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2723 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2725 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2730 case SMESHOp::OpSmoothing:
2732 if(checkLock(aStudy)) break;
2734 EmitSignalDeactivateDialog();
2735 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2738 SUIT_MessageBox::warning(desktop(),
2739 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2743 case SMESHOp::OpExtrusion:
2745 if (checkLock(aStudy)) break;
2747 EmitSignalDeactivateDialog();
2748 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2750 SUIT_MessageBox::warning(desktop(),
2751 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2755 case SMESHOp::OpExtrusionAlongAPath:
2757 if (checkLock(aStudy)) break;
2759 EmitSignalDeactivateDialog();
2760 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2762 SUIT_MessageBox::warning(desktop(),
2763 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2767 case SMESHOp::OpRevolution:
2769 if(checkLock(aStudy)) break;
2771 EmitSignalDeactivateDialog();
2772 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2775 SUIT_MessageBox::warning(desktop(),
2776 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2780 case SMESHOp::OpPatternMapping:
2782 if ( checkLock( aStudy ) )
2786 EmitSignalDeactivateDialog();
2787 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2790 SUIT_MessageBox::warning(desktop(),
2791 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2795 case SMESHOp::OpConvertMeshToQuadratic:
2796 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2797 case SMESHOp::OpReorientFaces:
2798 case SMESHOp::OpCreateGeometryGroup:
2800 startOperation( theCommandID );
2803 case SMESHOp::OpCreateGroup:
2807 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2808 tr( "NOT_A_VTK_VIEWER" ) );
2812 if(checkLock(aStudy)) break;
2813 EmitSignalDeactivateDialog();
2814 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2816 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2817 SALOME_ListIO selected;
2819 aSel->selectedObjects( selected );
2821 int nbSel = selected.Extent();
2823 // check if mesh is selected
2824 aMesh = SMESH::GetMeshByIO( selected.First() );
2826 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2831 case SMESHOp::OpConstructGroup:
2835 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2836 tr( "NOT_A_VTK_VIEWER" ) );
2840 if(checkLock(aStudy)) break;
2841 EmitSignalDeactivateDialog();
2843 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2844 SALOME_ListIO selected;
2846 aSel->selectedObjects( selected );
2848 int nbSel = selected.Extent();
2850 // check if submesh is selected
2851 Handle(SALOME_InteractiveObject) IObject = selected.First();
2852 if (IObject->hasEntry()) {
2853 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2855 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2856 if (!aSubMesh->_is_nil()) {
2858 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2859 // get submesh elements list by types
2860 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2861 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2862 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2863 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2864 // create group for each type o elements
2865 QString aName = IObject->getName();
2866 QStringList anEntryList;
2867 if (aNodes->length() > 0) {
2868 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2869 aGroup->Add(aNodes.inout());
2870 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2871 anEntryList.append( aSObject->GetID().c_str() );
2873 if (aEdges->length() > 0) {
2874 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2875 aGroup->Add(aEdges.inout());
2876 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2877 anEntryList.append( aSObject->GetID().c_str() );
2879 if (aFaces->length() > 0) {
2880 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2881 aGroup->Add(aFaces.inout());
2882 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2883 anEntryList.append( aSObject->GetID().c_str() );
2885 if (aVolumes->length() > 0) {
2886 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2887 aGroup->Add(aVolumes.inout());
2888 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2889 anEntryList.append( aSObject->GetID().c_str() );
2892 anApp->browseObjects( anEntryList );
2894 catch(const SALOME::SALOME_Exception & S_ex){
2895 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2902 SUIT_MessageBox::warning(desktop(),
2903 tr("SMESH_WRN_WARNING"),
2904 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2909 case SMESHOp::OpEditGroup:
2913 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2914 tr( "NOT_A_VTK_VIEWER" ) );
2918 if(checkLock(aStudy)) break;
2919 EmitSignalDeactivateDialog();
2921 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2922 SALOME_ListIO selected;
2924 aSel->selectedObjects( selected );
2926 SALOME_ListIteratorOfListIO It (selected);
2927 int nbSelectedGroups = 0;
2928 for ( ; It.More(); It.Next() )
2930 SMESH::SMESH_GroupBase_var aGroup =
2931 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2932 if (!aGroup->_is_nil()) {
2934 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2938 if (nbSelectedGroups == 0)
2940 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2946 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
2948 if(checkLock(aStudy)) break;
2949 if (myState == 800) {
2950 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2951 if (aDlg) aDlg->onAdd();
2956 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
2958 if(checkLock(aStudy)) break;
2959 if (myState == 800) {
2960 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2961 if (aDlg) aDlg->onRemove();
2966 case SMESHOp::OpEditGeomGroupAsGroup:
2970 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2971 tr( "NOT_A_VTK_VIEWER" ) );
2975 if(checkLock(aStudy)) break;
2976 EmitSignalDeactivateDialog();
2978 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2979 SALOME_ListIO selected;
2981 aSel->selectedObjects( selected );
2983 SALOME_ListIteratorOfListIO It (selected);
2984 for ( ; It.More(); It.Next() )
2986 SMESH::SMESH_GroupOnGeom_var aGroup =
2987 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2988 if (!aGroup->_is_nil()) {
2989 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2994 SMESH::SMESH_GroupOnFilter_var aGroup =
2995 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2996 if (!aGroup->_is_nil()) {
2997 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3005 case SMESHOp::OpUnionGroups:
3006 case SMESHOp::OpIntersectGroups:
3007 case SMESHOp::OpCutGroups:
3011 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3012 tr( "NOT_A_VTK_VIEWER" ) );
3016 if ( checkLock( aStudy ) )
3019 EmitSignalDeactivateDialog();
3021 SMESHGUI_GroupOpDlg* aDlg = 0;
3022 if ( theCommandID == SMESHOp::OpUnionGroups )
3023 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3024 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3025 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3027 aDlg = new SMESHGUI_CutGroupsDlg( this );
3034 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3036 if ( checkLock( aStudy ) )
3039 EmitSignalDeactivateDialog();
3040 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3046 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3050 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3051 tr( "NOT_A_VTK_VIEWER" ) );
3055 if ( checkLock( aStudy ) )
3058 EmitSignalDeactivateDialog();
3060 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3064 case SMESHOp::OpMeshInformation:
3065 case SMESHOp::OpWhatIs:
3067 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3068 EmitSignalDeactivateDialog();
3069 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3070 SALOME_ListIO selected;
3072 aSel->selectedObjects( selected );
3074 if ( selected.Extent() > 1 ) { // a dlg for each IO
3075 SALOME_ListIteratorOfListIO It( selected );
3076 for ( ; It.More(); It.Next() ) {
3077 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3078 dlg->showInfo( It.Value() );
3083 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3089 case SMESHOp::OpFindElementByPoint:
3091 startOperation( theCommandID );
3095 case SMESHOp::OpEditHypothesis:
3097 if(checkLock(aStudy)) break;
3099 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3100 SALOME_ListIO selected;
3102 aSel->selectedObjects( selected );
3104 int nbSel = selected.Extent();
3107 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3108 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3110 if ( !aHypothesis->_is_nil() )
3112 SMESHGUI_GenericHypothesisCreator* aCreator =
3113 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3116 // set geometry of mesh and sub-mesh to aCreator
3117 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3118 if ( selected.Extent() == 1 )
3120 QString subGeomID, meshGeomID;
3121 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3122 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3124 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3125 aCreator->setShapeEntry( subGeomID );
3126 aCreator->setMainShapeEntry( meshGeomID );
3130 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3140 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3142 if(checkLock(aStudy)) break;
3143 SUIT_OverrideCursor wc;
3145 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3146 SALOME_ListIO selected;
3148 aSel->selectedObjects( selected, QString::null, false );
3150 SALOME_ListIteratorOfListIO It(selected);
3151 for (int i = 0; It.More(); It.Next(), i++) {
3152 Handle(SALOME_InteractiveObject) IObject = It.Value();
3153 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3156 aSel->setSelectedObjects( l1 );
3161 case SMESHOp::OpElem0D:
3162 case SMESHOp::OpBall:
3163 case SMESHOp::OpEdge:
3164 case SMESHOp::OpTriangle:
3165 case SMESHOp::OpQuadrangle:
3166 case SMESHOp::OpPolygon:
3167 case SMESHOp::OpTetrahedron:
3168 case SMESHOp::OpHexahedron:
3169 case SMESHOp::OpPentahedron:
3170 case SMESHOp::OpPyramid:
3171 case SMESHOp::OpHexagonalPrism:
3173 if(checkLock(aStudy)) break;
3175 EmitSignalDeactivateDialog();
3176 SMDSAbs_EntityType type = SMDSEntity_Edge;
3177 switch (theCommandID) {
3178 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3179 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3180 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3181 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3182 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3183 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3184 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3185 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3186 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3187 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3190 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3193 SUIT_MessageBox::warning(desktop(),
3194 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3198 case SMESHOp::OpPolyhedron:
3200 if(checkLock(aStudy)) break;
3202 EmitSignalDeactivateDialog();
3203 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3206 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3207 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3211 case SMESHOp::OpQuadraticEdge:
3212 case SMESHOp::OpQuadraticTriangle:
3213 case SMESHOp::OpBiQuadraticTriangle:
3214 case SMESHOp::OpQuadraticQuadrangle:
3215 case SMESHOp::OpBiQuadraticQuadrangle:
3216 case SMESHOp::OpQuadraticTetrahedron:
3217 case SMESHOp::OpQuadraticPyramid:
3218 case SMESHOp::OpQuadraticPentahedron:
3219 case SMESHOp::OpQuadraticHexahedron:
3220 case SMESHOp::OpTriQuadraticHexahedron:
3222 if(checkLock(aStudy)) break;
3224 EmitSignalDeactivateDialog();
3225 SMDSAbs_EntityType type = SMDSEntity_Last;
3227 switch (theCommandID) {
3228 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3229 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3230 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3231 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3232 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3233 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3234 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3235 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3236 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3237 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3240 if ( type != SMDSEntity_Last )
3241 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3244 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3245 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3249 case SMESHOp::OpRemoveNodes:
3251 if(checkLock(aStudy)) break;
3253 EmitSignalDeactivateDialog();
3254 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3257 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3258 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3262 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3264 if(checkLock(aStudy)) break;
3266 EmitSignalDeactivateDialog();
3267 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3271 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3272 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3276 case SMESHOp::OpClearMesh: {
3278 if(checkLock(aStudy)) break;
3280 SALOME_ListIO selected;
3281 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3282 aSel->selectedObjects( selected );
3284 SUIT_OverrideCursor wc;
3285 SALOME_ListIteratorOfListIO It (selected);
3286 for ( ; It.More(); It.Next() )
3288 Handle(SALOME_InteractiveObject) IOS = It.Value();
3289 SMESH::SMESH_Mesh_var aMesh =
3290 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3291 if ( aMesh->_is_nil()) continue;
3293 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3295 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3296 SMESH::ModifiedMesh( aMeshSObj, false, true);
3297 // hide groups and submeshes
3298 _PTR(ChildIterator) anIter =
3299 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3300 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3302 _PTR(SObject) so = anIter->Value();
3303 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3306 catch (const SALOME::SALOME_Exception& S_ex){
3308 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3312 SMESH::UpdateView();
3316 case SMESHOp::OpRemoveOrphanNodes:
3318 if(checkLock(aStudy)) break;
3319 SALOME_ListIO selected;
3320 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3321 aSel->selectedObjects( selected );
3322 if ( selected.Extent() == 1 ) {
3323 Handle(SALOME_InteractiveObject) anIO = selected.First();
3324 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3325 if ( !aMesh->_is_nil() ) {
3326 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3327 tr( "SMESH_WARNING" ),
3328 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3329 SUIT_MessageBox::Yes |
3330 SUIT_MessageBox::No,
3331 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3334 SUIT_OverrideCursor wc;
3335 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3336 int removed = aMeshEditor->RemoveOrphanNodes();
3337 SUIT_MessageBox::information(SMESHGUI::desktop(),
3338 tr("SMESH_INFORMATION"),
3339 tr("NB_NODES_REMOVED").arg(removed));
3340 if ( removed > 0 ) {
3341 SMESH::UpdateView();
3342 SMESHGUI::Modified();
3345 catch (const SALOME::SALOME_Exception& S_ex) {
3346 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3355 case SMESHOp::OpRenumberingNodes:
3357 if(checkLock(aStudy)) break;
3359 EmitSignalDeactivateDialog();
3360 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3364 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3365 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3369 case SMESHOp::OpRenumberingElements:
3371 if(checkLock(aStudy)) break;
3373 EmitSignalDeactivateDialog();
3374 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3378 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3379 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3383 case SMESHOp::OpTranslation:
3385 if(checkLock(aStudy)) break;
3387 EmitSignalDeactivateDialog();
3388 ( new SMESHGUI_TranslationDlg( this ) )->show();
3391 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3392 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3396 case SMESHOp::OpRotation:
3398 if(checkLock(aStudy)) break;
3400 EmitSignalDeactivateDialog();
3401 ( new SMESHGUI_RotationDlg( this ) )->show();
3404 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3405 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3409 case SMESHOp::OpSymmetry:
3411 if(checkLock(aStudy)) break;
3413 EmitSignalDeactivateDialog();
3414 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3417 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3418 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3422 case SMESHOp::OpScale:
3424 if(checkLock(aStudy)) break;
3426 EmitSignalDeactivateDialog();
3427 ( new SMESHGUI_ScaleDlg( this ) )->show();
3430 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3431 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3436 case SMESHOp::OpSewing:
3438 if(checkLock(aStudy)) break;
3440 EmitSignalDeactivateDialog();
3441 ( new SMESHGUI_SewingDlg( this ) )->show();
3444 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3445 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3449 case SMESHOp::OpMergeNodes:
3451 if(checkLock(aStudy)) break;
3453 EmitSignalDeactivateDialog();
3454 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3457 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3458 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3462 case SMESHOp::OpMergeElements:
3464 if (checkLock(aStudy)) break;
3466 EmitSignalDeactivateDialog();
3467 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3469 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3470 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3475 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3476 startOperation( SMESHOp::OpMoveNode );
3479 case SMESHOp::OpDuplicateNodes:
3481 if(checkLock(aStudy)) break;
3483 EmitSignalDeactivateDialog();
3484 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3487 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3488 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3493 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3494 startOperation( SMESHOp::OpElem0DOnElemNodes );
3497 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3499 static QList<int> aTypes;
3500 if ( aTypes.isEmpty() )
3502 aTypes.append( SMESH::NODE );
3503 aTypes.append( SMESH::EDGE );
3504 aTypes.append( SMESH::FACE );
3505 aTypes.append( SMESH::VOLUME );
3507 if (!myFilterLibraryDlg)
3508 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3509 else if (myFilterLibraryDlg->isHidden())
3510 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3511 myFilterLibraryDlg->raise();
3515 case SMESHOp::OpFreeNode:
3516 case SMESHOp::OpEqualNode:
3517 case SMESHOp::OpFreeEdge:
3518 case SMESHOp::OpFreeBorder:
3519 case SMESHOp::OpLength:
3520 case SMESHOp::OpConnection:
3521 case SMESHOp::OpEqualEdge:
3522 case SMESHOp::OpFreeFace:
3523 case SMESHOp::OpBareBorderFace:
3524 case SMESHOp::OpOverConstrainedFace:
3525 case SMESHOp::OpLength2D:
3526 case SMESHOp::OpConnection2D:
3527 case SMESHOp::OpArea:
3528 case SMESHOp::OpTaper:
3529 case SMESHOp::OpAspectRatio:
3530 case SMESHOp::OpMinimumAngle:
3531 case SMESHOp::OpWarpingAngle:
3532 case SMESHOp::OpSkew:
3533 case SMESHOp::OpMaxElementLength2D:
3534 case SMESHOp::OpEqualFace:
3535 case SMESHOp::OpAspectRatio3D:
3536 case SMESHOp::OpVolume:
3537 case SMESHOp::OpMaxElementLength3D:
3538 case SMESHOp::OpBareBorderVolume:
3539 case SMESHOp::OpOverConstrainedVolume:
3540 case SMESHOp::OpEqualVolume:
3543 LightApp_SelectionMgr* mgr = selectionMgr();
3544 SALOME_ListIO selected; mgr->selectedObjects( selected );
3546 if( !selected.IsEmpty() ) {
3547 SUIT_OverrideCursor wc;
3548 ::Control( theCommandID );
3551 SUIT_MessageBox::warning(desktop(),
3552 tr( "SMESH_WRN_WARNING" ),
3553 tr( "SMESH_BAD_SELECTION" ) );
3557 SUIT_MessageBox::warning(desktop(),
3558 tr( "SMESH_WRN_WARNING" ),
3559 tr( "NOT_A_VTK_VIEWER" ) );
3562 case SMESHOp::OpOverallMeshQuality:
3563 OverallMeshQuality();
3565 case SMESHOp::OpNumberingNodes:
3567 SUIT_OverrideCursor wc;
3568 LightApp_SelectionMgr* mgr = selectionMgr();
3569 SALOME_ListIO selected; mgr->selectedObjects( selected );
3571 SALOME_ListIteratorOfListIO it(selected);
3572 for( ; it.More(); it.Next()) {
3573 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3574 if(anIObject->hasEntry()) {
3575 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3576 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3582 case SMESHOp::OpNumberingElements:
3584 SUIT_OverrideCursor wc;
3585 LightApp_SelectionMgr* mgr = selectionMgr();
3586 SALOME_ListIO selected; mgr->selectedObjects( selected );
3588 SALOME_ListIteratorOfListIO it(selected);
3589 for( ; it.More(); it.Next()) {
3590 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3591 if(anIObject->hasEntry())
3592 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3593 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3598 case SMESHOp::OpPropertiesLength:
3599 case SMESHOp::OpPropertiesArea:
3600 case SMESHOp::OpPropertiesVolume:
3601 case SMESHOp::OpMinimumDistance:
3602 case SMESHOp::OpBoundingBox:
3604 int page = SMESHGUI_MeasureDlg::MinDistance;
3605 if ( theCommandID == SMESHOp::OpBoundingBox )
3606 page = SMESHGUI_MeasureDlg::BoundingBox;
3607 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3608 page = SMESHGUI_MeasureDlg::Length;
3609 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3610 page = SMESHGUI_MeasureDlg::Area;
3611 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3612 page = SMESHGUI_MeasureDlg::Volume;
3614 EmitSignalDeactivateDialog();
3615 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3619 case SMESHOp::OpSortChild:
3625 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3626 //updateObjBrowser();
3630 //=============================================================================
3634 //=============================================================================
3635 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3640 //=============================================================================
3644 //=============================================================================
3645 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3650 //=============================================================================
3654 //=============================================================================
3655 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3660 //=============================================================================
3661 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3662 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3664 //=============================================================================
3665 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3666 SUIT_ViewWindow* wnd )
3668 if(theIO->hasEntry()){
3669 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3670 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3674 //=======================================================================
3675 // function : createSMESHAction
3677 //=======================================================================
3678 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3679 const int key, const bool toggle, const QString& shortcutAction )
3682 QWidget* parent = application()->desktop();
3683 SUIT_ResourceMgr* resMgr = resourceMgr();
3685 if ( !icon_id.isEmpty() )
3686 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3688 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3689 if ( !pix.isNull() )
3690 icon = QIcon( pix );
3692 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3693 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3694 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3696 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3697 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3700 //=======================================================================
3701 // function : createPopupItem
3703 //=======================================================================
3704 void SMESHGUI::createPopupItem( const int id,
3705 const QString& clients,
3706 const QString& types,
3707 const QString& theRule,
3710 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3711 popupMgr()->insert( action( id ), pId, 0 );
3713 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3714 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3715 QString rule = "(%1) and (%2) and (%3)";
3716 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3717 if( clients.isEmpty() )
3718 rule = rule.arg( QString( "true" ) );
3720 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3721 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3724 bool cont = myRules.contains( id );
3726 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3728 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3729 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3732 //=======================================================================
3733 // function : initialize
3735 //=======================================================================
3736 void SMESHGUI::initialize( CAM_Application* app )
3738 SalomeApp_Module::initialize( app );
3740 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3742 /* Automatic Update flag */
3743 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3745 // ----- create actions --------------
3747 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3748 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3749 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3750 //createSMESHAction( 114, "NUM" );
3751 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3753 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3755 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3756 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3757 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3758 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3759 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3760 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3762 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3764 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3765 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3766 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3767 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3768 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3769 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3771 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3773 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3774 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3775 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3776 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3777 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3778 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3779 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3780 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3781 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3782 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3783 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3784 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3785 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_COMPUTE" );
3786 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_COMPUTE" );
3787 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3788 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3789 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3790 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3791 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3792 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3793 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3794 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3795 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3796 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3797 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3798 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3799 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3800 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3801 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3802 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3804 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3805 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3806 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3807 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3808 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3809 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3810 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3811 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3812 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3813 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3814 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3815 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3816 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3817 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3818 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3819 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3820 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3821 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3822 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3823 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3824 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3825 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3826 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3827 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3828 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3829 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3830 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3832 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3833 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3834 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3835 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3836 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3837 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3838 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3839 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3840 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3841 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3842 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3843 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3844 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3845 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3846 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3847 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3848 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3849 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3850 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3851 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3852 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3853 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3854 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3855 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3857 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3858 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3859 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3860 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3862 createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3863 createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3865 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3866 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3867 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3868 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3869 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3870 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3871 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3872 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3873 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3874 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3875 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3876 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3877 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3878 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3879 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3880 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3881 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3882 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3883 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3884 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3885 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3886 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3887 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3889 createSMESHAction( SMESHOp::OpReset, "RESET" );
3890 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3891 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3892 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3893 #ifndef DISABLE_PLOT2DVIEWER
3894 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3896 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3897 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3898 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3899 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3900 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3901 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3902 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3903 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3904 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3905 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3906 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL" );
3907 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3909 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3910 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3912 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3913 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3914 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3915 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3916 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3917 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3918 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3919 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3920 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3922 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3923 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3924 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3925 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3926 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
3928 createSMESHAction( SMESHOp::OpHide, "HIDE" );
3929 createSMESHAction( SMESHOp::OpShow, "SHOW" );
3930 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
3932 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
3934 QList<int> aCtrlActions;
3935 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode // node controls
3936 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
3937 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
3938 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
3939 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
3940 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
3941 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
3942 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
3943 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
3944 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
3945 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
3946 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
3947 aCtrlGroup->setExclusive( true );
3948 for( int i = 0; i < aCtrlActions.size(); i++ )
3949 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
3951 // ----- create menu --------------
3952 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3953 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3954 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3955 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3956 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3957 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3958 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3959 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3961 createMenu( separator(), fileId );
3963 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3964 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3965 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3966 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3967 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3968 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3969 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3970 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3971 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3972 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
3973 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
3975 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
3976 createMenu( SMESHOp::OpImportUNV, importId, -1 );
3977 createMenu( SMESHOp::OpImportMED, importId, -1 );
3978 createMenu( SMESHOp::OpImportSTL, importId, -1 );
3980 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
3982 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
3983 createMenu( SMESHOp::OpImportGMF, importId, -1 );
3984 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
3985 createMenu( SMESHOp::OpExportMED, exportId, -1 );
3986 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
3987 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
3989 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
3991 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
3992 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
3993 createMenu( separator(), fileId, 10 );
3995 createMenu( SMESHOp::OpDelete, editId, -1 );
3997 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
3999 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4000 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4001 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4002 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4003 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4004 createMenu( separator(), meshId, -1 );
4005 createMenu( SMESHOp::OpCompute, meshId, -1 );
4006 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4007 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4008 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4009 createMenu( separator(), meshId, -1 );
4010 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4011 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4012 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4013 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4014 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4015 createMenu( separator(), meshId, -1 );
4016 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4017 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4018 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4019 createMenu( separator(), meshId, -1 );
4020 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4021 createMenu( separator(), meshId, -1 );
4022 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4023 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4024 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4025 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4026 createMenu( separator(), meshId, -1 );
4028 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4029 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4030 createMenu( SMESHOp::OpFreeEdge, edgeId, -1 );
4031 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4032 createMenu( SMESHOp::OpLength, edgeId, -1 );
4033 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4034 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4035 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4036 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4037 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4038 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4039 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4040 createMenu( SMESHOp::OpArea, faceId, -1 );
4041 createMenu( SMESHOp::OpTaper, faceId, -1 );
4042 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4043 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4044 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4045 createMenu( SMESHOp::OpSkew, faceId, -1 );
4046 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4047 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4048 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4049 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4050 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4051 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4052 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4053 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4054 createMenu( separator(), ctrlId, -1 );
4055 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4056 createMenu( separator(), ctrlId, -1 );
4057 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4059 createMenu( SMESHOp::OpNode, addId, -1 );
4060 createMenu( SMESHOp::OpElem0D, addId, -1 );
4061 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4062 createMenu( SMESHOp::OpBall, addId, -1 );
4063 createMenu( SMESHOp::OpEdge, addId, -1 );
4064 createMenu( SMESHOp::OpTriangle, addId, -1 );
4065 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4066 createMenu( SMESHOp::OpPolygon, addId, -1 );
4067 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4068 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4069 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4070 createMenu( SMESHOp::OpPyramid, addId, -1 );
4071 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4072 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4073 createMenu( separator(), addId, -1 );
4074 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4075 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4076 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4077 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4078 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4079 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4080 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4081 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4082 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4083 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4085 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4086 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4087 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4088 createMenu( separator(), removeId, -1 );
4089 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4090 createMenu( separator(), removeId, -1 );
4091 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4093 createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4094 createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4096 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4097 createMenu( SMESHOp::OpRotation, transfId, -1 );
4098 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4099 createMenu( SMESHOp::OpScale, transfId, -1 );
4100 createMenu( SMESHOp::OpSewing, transfId, -1 );
4101 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4102 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4103 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4105 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4106 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4107 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4108 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4109 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4110 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4111 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4112 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4113 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4114 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4115 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4116 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4117 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4118 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4119 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4121 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4122 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4123 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4124 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4125 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4126 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4128 // ----- create toolbars --------------
4129 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4130 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4131 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4132 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4133 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4134 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4135 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4136 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4137 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4138 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4139 renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4140 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4141 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4142 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4143 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4145 createTool( SMESHOp::OpCreateMesh, meshTb );
4146 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4147 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4148 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4149 createTool( SMESHOp::OpCopyMesh, meshTb );
4150 createTool( separator(), meshTb );
4151 createTool( SMESHOp::OpCompute, meshTb );
4152 createTool( SMESHOp::OpPreCompute, meshTb );
4153 createTool( SMESHOp::OpEvaluate, meshTb );
4154 createTool( SMESHOp::OpMeshOrder, meshTb );
4156 createTool( SMESHOp::OpCreateGroup, groupTb );
4157 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4158 createTool( SMESHOp::OpConstructGroup, groupTb );
4159 createTool( SMESHOp::OpEditGroup, groupTb );
4161 createTool( SMESHOp::OpMeshInformation, info );
4162 //createTool( SMESHOp::OpStdInfo, meshTb );
4163 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4164 createTool( SMESHOp::OpFindElementByPoint, info );
4166 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4167 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4169 createTool( SMESHOp::OpFreeEdge, ctrl1dTb );
4170 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4171 createTool( SMESHOp::OpLength, ctrl1dTb );
4172 createTool( SMESHOp::OpConnection, ctrl1dTb );
4173 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4175 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4176 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4177 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4178 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4179 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4180 createTool( SMESHOp::OpArea, ctrl2dTb );
4181 createTool( SMESHOp::OpTaper, ctrl2dTb );
4182 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4183 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4184 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4185 createTool( SMESHOp::OpSkew, ctrl2dTb );
4186 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4187 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4189 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4190 createTool( SMESHOp::OpVolume, ctrl3dTb );
4191 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4192 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4193 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4194 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4196 createTool( SMESHOp::OpNode, addElemTb );
4197 createTool( SMESHOp::OpElem0D, addElemTb );
4198 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4199 createTool( SMESHOp::OpBall, addElemTb );
4200 createTool( SMESHOp::OpEdge, addElemTb );
4201 createTool( SMESHOp::OpTriangle, addElemTb );
4202 createTool( SMESHOp::OpQuadrangle, addElemTb );
4203 createTool( SMESHOp::OpPolygon, addElemTb );
4204 createTool( SMESHOp::OpTetrahedron, addElemTb );
4205 createTool( SMESHOp::OpHexahedron, addElemTb );
4206 createTool( SMESHOp::OpPentahedron, addElemTb );
4207 createTool( SMESHOp::OpPyramid, addElemTb );
4208 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4209 createTool( SMESHOp::OpPolyhedron, addElemTb );
4211 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4212 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4213 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4214 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4215 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4216 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4217 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4218 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4219 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4220 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4222 createTool( SMESHOp::OpRemoveNodes, remTb );
4223 createTool( SMESHOp::OpRemoveElements, remTb );
4224 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4225 createTool( SMESHOp::OpClearMesh, remTb );
4227 createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4228 createTool( SMESHOp::OpRenumberingElements, renumbTb );
4230 createTool( SMESHOp::OpTranslation, transformTb );
4231 createTool( SMESHOp::OpRotation, transformTb );
4232 createTool( SMESHOp::OpSymmetry, transformTb );
4233 createTool( SMESHOp::OpScale, transformTb );
4234 createTool( SMESHOp::OpSewing, transformTb );
4235 createTool( SMESHOp::OpMergeNodes, transformTb );
4236 createTool( SMESHOp::OpMergeElements, transformTb );
4237 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4239 createTool( SMESHOp::OpMoveNode, modifyTb );
4240 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4241 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4242 createTool( SMESHOp::OpOrientation, modifyTb );
4243 createTool( SMESHOp::OpReorientFaces, modifyTb );
4244 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4245 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4246 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4247 createTool( SMESHOp::OpSmoothing, modifyTb );
4248 createTool( SMESHOp::OpExtrusion, modifyTb );
4249 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4250 createTool( SMESHOp::OpRevolution, modifyTb );
4251 createTool( SMESHOp::OpPatternMapping, modifyTb );
4252 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4253 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4255 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4257 createTool( SMESHOp::OpUpdate, dispModeTb );
4259 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4260 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4263 QString OB = "'ObjectBrowser'",
4264 View = "'" + SVTK_Viewer::Type() + "'",
4266 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4267 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4268 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4269 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4270 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4271 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4272 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4273 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4274 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4275 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4276 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4278 mesh_part = mesh + " " + subMesh + " " + group,
4279 mesh_group = mesh + " " + group,
4280 hyp_alg = hypo + " " + algo;
4282 // popup for object browser
4284 isInvisible("not( isVisible )"),
4285 isEmpty("numberOfNodes = 0"),
4286 isNotEmpty("numberOfNodes <> 0"),
4288 // has nodes, edges, etc in VISIBLE! actor
4289 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4290 hasElems("(count( elemTypes ) > 0)"),
4291 hasDifferentElems("(count( elemTypes ) > 1)"),
4292 hasBalls("({'BallElem'} in elemTypes)"),
4293 hasElems0d("({'Elem0d'} in elemTypes)"),
4294 hasEdges("({'Edge'} in elemTypes)"),
4295 hasFaces("({'Face'} in elemTypes)"),
4296 hasVolumes("({'Volume'} in elemTypes)");
4298 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4299 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& isComputable");
4300 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, mesh, "&& isComputable");
4301 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, subMesh, "&& isComputable" );
4302 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4303 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4305 popupMgr()->insert( separator(), -1, 0 );
4306 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& isComputable" );
4307 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& isComputable && isPreComputable" );
4308 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& isComputable" );
4309 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& isComputable" );
4310 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4311 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4312 createPopupItem( SMESHOp::OpFindElementByPoint, OB, mesh_group );
4313 createPopupItem( SMESHOp::OpOverallMeshQuality, OB, mesh_part );
4314 popupMgr()->insert( separator(), -1, 0 );
4315 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh );
4316 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh );
4317 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4318 popupMgr()->insert( separator(), -1, 0 );
4319 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo);
4320 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4321 popupMgr()->insert( separator(), -1, 0 );
4322 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4323 popupMgr()->insert( separator(), -1, 0 );
4324 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh + " " + subMesh ); // convert to quadratic
4325 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh + " " + group, // create 2D mesh from 3D
4327 popupMgr()->insert( separator(), -1, 0 );
4329 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4330 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4331 QString only_one_2D = only_one_non_empty + " && dim>1";
4333 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4334 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4335 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4336 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4338 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4340 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, multiple_non_empty, anId );
4341 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, multiple_non_empty, anId );
4342 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, multiple_non_empty, anId );
4343 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4344 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4345 popupMgr()->insert( separator(), -1, 0 );
4348 createPopupItem( SMESHOp::OpEditGroup, View, group );
4349 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4350 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4352 popupMgr()->insert( separator(), -1, 0 );
4353 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4354 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4355 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4356 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4357 popupMgr()->insert( separator(), -1, 0 );
4359 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4360 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4361 popupMgr()->insert( separator(), -1, 0 );
4363 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4364 QString aType = QString( "%1type in {%2}" ).arg( lc );
4365 aType = aType.arg( mesh_part );
4366 QString aMeshInVTK = aClient + "&&" + aType;
4368 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4369 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4370 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4372 //-------------------------------------------------
4374 //-------------------------------------------------
4375 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4377 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4378 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4379 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4381 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4382 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4383 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4385 popupMgr()->insert( separator(), -1, -1 );
4387 //-------------------------------------------------
4389 //-------------------------------------------------
4390 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4392 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4393 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4394 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4396 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4397 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4398 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4400 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4401 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4402 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4404 popupMgr()->insert( separator(), anId, -1 );
4406 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4407 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4408 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4410 //-------------------------------------------------
4412 //-------------------------------------------------
4413 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4415 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4417 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4418 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4419 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4421 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4422 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4423 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4425 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4426 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4427 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4429 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4430 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4431 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4433 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4434 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4435 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4437 popupMgr()->insert( separator(), anId, -1 );
4439 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4440 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4443 //-------------------------------------------------
4444 // Representation of the 2D Quadratic elements
4445 //-------------------------------------------------
4446 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4447 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4448 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4449 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4451 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4452 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4453 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4455 //-------------------------------------------------
4456 // Orientation of faces
4457 //-------------------------------------------------
4458 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4459 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4460 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4462 //-------------------------------------------------
4464 //-------------------------------------------------
4465 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4466 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4468 //-------------------------------------------------
4470 //-------------------------------------------------
4471 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4472 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4474 //-------------------------------------------------
4476 //-------------------------------------------------
4478 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4479 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4480 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4481 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4483 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4485 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4486 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4488 popupMgr()->insert( separator(), anId, -1 );
4490 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4492 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4493 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4494 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4496 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4497 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4498 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4500 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4502 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4503 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4504 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4506 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4507 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4508 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4510 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4511 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4512 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4514 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4515 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4516 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4517 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4518 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4519 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4521 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4523 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4524 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4525 QtxPopupMgr::VisibleRule );
4526 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4528 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4529 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4530 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4532 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4533 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4534 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4536 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4537 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4538 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4540 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4541 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4542 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4544 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4545 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4546 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4548 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4549 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4550 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4552 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4553 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4554 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4556 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4557 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4558 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4560 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4561 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4562 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4564 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4565 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4566 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4568 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4569 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4570 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4571 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4572 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4573 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4575 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4577 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4578 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4579 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4581 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4582 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4583 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4585 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4586 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4587 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4589 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4590 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4591 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4593 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4594 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4595 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4597 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4598 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4599 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4601 popupMgr()->insert( separator(), anId, -1 );
4603 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4604 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4606 popupMgr()->insert( separator(), anId, -1 );
4608 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4610 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4611 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4613 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4614 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4615 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4617 #ifndef DISABLE_PLOT2DVIEWER
4618 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4619 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4622 //-------------------------------------------------
4624 //-------------------------------------------------
4625 popupMgr()->insert( separator(), -1, -1 );
4626 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4627 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4628 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4629 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4631 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4632 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4634 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4635 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4637 popupMgr()->insert( separator(), -1, -1 );
4639 //-------------------------------------------------
4641 //-------------------------------------------------
4642 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4643 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4645 popupMgr()->insert( separator(), -1, -1 );
4647 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4648 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4649 popupMgr()->insert( separator(), -1, -1 );
4651 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4652 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4654 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4655 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4658 //================================================================================
4660 * \brief Return true if SMESH or GEOM objects are selected.
4661 * Is called form LightApp_Module::activateModule() which clear selection if
4662 * not isSelectionCompatible()
4664 //================================================================================
4666 bool SMESHGUI::isSelectionCompatible()
4668 bool isCompatible = true;
4669 SALOME_ListIO selected;
4670 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4671 Sel->selectedObjects( selected );
4673 SALOME_ListIteratorOfListIO It( selected );
4674 for ( ; isCompatible && It.More(); It.Next())
4676 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4677 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4679 return isCompatible;
4683 bool SMESHGUI::reusableOperation( const int id )
4685 // compute, evaluate and precompute are not reusable operations
4686 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4689 bool SMESHGUI::activateModule( SUIT_Study* study )
4691 bool res = SalomeApp_Module::activateModule( study );
4693 setMenuShown( true );
4694 setToolShown( true );
4696 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4697 PyGILState_STATE gstate = PyGILState_Ensure();
4698 PyObjWrapper pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4699 if ( !pluginsmanager ) {
4703 PyObjWrapper result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4707 PyGILState_Release(gstate);
4708 // end of SMESH plugins loading
4710 // Reset actions accelerator keys
4711 //action(SMESHOp::OpImportDAT)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B));
4712 action(SMESHOp::OpImportUNV)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U));
4713 action(SMESHOp::OpImportMED)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M));
4715 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4717 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4718 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4719 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4720 if ( _PTR(Study) aStudy = s->studyDS()) {
4721 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4722 updateObjBrowser(); // objects can be removed
4725 // get all view currently opened in the study and connect their signals to
4726 // the corresponding slots of the class.
4727 SUIT_Desktop* aDesk = study->application()->desktop();
4729 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4730 SUIT_ViewWindow* wnd;
4731 foreach ( wnd, wndList )
4738 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4740 setMenuShown( false );
4741 setToolShown( false );
4743 EmitSignalCloseAllDialogs();
4745 // Unset actions accelerator keys
4746 //action(SMESHOp::OpImportDAT)->setShortcut(QKeySequence());
4747 action(SMESHOp::OpImportUNV)->setShortcut(QKeySequence());
4748 action(SMESHOp::OpImportMED)->setShortcut(QKeySequence());
4750 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4752 return SalomeApp_Module::deactivateModule( study );
4755 void SMESHGUI::studyClosed( SUIT_Study* s )
4757 SMESH::RemoveVisuData( s->id() );
4758 SalomeApp_Module::studyClosed( s );
4761 void SMESHGUI::OnGUIEvent()
4763 const QObject* obj = sender();
4764 if ( !obj || !obj->inherits( "QAction" ) )
4766 int id = actionId((QAction*)obj);
4771 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4773 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4774 if ( CORBA::is_nil( myComponentSMESH ) )
4776 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4778 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4779 return aGUI.myComponentSMESH;
4782 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4783 return myComponentSMESH;
4786 QString SMESHGUI::engineIOR() const
4788 CORBA::ORB_var anORB = getApp()->orb();
4789 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4790 return QString( anIOR.in() );
4793 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4795 SalomeApp_Module::contextMenuPopup( client, menu, title );
4797 selectionMgr()->selectedObjects( lst );
4798 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4799 Handle(SALOME_InteractiveObject) io = lst.First();
4800 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4801 _PTR(Study) study = appStudy->studyDS();
4802 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4804 QString aName = QString( QString::fromUtf8(obj->GetName().c_str()) );
4805 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4806 aName.remove( (aName.length() - 1), 1 );
4812 LightApp_Selection* SMESHGUI::createSelection() const
4814 return new SMESHGUI_Selection();
4817 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4819 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4820 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4821 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4824 void SMESHGUI::viewManagers( QStringList& list ) const
4826 list.append( SVTK_Viewer::Type() );
4829 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4831 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4832 SMESH::UpdateSelectionProp( this );
4834 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4835 for(int i = 0; i < aViews.count() ; i++){
4836 SUIT_ViewWindow *sf = aViews[i];
4842 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4844 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4845 myClippingPlaneInfoMap.erase( theViewManager );
4848 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4850 theActor->AddObserver( SMESH::DeleteActorEvent,
4851 myEventCallbackCommand.GetPointer(),
4855 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4856 unsigned long theEvent,
4857 void* theClientData,
4860 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4861 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4862 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4863 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4864 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4865 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4866 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4867 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4868 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4869 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4870 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4871 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4872 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4873 if( anActor == *anIter3 ) {
4874 anActorList.erase( anIter3 );
4885 void SMESHGUI::createPreferences()
4887 // General tab ------------------------------------------------------------------------
4888 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4890 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4891 setPreferenceProperty( autoUpdate, "columns", 2 );
4892 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4893 setPreferenceProperty( lim, "min", 0 );
4894 setPreferenceProperty( lim, "max", 100000000 );
4895 setPreferenceProperty( lim, "step", 1000 );
4896 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4897 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4899 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4900 setPreferenceProperty( qaGroup, "columns", 2 );
4901 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4902 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4903 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4904 setPreferenceProperty( prec, "min", 0 );
4905 setPreferenceProperty( prec, "max", 16 );
4906 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4907 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4908 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4909 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4910 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4912 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4913 setPreferenceProperty( dispgroup, "columns", 2 );
4914 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4916 modes.append( tr("MEN_WIRE") );
4917 modes.append( tr("MEN_SHADE") );
4918 modes.append( tr("MEN_NODES") );
4919 modes.append( tr("MEN_SHRINK") );
4920 QList<QVariant> indices;
4921 indices.append( 0 );
4922 indices.append( 1 );
4923 indices.append( 2 );
4924 indices.append( 3 );
4925 setPreferenceProperty( dispmode, "strings", modes );
4926 setPreferenceProperty( dispmode, "indexes", indices );
4928 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4929 setPreferenceProperty( arcgroup, "columns", 2 );
4930 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4931 QStringList quadraticModes;
4932 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4933 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4935 indices.append( 0 );
4936 indices.append( 1 );
4937 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4938 setPreferenceProperty( quadraticmode, "indexes", indices );
4940 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4941 "SMESH", "max_angle" );
4942 setPreferenceProperty( maxAngle, "min", 1 );
4943 setPreferenceProperty( maxAngle, "max", 90 );
4947 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4948 setPreferenceProperty( exportgroup, "columns", 2 );
4949 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4950 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4952 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4953 setPreferenceProperty( computeGroup, "columns", 2 );
4954 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4956 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4957 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4958 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4960 indices.append( 0 );
4961 indices.append( 1 );
4962 indices.append( 2 );
4963 setPreferenceProperty( notifyMode, "strings", modes );
4964 setPreferenceProperty( notifyMode, "indexes", indices );
4966 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4967 setPreferenceProperty( infoGroup, "columns", 2 );
4968 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4970 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4971 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4973 indices.append( 0 );
4974 indices.append( 1 );
4975 setPreferenceProperty( elemInfo, "strings", modes );
4976 setPreferenceProperty( elemInfo, "indexes", indices );
4977 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4978 setPreferenceProperty( nodesLim, "min", 0 );
4979 setPreferenceProperty( nodesLim, "max", 10000000 );
4980 setPreferenceProperty( nodesLim, "step", 10000 );
4981 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4982 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
4983 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4984 setPreferenceProperty( ctrlLim, "min", 0 );
4985 setPreferenceProperty( ctrlLim, "max", 10000000 );
4986 setPreferenceProperty( ctrlLim, "step", 1000 );
4987 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
4988 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
4989 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
4990 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
4991 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
4993 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4994 setPreferenceProperty( segGroup, "columns", 2 );
4995 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4996 "SMESH", "segmentation" );
4997 setPreferenceProperty( segLen, "min", 1 );
4998 setPreferenceProperty( segLen, "max", 10000000 );
4999 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5000 "SMESH", "nb_segments_per_edge" );
5001 setPreferenceProperty( nbSeg, "min", 1 );
5002 setPreferenceProperty( nbSeg, "max", 10000000 );
5004 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5005 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5006 "SMESH", "forget_mesh_on_hyp_modif" );
5009 // Quantities with individual precision settings
5010 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5011 setPreferenceProperty( precGroup, "columns", 2 );
5013 const int nbQuantities = 6;
5014 int precs[nbQuantities], ii = 0;
5015 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5016 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5017 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5018 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5019 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5020 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5021 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5022 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5023 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5024 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5025 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5026 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5028 // Set property for precision value for spinboxes
5029 for ( ii = 0; ii < nbQuantities; ii++ ){
5030 setPreferenceProperty( precs[ii], "min", -14 );
5031 setPreferenceProperty( precs[ii], "max", 14 );
5032 setPreferenceProperty( precs[ii], "precision", 2 );
5035 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5036 setPreferenceProperty( previewGroup, "columns", 2 );
5037 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5038 setPreferenceProperty( chunkSize, "min", 1 );
5039 setPreferenceProperty( chunkSize, "max", 1000 );
5040 setPreferenceProperty( chunkSize, "step", 50 );
5042 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5043 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5045 // Mesh tab ------------------------------------------------------------------------
5046 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5047 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5048 setPreferenceProperty( nodeGroup, "columns", 3 );
5050 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5052 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5054 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5055 QList<QVariant> aMarkerTypeIndicesList;
5056 QList<QVariant> aMarkerTypeIconsList;
5057 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5058 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5059 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5060 aMarkerTypeIndicesList << i;
5061 aMarkerTypeIconsList << pixmap;
5063 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5064 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5066 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5068 QList<QVariant> aMarkerScaleIndicesList;
5069 QStringList aMarkerScaleValuesList;
5070 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5071 aMarkerScaleIndicesList << i;
5072 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5074 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5075 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5077 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5078 //setPreferenceProperty( elemGroup, "columns", 2 );
5080 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5081 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5082 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5083 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5084 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5085 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5086 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5087 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5088 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5091 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5092 setPreferenceProperty( grpGroup, "columns", 2 );
5094 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5095 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5097 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5098 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5099 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5100 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
5101 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5102 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5103 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5104 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5105 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5106 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5107 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5108 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5110 setPreferenceProperty( size0d, "min", 1 );
5111 setPreferenceProperty( size0d, "max", 10 );
5113 setPreferenceProperty( ballSize, "min", 1 );
5114 setPreferenceProperty( ballSize, "max", 10 );
5116 setPreferenceProperty( ballScale, "min", 1e-2 );
5117 setPreferenceProperty( ballScale, "max", 1e7 );
5118 setPreferenceProperty( ballScale, "step", 0.5 );
5120 setPreferenceProperty( elemW, "min", 1 );
5121 setPreferenceProperty( elemW, "max", 5 );
5123 setPreferenceProperty( outW, "min", 1 );
5124 setPreferenceProperty( outW, "max", 5 );
5126 setPreferenceProperty( shrink, "min", 0 );
5127 setPreferenceProperty( shrink, "max", 100 );
5129 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5130 setPreferenceProperty( numGroup, "columns", 2 );
5132 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5133 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5135 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5136 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5138 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5139 setPreferenceProperty( orientGroup, "columns", 1 );
5141 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5142 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5144 setPreferenceProperty( orientScale, "min", 0.05 );
5145 setPreferenceProperty( orientScale, "max", 0.5 );
5146 setPreferenceProperty( orientScale, "step", 0.05 );
5148 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5150 // Selection tab ------------------------------------------------------------------------
5151 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5153 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5154 setPreferenceProperty( selGroup, "columns", 2 );
5156 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5157 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5159 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5160 setPreferenceProperty( preGroup, "columns", 2 );
5162 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5164 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5165 setPreferenceProperty( precSelGroup, "columns", 2 );
5167 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5168 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5169 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5171 // Scalar Bar tab ------------------------------------------------------------------------
5172 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5173 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5174 setPreferenceProperty( fontGr, "columns", 2 );
5176 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5177 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5179 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5180 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5182 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5183 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5185 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5186 setPreferenceProperty( numcol, "min", 2 );
5187 setPreferenceProperty( numcol, "max", 256 );
5189 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5190 setPreferenceProperty( numlab, "min", 2 );
5191 setPreferenceProperty( numlab, "max", 65 );
5193 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5194 setPreferenceProperty( orientGr, "columns", 2 );
5195 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5196 QStringList orients;
5197 orients.append( tr( "SMESH_VERTICAL" ) );
5198 orients.append( tr( "SMESH_HORIZONTAL" ) );
5199 indices.clear(); indices.append( 0 ); indices.append( 1 );
5200 setPreferenceProperty( orient, "strings", orients );
5201 setPreferenceProperty( orient, "indexes", indices );
5203 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5204 setPreferenceProperty( posVSizeGr, "columns", 2 );
5205 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5206 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5207 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5208 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5209 setPreferenceProperty( xv, "step", 0.1 );
5210 setPreferenceProperty( xv, "min", 0.0 );
5211 setPreferenceProperty( xv, "max", 1.0 );
5212 setPreferenceProperty( yv, "step", 0.1 );
5213 setPreferenceProperty( yv, "min", 0.0 );
5214 setPreferenceProperty( yv, "max", 1.0 );
5215 setPreferenceProperty( wv, "step", 0.1 );
5216 setPreferenceProperty( wv, "min", 0.0 );
5217 setPreferenceProperty( wv, "max", 1.0 );
5218 setPreferenceProperty( hv, "min", 0.0 );
5219 setPreferenceProperty( hv, "max", 1.0 );
5220 setPreferenceProperty( hv, "step", 0.1 );
5222 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5223 setPreferenceProperty( posHSizeGr, "columns", 2 );
5224 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5225 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5226 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5227 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5228 setPreferenceProperty( xv, "min", 0.0 );
5229 setPreferenceProperty( xv, "max", 1.0 );
5230 setPreferenceProperty( xv, "step", 0.1 );
5231 setPreferenceProperty( xh, "min", 0.0 );
5232 setPreferenceProperty( xh, "max", 1.0 );
5233 setPreferenceProperty( xh, "step", 0.1 );
5234 setPreferenceProperty( yh, "min", 0.0 );
5235 setPreferenceProperty( yh, "max", 1.0 );
5236 setPreferenceProperty( yh, "step", 0.1 );
5237 setPreferenceProperty( wh, "min", 0.0 );
5238 setPreferenceProperty( wh, "max", 1.0 );
5239 setPreferenceProperty( wh, "step", 0.1 );
5240 setPreferenceProperty( hh, "min", 0.0 );
5241 setPreferenceProperty( hh, "max", 1.0 );
5242 setPreferenceProperty( hh, "step", 0.1 );
5244 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5245 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5246 setPreferenceProperty( distributionGr, "columns", 3 );
5248 types.append( tr( "SMESH_MONOCOLOR" ) );
5249 types.append( tr( "SMESH_MULTICOLOR" ) );
5250 indices.clear(); indices.append( 0 ); indices.append( 1 );
5251 setPreferenceProperty( coloringType, "strings", types );
5252 setPreferenceProperty( coloringType, "indexes", indices );
5253 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5257 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5259 if( sect=="SMESH" ) {
5260 float sbX1,sbY1,sbW,sbH;
5261 float aTol = 1.00000009999999;
5262 std::string aWarning;
5263 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5264 if( name=="selection_object_color" || name=="selection_element_color" ||
5265 name=="highlight_color" ||
5266 name=="selection_precision_node" || name=="selection_precision_element" ||
5267 name=="selection_precision_object")
5268 SMESH::UpdateSelectionProp( this );
5269 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5270 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5271 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5272 if(sbX1+sbW > aTol){
5273 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5276 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5277 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5280 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5281 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5282 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5283 if(sbY1+sbH > aTol){
5284 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5285 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5286 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5289 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5290 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5291 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5292 if(sbX1+sbW > aTol){
5293 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5296 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5297 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5300 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5301 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5302 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5303 if(sbY1+sbH > aTol){
5304 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5307 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5308 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5311 else if ( name == "segmentation" ) {
5312 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5313 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5315 else if ( name == "nb_segments_per_edge" ) {
5316 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5317 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5319 else if ( name == "historical_python_dump" ||
5320 name == "forget_mesh_on_hyp_modif") {
5321 QString val = aResourceMgr->stringValue( "SMESH", name );
5322 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5324 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5325 SMESH::UpdateFontProp( this );
5327 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5328 SMESH::UpdateFontProp( this );
5331 if(aWarning.size() != 0){
5332 aWarning += "The default values are applied instead.";
5333 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5334 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5335 QObject::tr(aWarning.c_str()));
5340 //================================================================================
5342 * \brief Update something in accordance with update flags
5343 * \param theFlags - update flags
5345 * Update viewer or/and object browser etc. in accordance with update flags ( see
5346 * LightApp_UpdateFlags enumeration ).
5348 //================================================================================
5349 void SMESHGUI::update( const int flags )
5351 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5352 SMESH::UpdateView();
5354 SalomeApp_Module::update( flags );
5357 //================================================================================
5359 * \brief Set default selection mode
5361 * SLOT called when operation commited. Sets default selection mode
5363 //================================================================================
5364 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5366 SVTK_ViewWindow* vtkWnd =
5367 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5369 vtkWnd->SetSelectionMode( ActorSelection );
5372 //================================================================================
5374 * \brief Set default selection mode
5376 * SLOT called when operation aborted. Sets default selection mode
5378 //================================================================================
5379 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5381 SVTK_ViewWindow* vtkWnd =
5382 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5384 vtkWnd->SetSelectionMode( ActorSelection );
5387 //================================================================================
5389 * \brief Creates operation with given identifier
5390 * \param id - identifier of operation to be started
5391 * \return Pointer on created operation or NULL if operation is not created
5393 * Virtual method redefined from the base class creates operation with given id.
5394 * It is called called automatically from startOperation method of base class.
5396 //================================================================================
5397 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5399 LightApp_Operation* op = 0;
5400 // to do : create operation here
5403 case SMESHOp::OpConvertMeshToQuadratic:
5404 op = new SMESHGUI_ConvToQuadOp();
5406 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5407 op = new SMESHGUI_Make2DFrom3DOp();
5409 case SMESHOp::OpReorientFaces:
5410 op = new SMESHGUI_ReorientFacesOp();
5412 case SMESHOp::OpCreateMesh:
5413 op = new SMESHGUI_MeshOp( true, true );
5415 case SMESHOp::OpCreateSubMesh:
5416 op = new SMESHGUI_MeshOp( true, false );
5418 case SMESHOp::OpEditMeshOrSubMesh:
5419 op = new SMESHGUI_MeshOp( false );
5421 case SMESHOp::OpCompute:
5422 op = new SMESHGUI_ComputeOp();
5424 case SMESHOp::OpPreCompute:
5425 op = new SMESHGUI_PrecomputeOp();
5427 case SMESHOp::OpEvaluate:
5428 op = new SMESHGUI_EvaluateOp();
5430 case SMESHOp::OpMeshOrder:
5431 op = new SMESHGUI_MeshOrderOp();
5433 case SMESHOp::OpCreateGeometryGroup:
5434 op = new SMESHGUI_GroupOnShapeOp();
5436 case SMESHOp::OpFindElementByPoint:
5437 op = new SMESHGUI_FindElemByPointOp();
5439 case SMESHOp::OpMoveNode: // Make mesh pass through point
5440 op = new SMESHGUI_MakeNodeAtPointOp();
5442 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5443 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5450 op = SalomeApp_Module::createOperation( id );
5454 //================================================================================
5456 * \brief Stops current operations and starts a given one
5457 * \param id - The id of the operation to start
5459 //================================================================================
5461 void SMESHGUI::switchToOperation(int id)
5463 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5464 activeStudy()->abortAllOperations();
5465 startOperation( id );
5468 LightApp_Displayer* SMESHGUI::displayer()
5471 myDisplayer = new SMESHGUI_Displayer( getApp() );
5475 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5478 int aTolerance = 64;
5479 int anIterations = 0;
5485 if( anIterations % aPeriod == 0 )
5488 if( aTolerance < 1 )
5492 aHue = (int)( 360.0 * rand() / RAND_MAX );
5495 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5496 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5497 for( ; it != itEnd; ++it )
5499 SALOMEDS::Color anAutoColor = *it;
5500 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5503 aQColor.getHsv( &h, &s, &v );
5504 if( abs( h - aHue ) < aTolerance )
5516 aColor.setHsv( aHue, 255, 255 );
5518 SALOMEDS::Color aSColor;
5519 aSColor.R = aColor.redF();
5520 aSColor.G = aColor.greenF();
5521 aSColor.B = aColor.blueF();
5526 const char* gSeparator = "_"; // character used to separate parameter names
5527 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5528 const char* gPathSep = "|"; // character used to separate paths
5531 * \brief Store visual parameters
5533 * This method is called just before the study document is saved.
5534 * Store visual parameters in AttributeParameter attribue(s)
5536 void SMESHGUI::storeVisualParameters (int savePoint)
5539 Kernel_Utils::Localizer loc;
5541 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5542 if (!appStudy || !appStudy->studyDS())
5544 _PTR(Study) studyDS = appStudy->studyDS();
5546 // componentName is used for encoding of entries when storing them in IParameters
5547 std::string componentName = myComponentSMESH->ComponentDataType();
5548 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5549 //if (!aSComponent) return;
5552 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5553 componentName.c_str(),
5555 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5557 // store map of custom markers
5558 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5559 if( !aMarkerMap.empty() )
5561 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5562 for( ; anIter != aMarkerMap.end(); anIter++ )
5564 int anId = anIter->first;
5565 VTK::MarkerData aMarkerData = anIter->second;
5566 std::string aMarkerFileName = aMarkerData.first;
5567 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5568 if( aMarkerTexture.size() < 3 )
5569 continue; // should contain at least width, height and the first value
5571 QString aPropertyName( "texture" );
5572 aPropertyName += gSeparator;
5573 aPropertyName += QString::number( anId );
5575 QString aPropertyValue = aMarkerFileName.c_str();
5576 aPropertyValue += gPathSep;
5578 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5579 ushort aWidth = *aTextureIter++;
5580 ushort aHeight = *aTextureIter++;
5581 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5582 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5583 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5584 aPropertyValue += QString::number( *aTextureIter );
5586 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5590 // viewers counters are used for storing view_numbers in IParameters
5593 // main cycle to store parameters of displayed objects
5594 QList<SUIT_ViewManager*> lst;
5595 QList<SUIT_ViewManager*>::Iterator it;
5596 getApp()->viewManagers(lst);
5597 for (it = lst.begin(); it != lst.end(); it++)
5599 SUIT_ViewManager* vman = *it;
5600 QString vType = vman->getType();
5602 // saving VTK actors properties
5603 if (vType == SVTK_Viewer::Type())
5605 // store the clipping planes attached to the view manager
5606 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5607 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5608 if( anIter != myClippingPlaneInfoMap.end() )
5609 aClippingPlaneInfoList = anIter->second;
5611 if( !aClippingPlaneInfoList.empty() ) {
5612 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5613 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5615 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5616 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5618 QString aPropertyName( "ClippingPlane" );
5619 aPropertyName += gSeparator;
5620 aPropertyName += QString::number( vtkViewers );
5621 aPropertyName += gSeparator;
5622 aPropertyName += QString::number( anId );
5624 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5625 aPropertyValue += gDigitsSep;
5626 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5627 aPropertyValue += gDigitsSep;
5628 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5629 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5630 aPropertyValue += gDigitsSep;
5631 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5632 aPropertyValue += gDigitsSep;
5633 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5634 aPropertyValue += gDigitsSep;
5635 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5636 aPropertyValue += gDigitsSep;
5637 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5638 aPropertyValue += gDigitsSep;
5639 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5640 aPropertyValue += gDigitsSep;
5641 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5643 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5644 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5645 aPropertyValue += gDigitsSep;
5646 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5647 aPropertyValue += gDigitsSep;
5648 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5649 aPropertyValue += gDigitsSep;
5650 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5653 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5657 QVector<SUIT_ViewWindow*> views = vman->getViews();
5658 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5660 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5662 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5663 vtkActorCollection* allActors = aCopy.GetActors();
5664 allActors->InitTraversal();
5665 while (vtkActor* actor = allActors->GetNextActor())
5667 if (actor->GetVisibility()) // store only visible actors
5669 SMESH_Actor* aSmeshActor = 0;
5670 if (actor->IsA("SMESH_Actor"))
5671 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5672 if (aSmeshActor && aSmeshActor->hasIO())
5674 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5677 // entry is "encoded" = it does NOT contain component adress,
5678 // since it is a subject to change on next component loading
5679 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5681 std::string param, vtkParam = vType.toLatin1().data();
5682 vtkParam += gSeparator;
5683 vtkParam += QString::number(vtkViewers).toLatin1().data();
5684 vtkParam += gSeparator;
5687 param = vtkParam + "Visibility";
5688 ip->setParameter(entry, param, "On");
5691 param = vtkParam + "Representation";
5692 ip->setParameter(entry, param, QString::number
5693 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5696 param = vtkParam + "IsShrunk";
5697 ip->setParameter(entry, param, QString::number
5698 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5700 // Displayed entities
5701 unsigned int aMode = aSmeshActor->GetEntityMode();
5702 bool isE = aMode & SMESH_Actor::eEdges;
5703 bool isF = aMode & SMESH_Actor::eFaces;
5704 bool isV = aMode & SMESH_Actor::eVolumes;
5705 bool is0d = aMode & SMESH_Actor::e0DElements;
5706 bool isB = aMode & SMESH_Actor::eBallElem;
5708 QString modeStr ("e");
5709 modeStr += gDigitsSep; modeStr += QString::number(isE);
5710 modeStr += gDigitsSep; modeStr += "f";
5711 modeStr += gDigitsSep; modeStr += QString::number(isF);
5712 modeStr += gDigitsSep; modeStr += "v";
5713 modeStr += gDigitsSep; modeStr += QString::number(isV);
5714 modeStr += gDigitsSep; modeStr += "0d";
5715 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5716 modeStr += gDigitsSep; modeStr += "b";
5717 modeStr += gDigitsSep; modeStr += QString::number(isB);
5719 param = vtkParam + "Entities";
5720 ip->setParameter(entry, param, modeStr.toLatin1().data());
5726 aSmeshActor->GetSufaceColor(r, g, b, delta);
5727 QStringList colorStr;
5728 colorStr << "surface";
5729 colorStr << QString::number(r);
5730 colorStr << QString::number(g);
5731 colorStr << QString::number(b);
5733 colorStr << "backsurface";
5734 colorStr << QString::number(delta);
5736 aSmeshActor->GetVolumeColor(r, g, b, delta);
5737 colorStr << "volume";
5738 colorStr << QString::number(r);
5739 colorStr << QString::number(g);
5740 colorStr << QString::number(b);
5741 colorStr << QString::number(delta);
5743 aSmeshActor->GetEdgeColor(r, g, b);
5745 colorStr << QString::number(r);
5746 colorStr << QString::number(g);
5747 colorStr << QString::number(b);
5749 aSmeshActor->GetNodeColor(r, g, b);
5751 colorStr << QString::number(r);
5752 colorStr << QString::number(g);
5753 colorStr << QString::number(b);
5755 aSmeshActor->GetOutlineColor(r, g, b);
5756 colorStr << "outline";
5757 colorStr << QString::number(r);
5758 colorStr << QString::number(g);
5759 colorStr << QString::number(b);
5761 aSmeshActor->Get0DColor(r, g, b);
5762 colorStr << "elem0d";
5763 colorStr << QString::number(r);
5764 colorStr << QString::number(g);
5765 colorStr << QString::number(b);
5767 aSmeshActor->GetBallColor(r, g, b);
5769 colorStr << QString::number(r);
5770 colorStr << QString::number(g);
5771 colorStr << QString::number(b);
5773 aSmeshActor->GetFacesOrientationColor(r, g, b);
5774 colorStr << "orientation";
5775 colorStr << QString::number(r);
5776 colorStr << QString::number(g);
5777 colorStr << QString::number(b);
5779 param = vtkParam + "Colors";
5780 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5783 QStringList sizeStr;
5785 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5786 sizeStr << "outline";
5787 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5788 sizeStr << "elem0d";
5789 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5791 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5792 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5793 sizeStr << "shrink";
5794 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5795 sizeStr << "orientation";
5796 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5797 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5799 param = vtkParam + "Sizes";
5800 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5805 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5806 if( aMarkerType == VTK::MT_USER ) {
5807 markerStr += "custom";
5808 markerStr += gDigitsSep;
5809 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5813 markerStr += gDigitsSep;
5814 markerStr += QString::number( (int)aMarkerType );
5815 markerStr += gDigitsSep;
5816 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5819 param = vtkParam + "PointMarker";
5820 ip->setParameter(entry, param, markerStr.toLatin1().data());
5823 param = vtkParam + "Opacity";
5824 ip->setParameter(entry, param,
5825 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5828 param = vtkParam + "ClippingPlane";
5830 if( !aClippingPlaneInfoList.empty() ) {
5831 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5832 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5834 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5835 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5836 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5837 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5838 if( aSmeshActor == *anIter2 ) {
5839 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5840 QString::number( anId ).toLatin1().constData() );
5847 ip->setParameter( entry, param, "Off" );
5848 } // if (io->hasEntry())
5849 } // SMESH_Actor && hasIO
5851 } // while.. actors traversal
5855 } // if (SVTK view model)
5856 } // for (viewManagers)
5859 // data structures for clipping planes processing
5863 bool isOpenGLClipping;
5864 vtkIdType RelativeOrientation;
5867 int AbsoluteOrientation;
5868 double X, Y, Z, Dx, Dy, Dz;
5870 typedef std::list<TPlaneData> TPlaneDataList;
5871 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5873 typedef std::list<vtkActor*> TActorList;
5876 TActorList ActorList;
5877 SUIT_ViewManager* ViewManager;
5879 typedef std::list<TPlaneInfo> TPlaneInfoList;
5880 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5883 * \brief Restore visual parameters
5885 * This method is called after the study document is opened.
5886 * Restore visual parameters from AttributeParameter attribue(s)
5888 void SMESHGUI::restoreVisualParameters (int savePoint)
5891 Kernel_Utils::Localizer loc;
5893 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5894 if (!appStudy || !appStudy->studyDS())
5896 _PTR(Study) studyDS = appStudy->studyDS();
5898 // componentName is used for encoding of entries when storing them in IParameters
5899 std::string componentName = myComponentSMESH->ComponentDataType();
5900 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5901 //if (!aSComponent) return;
5904 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5905 componentName.c_str(),
5907 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5909 // restore map of custom markers and map of clipping planes
5910 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5911 TPlaneDataMap aPlaneDataMap;
5913 std::vector<std::string> properties = ip->getProperties();
5914 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5916 std::string property = *propIt;
5917 QString aPropertyName( property.c_str() );
5918 QString aPropertyValue( ip->getProperty( property ).c_str() );
5920 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5921 if( aPropertyNameList.isEmpty() )
5924 QString aPropertyType = aPropertyNameList[0];
5925 if( aPropertyType == "texture" )
5927 if( aPropertyNameList.size() != 2 )
5931 int anId = aPropertyNameList[1].toInt( &ok );
5932 if( !ok || anId < 1 )
5935 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5936 if( aPropertyValueList.size() != 2 )
5939 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5940 QString aMarkerTextureString = aPropertyValueList[1];
5941 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5942 if( aMarkerTextureStringList.size() != 3 )
5946 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5951 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5955 VTK::MarkerTexture aMarkerTexture;
5956 aMarkerTexture.push_back( aWidth );
5957 aMarkerTexture.push_back( aHeight );
5959 QString aMarkerTextureData = aMarkerTextureStringList[2];
5960 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5962 QChar aChar = aMarkerTextureData.at( i );
5963 if( aChar.isDigit() )
5964 aMarkerTexture.push_back( aChar.digitValue() );
5967 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5969 else if( aPropertyType == "ClippingPlane" )
5971 if( aPropertyNameList.size() != 3 )
5975 int aViewId = aPropertyNameList[1].toInt( &ok );
5976 if( !ok || aViewId < 0 )
5980 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5981 if( !ok || aClippingPlaneId < 0 )
5984 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5985 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
5988 TPlaneData aPlaneData;
5989 aPlaneData.Id = aClippingPlaneId;
5992 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
5997 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6001 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6004 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6009 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6014 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6019 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6024 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6029 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6034 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6038 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6040 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6045 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6050 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6055 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6060 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6061 aPlaneDataList.push_back( aPlaneData );
6065 TPlaneInfoMap aPlaneInfoMap;
6067 std::vector<std::string> entries = ip->getEntries();
6069 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6071 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6072 QString entry (ip->decodeEntry(*entIt).c_str());
6074 // Check that the entry corresponds to a real object in the Study
6075 // as the object may be deleted or modified after the visual state is saved.
6076 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6077 if (!so) continue; //Skip the not existent entry
6079 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6080 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6082 std::vector<std::string>::iterator namesIt = paramNames.begin();
6083 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6085 // actors are stored in a map after displaying of them for
6086 // quicker access in the future: map < viewID to actor >
6087 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6089 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6091 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6092 // '_' is used as separator and should not be used in viewer type or parameter names.
6093 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6094 if (lst.size() != 3)
6097 QString viewerTypStr = lst[0];
6098 QString viewIndexStr = lst[1];
6099 QString paramNameStr = lst[2];
6102 int viewIndex = viewIndexStr.toUInt(&ok);
6103 if (!ok) // bad conversion of view index to integer
6107 if (viewerTypStr == SVTK_Viewer::Type())
6109 SMESH_Actor* aSmeshActor = 0;
6110 if (vtkActors.IsBound(viewIndex))
6111 aSmeshActor = vtkActors.Find(viewIndex);
6113 QList<SUIT_ViewManager*> lst;
6114 getApp()->viewManagers(viewerTypStr, lst);
6116 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6117 SUIT_ViewManager* vman = NULL;
6118 if (viewIndex >= 0 && viewIndex < lst.count())
6119 vman = lst.at(viewIndex);
6121 if (paramNameStr == "Visibility")
6123 if (!aSmeshActor && displayer() && vman)
6125 SUIT_ViewModel* vmodel = vman->getViewModel();
6126 // SVTK view model can be casted to SALOME_View
6127 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6129 // store displayed actor in a temporary map for quicker
6130 // access later when restoring other parameters
6131 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6132 vtkRenderer* Renderer = vtkView->getRenderer();
6133 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6134 vtkActorCollection* theActors = aCopy.GetActors();
6135 theActors->InitTraversal();
6136 bool isFound = false;
6137 vtkActor *ac = theActors->GetNextActor();
6138 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6139 if (ac->IsA("SMESH_Actor")) {
6140 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6141 if (aGeomAc->hasIO()) {
6142 Handle(SALOME_InteractiveObject) io =
6143 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6144 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6146 vtkActors.Bind(viewIndex, aGeomAc);
6152 } // if (paramNameStr == "Visibility")
6155 // the rest properties "work" with SMESH_Actor
6158 QString val ((*valuesIt).c_str());
6161 if (paramNameStr == "Representation") {
6162 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6165 else if (paramNameStr == "IsShrunk") {
6167 if (!aSmeshActor->IsShrunk())
6168 aSmeshActor->SetShrink();
6171 if (aSmeshActor->IsShrunk())
6172 aSmeshActor->UnShrink();
6175 // Displayed entities
6176 else if (paramNameStr == "Entities") {
6177 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6178 int aEntityMode = SMESH_Actor::eAllEntity;
6179 for ( int i = 0; i < mode.count(); i+=2 ) {
6180 if ( i < mode.count()-1 ) {
6181 QString type = mode[i];
6182 bool val = mode[i+1].toInt();
6183 if ( type == "e" && !val )
6184 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6185 else if ( type == "f" && !val )
6186 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6187 else if ( type == "v" && !val )
6188 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6189 else if ( type == "0d" && !val )
6190 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6191 else if ( type == "b" && !val )
6192 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6195 aSmeshActor->SetEntityMode( aEntityMode );
6198 else if (paramNameStr == "Colors") {
6199 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6206 QColor outlineColor;
6207 QColor orientationColor;
6213 // below lines are required to get default values for delta coefficients
6214 // of backface color for faces and color of reversed volumes
6215 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6216 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6217 for ( int i = 0; i < colors.count(); i++ ) {
6218 QString type = colors[i];
6219 if ( type == "surface" ) {
6220 // face color is set by 3 values r:g:b, where
6221 // - r,g,b - is rgb color components
6222 if ( i+1 >= colors.count() ) break; // format error
6223 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6224 if ( i+2 >= colors.count() ) break; // format error
6225 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6226 if ( i+3 >= colors.count() ) break; // format error
6227 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6228 faceColor.setRgbF( r, g, b );
6231 else if ( type == "backsurface" ) {
6232 // backface color can be defined in several ways
6233 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6234 // - in latest versions, it is set as delta coefficient
6235 bool rgbOk = false, deltaOk;
6236 if ( i+1 >= colors.count() ) break; // format error
6237 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6238 int delta = colors[i+1].toInt( &deltaOk );
6240 if ( i+1 < colors.count() ) // index is shifted to 1
6241 g = colors[i+1].toDouble( &rgbOk );
6242 if ( rgbOk ) i++; // shift index
6243 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6244 b = colors[i+1].toDouble( &rgbOk );
6246 // - as currently there's no way to set directly backsurface color as it was before,
6247 // we ignore old dump where r,g,b triple was set
6248 // - also we check that delta parameter is set properly
6249 if ( !rgbOk && deltaOk )
6252 else if ( type == "volume" ) {
6253 // volume color is set by 4 values r:g:b:delta, where
6254 // - r,g,b - is a normal volume rgb color components
6255 // - delta - is a reversed volume color delta coefficient
6256 if ( i+1 >= colors.count() ) break; // format error
6257 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6258 if ( i+2 >= colors.count() ) break; // format error
6259 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6260 if ( i+3 >= colors.count() ) break; // format error
6261 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6262 if ( i+4 >= colors.count() ) break; // format error
6263 int delta = colors[i+4].toInt( &bOk );
6264 if ( !bOk ) break; // format error
6265 volumeColor.setRgbF( r, g, b );
6269 else if ( type == "edge" ) {
6270 // edge color is set by 3 values r:g:b, where
6271 // - r,g,b - is rgb color components
6272 if ( i+1 >= colors.count() ) break; // format error
6273 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6274 if ( i+2 >= colors.count() ) break; // format error
6275 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6276 if ( i+3 >= colors.count() ) break; // format error
6277 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6278 edgeColor.setRgbF( r, g, b );
6281 else if ( type == "node" ) {
6282 // node color is set by 3 values r:g:b, where
6283 // - r,g,b - is rgb color components
6284 if ( i+1 >= colors.count() ) break; // format error
6285 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6286 if ( i+2 >= colors.count() ) break; // format error
6287 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6288 if ( i+3 >= colors.count() ) break; // format error
6289 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6290 nodeColor.setRgbF( r, g, b );
6293 else if ( type == "elem0d" ) {
6294 // 0d element color is set by 3 values r:g:b, where
6295 // - r,g,b - is rgb color components
6296 if ( i+1 >= colors.count() ) break; // format error
6297 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6298 if ( i+2 >= colors.count() ) break; // format error
6299 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6300 if ( i+3 >= colors.count() ) break; // format error
6301 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6302 elem0dColor.setRgbF( r, g, b );
6305 else if ( type == "ball" ) {
6306 // ball color is set by 3 values r:g:b, where
6307 // - r,g,b - is rgb color components
6308 if ( i+1 >= colors.count() ) break; // format error
6309 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6310 if ( i+2 >= colors.count() ) break; // format error
6311 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6312 if ( i+3 >= colors.count() ) break; // format error
6313 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6314 ballColor.setRgbF( r, g, b );
6317 else if ( type == "outline" ) {
6318 // outline color is set by 3 values r:g:b, where
6319 // - r,g,b - is rgb color components
6320 if ( i+1 >= colors.count() ) break; // format error
6321 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6322 if ( i+2 >= colors.count() ) break; // format error
6323 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6324 if ( i+3 >= colors.count() ) break; // format error
6325 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6326 outlineColor.setRgbF( r, g, b );
6329 else if ( type == "orientation" ) {
6330 // orientation color is set by 3 values r:g:b, where
6331 // - r,g,b - is rgb color components
6332 if ( i+1 >= colors.count() ) break; // format error
6333 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6334 if ( i+2 >= colors.count() ) break; // format error
6335 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6336 if ( i+3 >= colors.count() ) break; // format error
6337 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6338 orientationColor.setRgbF( r, g, b );
6343 if ( nodeColor.isValid() )
6344 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6346 if ( edgeColor.isValid() )
6347 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6349 if ( faceColor.isValid() )
6350 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6352 if ( volumeColor.isValid() )
6353 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6354 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6355 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6357 if ( elem0dColor.isValid() )
6358 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6360 if ( ballColor.isValid() )
6361 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6363 if ( outlineColor.isValid() )
6364 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6365 // orientation color
6366 if ( orientationColor.isValid() )
6367 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6370 else if (paramNameStr == "Sizes") {
6371 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6374 int outlineWidth = -1;
6375 int elem0dSize = -1;
6377 double ballScale = -1.0;
6378 double shrinkSize = -1;
6379 double orientationSize = -1;
6380 bool orientation3d = false;
6381 for ( int i = 0; i < sizes.count(); i++ ) {
6382 QString type = sizes[i];
6383 if ( type == "line" ) {
6384 // line (wireframe) width is given as single integer value
6385 if ( i+1 >= sizes.count() ) break; // format error
6386 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6390 if ( type == "outline" ) {
6391 // outline width is given as single integer value
6392 if ( i+1 >= sizes.count() ) break; // format error
6393 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6397 else if ( type == "elem0d" ) {
6398 // 0d element size is given as single integer value
6399 if ( i+1 >= sizes.count() ) break; // format error
6400 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6404 else if ( type == "ball" ) {
6405 // balls are specified by two values: size:scale, where
6406 // - size - is a integer value specifying size
6407 // - scale - is a double value specifying scale factor
6408 if ( i+1 >= sizes.count() ) break; // format error
6409 int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6410 if ( i+2 >= sizes.count() ) break; // format error
6411 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6416 else if ( type == "shrink" ) {
6417 // shrink factor is given as single floating point value
6418 if ( i+1 >= sizes.count() ) break; // format error
6419 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6423 else if ( type == "orientation" ) {
6424 // orientation vectors are specified by two values size:3d, where
6425 // - size - is a floating point value specifying scale factor
6426 // - 3d - is a boolean
6427 if ( i+1 >= sizes.count() ) break; // format error
6428 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6429 if ( i+2 >= sizes.count() ) break; // format error
6430 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6431 orientationSize = v1;
6432 orientation3d = (bool)v2;
6436 // line (wireframe) width
6437 if ( lineWidth > 0 )
6438 aSmeshActor->SetLineWidth( lineWidth );
6440 if ( outlineWidth > 0 )
6441 aSmeshActor->SetOutlineWidth( outlineWidth );
6442 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6443 aSmeshActor->SetOutlineWidth( lineWidth );
6445 if ( elem0dSize > 0 )
6446 aSmeshActor->Set0DSize( elem0dSize );
6449 aSmeshActor->SetBallSize( ballSize );
6451 if ( ballScale > 0.0 )
6452 aSmeshActor->SetBallScale( ballScale );
6454 if ( shrinkSize > 0 )
6455 aSmeshActor->SetShrinkFactor( shrinkSize );
6456 // orientation vectors
6457 if ( orientationSize > 0 ) {
6458 aSmeshActor->SetFacesOrientationScale( orientationSize );
6459 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6463 else if (paramNameStr == "PointMarker") {
6464 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6465 if( data.count() >= 2 ) {
6467 int aParam1 = data[1].toInt( &ok );
6469 if( data[0] == "std" && data.count() == 3 ) {
6470 int aParam2 = data[2].toInt( &ok );
6471 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6473 else if( data[0] == "custom" ) {
6474 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6475 if( markerIt != aMarkerMap.end() ) {
6476 VTK::MarkerData aMarkerData = markerIt->second;
6477 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6484 else if (paramNameStr == "Opacity") {
6485 aSmeshActor->SetOpacity(val.toFloat());
6488 else if (paramNameStr.startsWith("ClippingPlane")) {
6489 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6490 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6491 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6492 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6493 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6494 // new format - val looks like "Off" or "0" (plane id)
6495 // (note: in new format "Off" value is used only for consistency,
6496 // so it is processed together with values in old format)
6497 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6498 if( anIsOldFormat ) {
6499 if (paramNameStr == "ClippingPlane1" || val == "Off")
6500 aSmeshActor->RemoveAllClippingPlanes();
6502 QList<SUIT_ViewManager*> lst;
6503 getApp()->viewManagers(viewerTypStr, lst);
6504 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6505 if (viewIndex >= 0 && viewIndex < lst.count()) {
6506 SUIT_ViewManager* vman = lst.at(viewIndex);
6507 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6509 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6511 SMESH::TActorList anActorList;
6512 anActorList.push_back( aSmeshActor );
6513 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6514 aPlane->myViewWindow = vtkView;
6515 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6516 aPlane->PlaneMode = aMode;
6517 bool isOpenGLClipping = ( bool )vals[1].toInt();
6518 aPlane->IsOpenGLClipping = isOpenGLClipping;
6519 if ( aMode == SMESH::Absolute ) {
6520 aPlane->myAbsoluteOrientation = vals[2].toInt();
6521 aPlane->X = vals[3].toFloat();
6522 aPlane->Y = vals[4].toFloat();
6523 aPlane->Z = vals[5].toFloat();
6524 aPlane->Dx = vals[6].toFloat();
6525 aPlane->Dy = vals[7].toFloat();
6526 aPlane->Dz = vals[8].toFloat();
6528 else if ( aMode == SMESH::Relative ) {
6529 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6530 aPlane->myDistance = vals[3].toFloat();
6531 aPlane->myAngle[0] = vals[4].toFloat();
6532 aPlane->myAngle[1] = vals[5].toFloat();
6536 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6537 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6538 aClippingPlaneInfo.Plane = aPlane;
6539 aClippingPlaneInfo.ActorList = anActorList;
6540 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6548 int aPlaneId = val.toInt( &ok );
6549 if( ok && aPlaneId >= 0 ) {
6550 bool anIsDefinedPlane = false;
6551 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6552 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6553 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6554 TPlaneInfo& aPlaneInfo = *anIter;
6555 if( aPlaneInfo.PlaneId == aPlaneId ) {
6556 aPlaneInfo.ActorList.push_back( aSmeshActor );
6557 anIsDefinedPlane = true;
6561 if( !anIsDefinedPlane ) {
6562 TPlaneInfo aPlaneInfo;
6563 aPlaneInfo.PlaneId = aPlaneId;
6564 aPlaneInfo.ActorList.push_back( aSmeshActor );
6565 aPlaneInfo.ViewManager = vman;
6567 // to make the list sorted by plane id
6568 anIter = aPlaneInfoList.begin();
6569 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6570 const TPlaneInfo& aPlaneInfoRef = *anIter;
6571 if( aPlaneInfoRef.PlaneId > aPlaneId )
6574 aPlaneInfoList.insert( anIter, aPlaneInfo );
6579 } // if (aSmeshActor)
6580 } // other parameters than Visibility
6582 } // for names/parameters iterator
6583 } // for entries iterator
6585 // take into account planes with empty list of actors referred to them
6586 QList<SUIT_ViewManager*> aVMList;
6587 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6589 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6590 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6591 int aViewId = aPlaneDataIter->first;
6592 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6593 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6595 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6597 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6598 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6599 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6600 const TPlaneData& aPlaneData = *anIter2;
6601 int aPlaneId = aPlaneData.Id;
6603 bool anIsFound = false;
6604 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6605 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6606 const TPlaneInfo& aPlaneInfo = *anIter3;
6607 if( aPlaneInfo.PlaneId == aPlaneId ) {
6614 TPlaneInfo aPlaneInfo; // ActorList field is empty
6615 aPlaneInfo.PlaneId = aPlaneId;
6616 aPlaneInfo.ViewManager = aViewManager;
6618 // to make the list sorted by plane id
6619 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6620 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6621 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6622 if( aPlaneInfoRef.PlaneId > aPlaneId )
6625 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6631 // add clipping planes to actors according to the restored parameters
6632 // and update the clipping plane map
6633 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6634 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6635 int aViewId = anIter1->first;
6636 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6638 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6639 if( anIter2 == aPlaneDataMap.end() )
6641 const TPlaneDataList& aPlaneDataList = anIter2->second;
6643 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6644 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6645 const TPlaneInfo& aPlaneInfo = *anIter3;
6646 int aPlaneId = aPlaneInfo.PlaneId;
6647 const TActorList& anActorList = aPlaneInfo.ActorList;
6648 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6652 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6656 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6658 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6659 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6660 const TPlaneData& aPlaneData = *anIter4;
6661 if( aPlaneData.Id == aPlaneId ) {
6662 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6663 aPlane->myViewWindow = aViewWindow;
6664 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6665 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6666 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6667 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6668 aPlane->X = aPlaneData.X;
6669 aPlane->Y = aPlaneData.Y;
6670 aPlane->Z = aPlaneData.Z;
6671 aPlane->Dx = aPlaneData.Dx;
6672 aPlane->Dy = aPlaneData.Dy;
6673 aPlane->Dz = aPlaneData.Dz;
6675 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6676 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6677 aPlane->myDistance = aPlaneData.Distance;
6678 aPlane->myAngle[0] = aPlaneData.Angle[0];
6679 aPlane->myAngle[1] = aPlaneData.Angle[1];
6682 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6683 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6684 aClippingPlaneInfo.Plane = aPlane;
6685 aClippingPlaneInfo.ActorList = anActorList;
6686 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6697 // update all VTK views
6698 QList<SUIT_ViewManager*> lst;
6699 getApp()->viewManagers(lst);
6700 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6701 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6702 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6703 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6704 // set OpenGL clipping planes
6705 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6706 vtkActorCollection* anAllActors = aCopy.GetActors();
6707 anAllActors->InitTraversal();
6708 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6709 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6710 anActor->SetOpenGLClippingPlane();
6712 vtkView->getRenderer()->ResetCameraClippingRange();
6719 \brief Adds preferences for dfont of VTK viewer
6721 \param pIf group identifier
6722 \param param parameter
6723 \return identifier of preferences
6725 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6727 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6729 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6732 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6733 fam.append( tr( "SMESH_FONT_COURIER" ) );
6734 fam.append( tr( "SMESH_FONT_TIMES" ) );
6736 setPreferenceProperty( tfont, "fonts", fam );
6738 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6739 if ( needSize ) f = f | QtxFontEdit::Size;
6740 setPreferenceProperty( tfont, "features", f );
6746 \brief Actions after hypothesis edition
6747 Updates object browser after hypothesis edition
6749 void SMESHGUI::onHypothesisEdit( int result )
6752 SMESHGUI::Modified();
6753 updateObjBrowser( true );
6758 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6759 \param pview view being closed
6761 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6762 #ifndef DISABLE_PLOT2DVIEWER
6763 //Crear all Plot2d Viewers if need.
6764 SMESH::ClearPlot2Viewers(pview);
6768 void SMESHGUI::message( const QString& msg )
6771 QStringList data = msg.split("/");
6772 if ( data.count() > 0 ) {
6773 if ( data.first() == "mesh_loading" ) {
6775 QString entry = data.count() > 1 ? data[1] : QString();
6776 if ( entry.isEmpty() )
6779 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6781 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6784 name = QString::fromUtf8(obj->GetName().c_str());
6785 if ( name.isEmpty() )
6788 if ( data.last() == "stop" )
6789 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6791 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6792 QApplication::processEvents();
6798 \brief Connects or disconnects signals about activating and cloning view on the module slots
6799 \param pview view which is connected/disconnected
6801 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6805 SUIT_ViewManager* viewMgr = pview->getViewManager();
6807 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6808 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6810 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6811 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6816 \brief Return \c true if object can be renamed
6818 bool SMESHGUI::renameAllowed( const QString& entry) const {
6819 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6823 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6827 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6832 if(appStudy->isComponent(entry) || obj->isReference())
6835 // check type to prevent renaming of inappropriate objects
6836 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6837 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6838 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6839 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6840 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6841 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6848 Rename object by entry.
6849 \param entry entry of the object
6850 \param name new name of the object
6851 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6853 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6855 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6859 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6864 _PTR(Study) aStudy = appStudy->studyDS();
6869 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6871 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6876 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6877 _PTR(GenericAttribute) anAttr;
6878 _PTR(AttributeName) aName;
6880 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6882 // check type to prevent renaming of inappropriate objects
6883 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6884 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6885 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6886 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6887 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6888 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6889 if ( !name.isEmpty() ) {
6890 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6892 // update name of group object and its actor
6893 Handle(SALOME_InteractiveObject) IObject =
6894 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6896 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6897 if( !aGroupObject->_is_nil() ) {
6898 aGroupObject->SetName( qPrintable(name) );
6899 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6900 anActor->setName( qPrintable(name) );
6910 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6912 static QList<QColor> colors;
6914 if ( colors.isEmpty() ) {
6916 for (int s = 0; s < 2 ; s++)
6918 for (int v = 100; v >= 40; v = v - 20)
6920 for (int h = 0; h < 359 ; h = h + 60)
6922 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
6927 static int currentColor = 0;
6929 SALOMEDS::Color color;
6930 color.R = (double)colors[currentColor].red() / 255.0;
6931 color.G = (double)colors[currentColor].green() / 255.0;
6932 color.B = (double)colors[currentColor].blue() / 255.0;
6934 currentColor = (currentColor+1) % colors.count();