1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FieldSelectorWdg.h"
48 #include "SMESHGUI_FileInfoDlg.h"
49 #include "SMESHGUI_FileValidator.h"
50 #include "SMESHGUI_FilterDlg.h"
51 #include "SMESHGUI_FilterLibraryDlg.h"
52 #include "SMESHGUI_FindElemByPointDlg.h"
53 #include "SMESHGUI_GroupDlg.h"
54 #include "SMESHGUI_GroupOnShapeDlg.h"
55 #include "SMESHGUI_GroupOpDlg.h"
56 #include "SMESHGUI_Hypotheses.h"
57 #include "SMESHGUI_Make2DFrom3DOp.h"
58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
59 #include "SMESHGUI_Measurements.h"
60 #include "SMESHGUI_MergeDlg.h"
61 #include "SMESHGUI_MeshInfo.h"
62 #include "SMESHGUI_MeshOp.h"
63 #include "SMESHGUI_MeshOrderOp.h"
64 #include "SMESHGUI_MeshPatternDlg.h"
65 #include "SMESHGUI_MultiEditDlg.h"
66 #include "SMESHGUI_NodesDlg.h"
67 #include "SMESHGUI_Operations.h"
68 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
69 #include "SMESHGUI_PropertiesDlg.h"
70 #include "SMESHGUI_RemoveElementsDlg.h"
71 #include "SMESHGUI_RemoveNodesDlg.h"
72 #include "SMESHGUI_RenumberingDlg.h"
73 #include "SMESHGUI_ReorientFacesDlg.h"
74 #include "SMESHGUI_RevolutionDlg.h"
75 #include "SMESHGUI_RotationDlg.h"
76 #include "SMESHGUI_ScaleDlg.h"
77 #include "SMESHGUI_Selection.h"
78 #include "SMESHGUI_SewingDlg.h"
79 #include "SMESHGUI_SingleEditDlg.h"
80 #include "SMESHGUI_SmoothingDlg.h"
81 #include "SMESHGUI_SymmetryDlg.h"
82 #include "SMESHGUI_TranslationDlg.h"
83 #include "SMESHGUI_TransparencyDlg.h"
84 #include "SMESHGUI_DisplayEntitiesDlg.h"
85 #include "SMESHGUI_SplitBiQuad.h"
87 #include "SMESHGUI_FilterUtils.h"
88 #include "SMESHGUI_GEOMGenUtils.h"
89 #include "SMESHGUI_GroupUtils.h"
90 #include "SMESHGUI_HypothesesUtils.h"
91 #include "SMESHGUI_MeshUtils.h"
92 #include "SMESHGUI_PatternUtils.h"
93 #include "SMESHGUI_Utils.h"
94 #include "SMESHGUI_VTKUtils.h"
96 #include "SMESH_version.h"
98 #include "SMESH_ControlsDef.hxx"
99 #include "SMESH_Actor.h"
100 #include "SMESH_ActorUtils.h"
101 #include "SMESH_Client.hxx"
102 #include "SMESH_ScalarBarActor.h"
103 #include "SMESH_TypeFilter.hxx"
105 // SALOME GUI includes
106 #include <SalomeApp_Application.h>
107 #include <SalomeApp_CheckFileDlg.h>
108 #include <SalomeApp_DataObject.h>
109 #include <SalomeApp_Study.h>
110 #include <SalomeApp_Tools.h>
112 #include <LightApp_DataOwner.h>
113 #include <LightApp_NameDlg.h>
114 #include <LightApp_Preferences.h>
115 #include <LightApp_SelectionMgr.h>
116 #include <LightApp_UpdateFlags.h>
118 #include <SVTK_ViewManager.h>
119 #include <SVTK_ViewModel.h>
120 #include <SVTK_ViewWindow.h>
122 #include <VTKViewer_Algorithm.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>
136 #ifndef DISABLE_PLOT2DVIEWER
137 #include <SPlot2d_ViewModel.h>
138 #include <SPlot2d_Histogram.h>
142 #include <SALOMEconfig.h>
143 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
144 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
145 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
148 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
149 #include <QApplication>
151 #include <QTextStream>
156 #include <boost/shared_ptr.hpp>
159 #include <vtkCallbackCommand.h>
160 #include <vtkCamera.h>
161 #include <vtkLookupTable.h>
162 #include <vtkPlane.h>
163 #include <vtkRenderer.h>
165 // SALOME KERNEL includes
166 #include <SALOMEDSClient_ClientFactory.hxx>
167 #include <SALOMEDSClient_IParameters.hxx>
168 #include <SALOMEDSClient_SComponent.hxx>
169 #include <SALOMEDSClient_StudyBuilder.hxx>
170 #include <SALOMEDS_Study.hxx>
171 #include <SALOMEDS_SObject.hxx>
172 #include "utilities.h"
175 #include <Standard_ErrorHandler.hxx>
176 #include <NCollection_DataMap.hxx>
177 #include <NCollection_DoubleMap.hxx>
179 #include <Basics_Utils.hxx>
181 // Below macro, when uncommented, switches on simplified (more performant) algorithm
182 // of auto-color picking up
183 #define SIMPLE_AUTOCOLOR
188 //=============================================================
189 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
192 void ExportMeshToFile(int theCommandID);
194 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
196 void SetDisplayEntity(int theCommandID);
198 int ActionToControl( int theID, bool theReversed = false );
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 ||
423 theCommandID == SMESHOp::OpPopupExportDAT );
424 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
425 theCommandID == SMESHOp::OpPopupExportMED );
426 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
427 theCommandID == SMESHOp::OpPopupExportUNV );
428 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
429 theCommandID == SMESHOp::OpPopupExportSTL );
431 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
432 theCommandID == SMESHOp::OpPopupExportCGNS );
434 const bool isCGNS= false;
436 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
437 theCommandID == SMESHOp::OpPopupExportSAUV );
438 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
439 theCommandID == SMESHOp::OpPopupExportGMF );
441 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
442 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
445 // get mesh object from selection and check duplication of their names
446 bool hasDuplicatedMeshNames = false;
447 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
448 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
449 SALOME_ListIteratorOfListIO It( selected );
450 for( ; It.More(); It.Next() )
452 Handle(SALOME_InteractiveObject) anIObject = It.Value();
453 SMESH::SMESH_IDSource_var aMeshItem =
454 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
455 if ( aMeshItem->_is_nil() ) {
456 SUIT_MessageBox::warning( SMESHGUI::desktop(),
457 QObject::tr( "SMESH_WRN_WARNING" ),
458 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
462 QString aMeshName = anIObject->getName();
464 // check for name duplications
465 if ( !hasDuplicatedMeshNames )
466 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
467 if( aMeshName == (*aMeshIter).second ) {
468 hasDuplicatedMeshNames = true;
473 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
476 if( hasDuplicatedMeshNames && isMED ) {
477 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
478 QObject::tr("SMESH_WRN_WARNING"),
479 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
480 QObject::tr("SMESH_BUT_YES"),
481 QObject::tr("SMESH_BUT_NO"), 0, 1);
486 aMeshIter = aMeshList.begin();
487 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
488 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
489 QString aMeshName = (*aMeshIter).second;
491 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
493 // check for equal group names within each mesh
494 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
495 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
496 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
497 int aRet = SUIT_MessageBox::warning
498 (SMESHGUI::desktop(),
499 QObject::tr("SMESH_WRN_WARNING"),
500 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
501 QObject::tr("SMESH_BUT_YES"),
502 QObject::tr("SMESH_BUT_NO"), 0, 1);
509 // Warn the user about presence of not supported elements
511 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
515 notSupportedElemTypes.push_back( SMESH::Entity_0D );
516 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
521 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
522 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
523 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
524 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
525 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
526 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
527 notSupportedElemTypes.push_back( SMESH::Entity_0D );
528 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
533 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
534 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
535 notSupportedElemTypes.push_back( SMESH::Entity_0D );
536 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
541 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
546 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
547 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
548 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
549 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
550 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
551 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
552 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
553 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
558 notSupportedElemTypes.push_back( SMESH::Entity_0D );
559 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
560 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
561 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
562 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
563 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
564 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
565 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
566 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
568 if ( ! notSupportedElemTypes.empty() )
570 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
571 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
572 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
573 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
575 if ( !presentNotSupported.empty() )
578 const char* typeMsg[] = {
579 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
580 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
581 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
582 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
583 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
584 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
585 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
586 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
588 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
589 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
590 int _assert[( nbTypes == SMESH::Entity_Last ) ? 1 : -1 ]; _assert[0]=1;
592 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
593 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
594 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
595 if ( iType != presentNotSupported.size() - 1 )
596 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
598 int aRet = SUIT_MessageBox::warning
599 (SMESHGUI::desktop(),
600 QObject::tr("SMESH_WRN_WARNING"),
601 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
602 QObject::tr("SMESH_BUT_YES"),
603 QObject::tr("SMESH_BUT_NO"), 0, 1);
608 // Get parameters of export operation
611 SMESH::MED_VERSION aFormat;
612 // Init the parameters with the default values
613 bool aIsASCII_STL = true;
614 bool toCreateGroups = false;
615 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
617 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
618 bool toOverwrite = true;
619 bool toFindOutDim = true;
621 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
622 QString anInitialPath = "";
623 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
624 anInitialPath = QDir::currentPath();
626 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
628 // Get a file name to write in and additional otions
629 if ( isUNV || isDAT || isGMF ) // Export w/o options
632 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
634 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
636 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
637 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
638 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
639 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
640 anInitialPath + QString("/") + aMeshName,
641 aFilter, aTitle, false);
643 else if ( isCGNS )// Export to CGNS
645 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
646 fd->setWindowTitle( aTitle );
647 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
648 if ( !anInitialPath.isEmpty() )
649 fd->setDirectory( anInitialPath );
650 fd->selectFile(aMeshName);
651 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
652 fd->setValidator( fv );
655 aFilename = fd->selectedFile();
656 toOverwrite = fv->isOverwrite();
660 else if ( isSTL ) // Export to STL
662 QMap<QString, int> aFilterMap;
663 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
664 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
667 QMap<QString, int>::const_iterator it = aFilterMap.begin();
668 for ( ; it != aFilterMap.end(); ++it )
669 filters.push_back( it.key() );
671 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
672 fd->setWindowTitle( aTitle );
673 fd->setNameFilters( filters );
674 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
675 if ( !anInitialPath.isEmpty() )
676 fd->setDirectory( anInitialPath );
677 fd->selectFile(aMeshName);
681 aFilename = fd->selectedFile();
682 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
687 else if ( isMED || isSAUV ) // Export to MED or SAUV
689 QMap<QString, SMESH::MED_VERSION> aFilterMap;
690 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
692 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
693 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
694 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
697 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
698 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
699 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
703 QString aDefaultFilter;
704 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
705 for ( ; it != aFilterMap.end(); ++it ) {
706 filters.push_back( it.key() );
707 if (it.value() == SMESH::MED_V2_2)
708 aDefaultFilter = it.key();
710 QStringList checkBoxes;
711 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
713 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
714 QList< QWidget* > wdgList;
715 if ( fieldSelWdg->GetAllFeilds( aMeshList, aFieldList ))
716 wdgList.append( fieldSelWdg );
718 SalomeApp_CheckFileDlg* fd =
719 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
720 fd->setWindowTitle( aTitle );
721 fd->setNameFilters( filters );
722 fd->selectNameFilter( aDefaultFilter );
723 fd->SetChecked( toCreateGroups, 0 );
724 fd->SetChecked( toFindOutDim, 1 );
725 if ( !anInitialPath.isEmpty() )
726 fd->setDirectory( anInitialPath );
727 fd->selectFile(aMeshName);
730 QListView *lview = fd->findChild<QListView*>("listView");
732 lview->setMinimumHeight(200);
734 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
736 tview->setMinimumHeight(200);
739 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
740 fd->setValidator( fv );
745 aFilename = fd->selectedFile();
747 aFilename = QString::null;
750 aFormat = aFilterMap[fd->selectedNameFilter()];
751 toOverwrite = fv->isOverwrite();
753 if ( !aFilename.isEmpty() ) {
754 // med-2.1 does not support poly elements
755 if ( aFormat==SMESH::MED_V2_1 )
756 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
757 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
758 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
759 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
760 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
762 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
763 QObject::tr("SMESH_WRN_WARNING"),
764 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
765 QObject::tr("SMESH_BUT_YES"),
766 QObject::tr("SMESH_BUT_NO"), 0, 1);
774 // can't append to an existing using other format
775 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
776 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
777 if( !isVersionOk || aVersion != aFormat ) {
778 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
779 QObject::tr("SMESH_WRN_WARNING"),
780 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
781 QObject::tr("SMESH_BUT_YES"),
782 QObject::tr("SMESH_BUT_NO"), 0, 1);
789 QStringList aMeshNamesCollisionList;
790 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
791 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
792 QString anExistingMeshName( aMeshNames[ i ] );
793 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
794 QString anExportMeshName = (*aMeshIter).second;
795 if( anExportMeshName == anExistingMeshName ) {
796 aMeshNamesCollisionList.append( anExportMeshName );
801 if( !aMeshNamesCollisionList.isEmpty() ) {
802 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
803 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
804 QObject::tr("SMESH_WRN_WARNING"),
805 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
806 QObject::tr("SMESH_BUT_YES"),
807 QObject::tr("SMESH_BUT_NO"),
808 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
817 toCreateGroups = fd->IsChecked(0);
818 toFindOutDim = fd->IsChecked(1);
819 fieldSelWdg->GetSelectedFeilds();
820 if ( !fieldSelWdg->parent() )
831 if ( !aFilename.isEmpty() ) {
832 // Check whether the file already exists and delete it if yes
833 QFile aFile( aFilename );
834 if ( aFile.exists() && toOverwrite )
836 SUIT_OverrideCursor wc;
839 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
840 // bool Renumber = false;
841 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
843 // Renumber= resMgr->booleanValue("renumbering");
845 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
846 // aMeshEditor->RenumberNodes();
847 // aMeshEditor->RenumberElements();
848 // if ( SMESHGUI::automaticUpdate() )
849 // SMESH::UpdateView();
853 aMeshIter = aMeshList.begin();
854 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
856 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
857 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
858 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
859 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
860 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
861 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
862 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
863 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
865 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
866 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
867 fields, geoAssFields.toLatin1().data() );
872 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
874 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
875 if( !aMeshItem->_is_nil() )
876 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
881 if ( aMeshOrGroup->_is_equivalent( aMesh ))
882 aMesh->ExportDAT( aFilename.toUtf8().data() );
884 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
888 if ( aMeshOrGroup->_is_equivalent( aMesh ))
889 aMesh->ExportUNV( aFilename.toUtf8().data() );
891 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
895 if ( aMeshOrGroup->_is_equivalent( aMesh ))
896 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
898 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
902 aMeshIter = aMeshList.begin();
903 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
905 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
906 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
907 aMeshItem->ExportCGNS( aMeshOrGroup,
908 aFilename.toUtf8().data(),
909 toOverwrite && aMeshIndex == 0 );
914 toCreateGroups = true;
915 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
918 catch (const SALOME::SALOME_Exception& S_ex){
920 SUIT_MessageBox::warning(SMESHGUI::desktop(),
921 QObject::tr("SMESH_WRN_WARNING"),
922 QObject::tr("SMESH_EXPORT_FAILED"));
928 inline void InverseEntityMode(unsigned int& theOutputMode,
929 unsigned int theMode)
931 bool anIsNotPresent = ~theOutputMode & theMode;
933 theOutputMode |= theMode;
935 theOutputMode &= ~theMode;
938 void SetDisplayEntity(int theCommandID)
940 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
941 SALOME_ListIO selected;
943 aSel->selectedObjects( selected );
945 if ( selected.Extent() >= 1 ) {
946 SALOME_ListIteratorOfListIO It( selected );
947 for( ; It.More(); It.Next()){
948 Handle(SALOME_InteractiveObject) IObject = It.Value();
949 if(IObject->hasEntry()){
950 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
951 unsigned int aMode = anActor->GetEntityMode();
952 switch(theCommandID){
953 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
954 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
955 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
956 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
957 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
958 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
961 anActor->SetEntityMode(aMode);
970 SalomeApp_Application* app =
971 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
975 LightApp_SelectionMgr* aSel = app->selectionMgr();
976 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
977 if ( !aSel || !appStudy )
980 SALOME_ListIO selected;
981 aSel->selectedObjects( selected );
982 if ( selected.IsEmpty() )
985 Handle(SALOME_InteractiveObject) anIObject = selected.First();
987 _PTR(Study) aStudy = appStudy->studyDS();
988 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
989 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
990 if ( aMainObject->_is_nil() )
993 SUIT_OverrideCursor wc;
995 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
997 QList<SALOMEDS::Color> aReservedColors;
999 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1000 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1002 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1004 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1005 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1006 #else // old algorithm for auto-colors
1007 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1008 aReservedColors.append( aColor );
1009 #endif // SIMPLE_AUTOCOLOR
1010 aGroupObject->SetColor( aColor );
1012 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1013 if ( aGroupSObject ) {
1016 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1017 switch ( aGroupObject->GetType ()) {
1019 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1021 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1023 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1025 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1027 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1028 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1031 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1032 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1038 SMESH::RepaintCurrentView();
1041 void OverallMeshQuality()
1043 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1044 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1045 SALOME_ListIO selected;
1047 aSel->selectedObjects( selected );
1049 if ( selected.IsEmpty() ) return;
1050 SALOME_ListIteratorOfListIO It( selected );
1051 for ( ; It.More(); It.Next() ) {
1052 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1053 ctrlDlg->showInfo( It.Value() );
1058 QString functorToString( SMESH::Controls::FunctorPtr f )
1060 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1061 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1062 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1063 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1064 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1065 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1066 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1067 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1068 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1069 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1070 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1071 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1072 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1073 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1074 type = QObject::tr( "WARP_ELEMENTS" );
1075 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1076 type = QObject::tr( "TAPER_ELEMENTS" );
1077 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1078 type = QObject::tr( "SKEW_ELEMENTS" );
1079 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1080 type = QObject::tr( "AREA_ELEMENTS" );
1081 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1082 type = QObject::tr( "LENGTH_EDGES" );
1083 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1084 type = QObject::tr( "LENGTH2D_EDGES" );
1085 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1086 type = QObject::tr( "MULTI_BORDERS" );
1087 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1088 type = QObject::tr( "MULTI2D_BORDERS" );
1089 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1090 type = QObject::tr( "FREE_NODES" );
1091 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1092 type = QObject::tr( "FREE_EDGES" );
1093 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1094 type = QObject::tr( "FREE_BORDERS" );
1095 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1096 type = QObject::tr( "FREE_FACES" );
1097 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1098 type = QObject::tr( "BARE_BORDER_VOLUME" );
1099 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1100 type = QObject::tr( "BARE_BORDER_FACE" );
1101 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1102 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1103 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1104 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1105 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1106 type = QObject::tr( "EQUAL_NODE" );
1107 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1108 type = QObject::tr( "EQUAL_EDGE" );
1109 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1110 type = QObject::tr( "EQUAL_FACE" );
1111 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1112 type = QObject::tr( "EQUAL_VOLUME" );
1116 void SaveDistribution()
1118 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1119 SALOME_ListIO selected;
1121 aSel->selectedObjects( selected );
1123 if ( selected.Extent() == 1 ) {
1124 Handle(SALOME_InteractiveObject) anIO = selected.First();
1125 if ( anIO->hasEntry() ) {
1126 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1128 anActor->GetScalarBarActor() &&
1129 anActor->GetControlMode() != SMESH_Actor::eNone )
1131 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1132 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1133 if ( aScalarBarActor && aFunctor ) {
1134 SMESH::Controls::NumericalFunctor* aNumFun =
1135 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1137 std::vector<int> elements;
1138 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1139 if ( mesh->_is_nil() ) {
1140 SMESH::SMESH_IDSource_var idSource =
1141 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1142 if ( !idSource->_is_nil() )
1144 SMESH::long_array_var ids = idSource->GetIDs();
1145 elements.resize( ids->length() );
1146 for ( unsigned i = 0; i < elements.size(); ++i )
1147 elements[i] = ids[i];
1150 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1151 vtkLookupTable* lookupTable =
1152 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1153 double * minmax = lookupTable->GetRange();
1154 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1155 std::vector<int> nbEvents;
1156 std::vector<double> funValues;
1157 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1158 elements, minmax, isLogarithmic );
1159 QString anInitialPath = "";
1160 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1161 anInitialPath = QDir::currentPath();
1162 QString aMeshName = anIO->getName();
1164 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1165 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1166 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1167 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1168 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1171 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1173 if ( !aFilename.isEmpty() ) {
1174 QFile f( aFilename );
1175 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1176 QTextStream out( &f );
1177 out << "# Mesh: " << aMeshName << endl;
1178 out << "# Control: " << functorToString( aFunctor ) << endl;
1180 out.setFieldWidth( 10 );
1181 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1182 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1193 void ShowElement( int theCommandID )
1195 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1196 SALOME_ListIO selected;
1198 aSel->selectedObjects( selected );
1200 if ( selected.Extent() == 1 ) {
1201 Handle(SALOME_InteractiveObject) anIO = selected.First();
1202 if ( anIO->hasEntry() ) {
1203 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1205 anActor->GetScalarBarActor() &&
1206 anActor->GetControlMode() != SMESH_Actor::eNone )
1208 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1209 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1210 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1212 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1213 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1220 #ifndef DISABLE_PLOT2DVIEWER
1221 void PlotDistribution()
1223 SalomeApp_Application* app =
1224 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1228 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1229 SALOME_ListIO selected;
1231 aSel->selectedObjects( selected );
1233 if ( selected.Extent() == 1 ) {
1234 Handle(SALOME_InteractiveObject) anIO = selected.First();
1235 if ( anIO->hasEntry() ) {
1236 //Find Actor by entry before getting Plot2d viewer,
1237 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1238 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1240 SUIT_ViewManager* aViewManager =
1241 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1245 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1249 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1253 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1255 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1256 QString functorName = functorToString( anActor->GetFunctor());
1257 QString aHistogramName("%1 : %2");
1258 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1259 aHistogram->setName(aHistogramName);
1260 aHistogram->setHorTitle(functorName);
1261 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1262 aPlot->displayObject(aHistogram, true);
1267 #endif //DISABLE_PLOT2DVIEWER
1269 void DisableAutoColor()
1271 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1272 SALOME_ListIO selected;
1274 aSel->selectedObjects( selected );
1276 if ( selected.Extent() ) {
1277 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1278 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1279 if ( !aMesh->_is_nil() ) {
1280 aMesh->SetAutoColor( false );
1287 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1288 SALOME_ListIO selected;
1290 aSel->selectedObjects( selected );
1291 if ( selected.Extent() )
1293 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1294 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1295 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1297 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1298 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1305 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1307 SALOME_ListIO selected;
1308 SalomeApp_Application* app =
1309 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1313 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1314 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1315 if ( !aSel || !appStudy )
1318 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1319 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1320 aModule->EmitSignalDeactivateDialog();
1321 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1322 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1327 _PTR(Study) aStudy = appStudy->studyDS();
1329 aSel->selectedObjects( selected );
1331 if ( selected.Extent() >= 1 )
1333 switch ( theCommandID ) {
1334 case SMESHOp::OpTransparency:
1336 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1337 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1340 case SMESHOp::OpProperties:
1343 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1344 QColor orientationColor, outlineColor, volumeColor;
1345 int deltaF = 0, deltaV = 0;
1348 double ballScale = 1.0;
1350 int outlineWidth = 1;
1351 double shrinkCoef = 0.0;
1352 double orientationScale = 0.0;
1353 bool orientation3d = false;
1354 VTK::MarkerType markerType = VTK::MT_NONE;
1355 VTK::MarkerScale markerScale = VTK::MS_NONE;
1357 bool hasNodes = false;
1358 int presentEntities = 0;
1359 bool firstTime = true;
1361 SALOME_ListIteratorOfListIO It( selected );
1362 for ( ; It.More(); It.Next() ) {
1363 Handle(SALOME_InteractiveObject) IObject = It.Value();
1364 if ( !IObject->hasEntry() ) continue;
1365 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1366 if ( !anActor || !anActor->GetObject() ) continue;
1369 // nodes: color, marker
1370 anActor->GetNodeColor( color[0], color[1], color[2] );
1371 nodeColor.setRgbF( color[0], color[1], color[2] );
1372 markerType = anActor->GetMarkerType();
1373 markerScale = anActor->GetMarkerScale();
1374 markerId = anActor->GetMarkerTexture();
1375 // edges: color, width
1376 anActor->GetEdgeColor( color[0], color[1], color[2] );
1377 edgeColor.setRgbF( color[0], color[1], color[2] );
1378 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1379 // faces: front color, back color (delta)
1380 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1381 faceColor.setRgbF( color[0], color[1], color[2] );
1382 // faces: front color, back color (delta)
1383 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1384 volumeColor.setRgbF( color[0], color[1], color[2] );
1385 // 0d elements: color, size
1386 anActor->Get0DColor( color[0], color[1], color[2] );
1387 elem0dColor.setRgbF( color[0], color[1], color[2] );
1388 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1389 // balls: color, size
1390 anActor->GetBallColor( color[0], color[1], color[2] );
1391 ballColor.setRgbF( color[0], color[1], color[2] );
1392 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1393 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1395 anActor->GetOutlineColor( color[0], color[1], color[2] );
1396 outlineColor.setRgbF( color[0], color[1], color[2] );
1397 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1398 // orientation vectors: color, scale, 3d flag
1399 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1400 orientationColor.setRgbF( color[0], color[1], color[2] );
1401 orientationScale = anActor->GetFacesOrientationScale();
1402 orientation3d = anActor->GetFacesOrientation3DVectors();
1404 shrinkCoef = anActor->GetShrinkFactor();
1407 firstTime = false; // we only take properties from first object (for performance reasons)
1410 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1411 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1412 presentEntities = presentEntities | SMESH_Actor::eEdges;
1413 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1414 presentEntities = presentEntities | SMESH_Actor::eFaces;
1415 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1416 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1417 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1418 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1419 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1420 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1422 // as we know that all types of elements are present, we can exit the loop
1423 if ( presentEntities == SMESH_Actor::eAllEntity )
1427 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1428 // nodes: color, marker
1429 dlg.setNodeColor( nodeColor );
1430 if( markerType != VTK::MT_USER )
1431 dlg.setNodeMarker( markerType, markerScale );
1433 dlg.setNodeCustomMarker( markerId );
1434 // edges: color, line width
1435 dlg.setEdgeColor( edgeColor );
1436 dlg.setEdgeWidth( edgeWidth );
1437 // faces: front color, back color
1438 dlg.setFaceColor( faceColor, deltaF );
1439 // volumes: normal color, reversed color
1440 dlg.setVolumeColor( volumeColor, deltaV );
1441 // outlines: color, line width
1442 dlg.setOutlineColor( outlineColor );
1443 dlg.setOutlineWidth( outlineWidth );
1444 // 0d elements: color, size
1445 dlg.setElem0dColor( elem0dColor );
1446 dlg.setElem0dSize( elem0dSize );
1447 // balls: color, size
1448 dlg.setBallColor( ballColor );
1449 //dlg.setBallSize( ballSize );
1450 dlg.setBallScale( ballScale );
1451 // orientation: color, scale, 3d flag
1452 dlg.setOrientationColor( orientationColor );
1453 dlg.setOrientationSize( int( orientationScale * 100. ) );
1454 dlg.setOrientation3d( orientation3d );
1455 // shrink: scale factor
1456 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1457 // hide unused controls
1458 dlg.showControls( presentEntities, hasNodes );
1461 nodeColor = dlg.nodeColor();
1462 markerType = dlg.nodeMarkerType();
1463 markerScale = dlg.nodeMarkerScale();
1464 markerId = dlg.nodeMarkerId();
1465 edgeColor = dlg.edgeColor();
1466 edgeWidth = dlg.edgeWidth();
1467 faceColor = dlg.faceColor();
1468 deltaF = dlg.faceColorDelta();
1469 volumeColor = dlg.volumeColor();
1470 deltaV = dlg.volumeColorDelta();
1471 outlineColor = dlg.outlineColor();
1472 outlineWidth = dlg.outlineWidth();
1473 elem0dColor = dlg.elem0dColor();
1474 elem0dSize = dlg.elem0dSize();
1475 ballColor = dlg.ballColor();
1476 // ballSize = dlg.ballSize();
1477 ballScale = dlg.ballScale();
1478 orientationColor = dlg.orientationColor();
1479 orientationScale = dlg.orientationSize() / 100.;
1480 orientation3d = dlg.orientation3d();
1481 shrinkCoef = dlg.shrinkCoef() / 100.;
1483 // store point markers map that might be changed by the user
1484 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1486 // set properties from dialog box to the presentations
1487 SALOME_ListIteratorOfListIO It( selected );
1488 for ( ; It.More(); It.Next() ) {
1489 Handle(SALOME_InteractiveObject) IObject = It.Value();
1490 if ( !IObject->hasEntry() ) continue;
1491 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1492 if ( !anActor ) continue;
1494 // nodes: color, marker
1495 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1496 if ( markerType != VTK::MT_USER ) {
1497 anActor->SetMarkerStd( markerType, markerScale );
1500 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1501 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1502 if ( iter != markerMap.end() )
1503 anActor->SetMarkerTexture( markerId, iter->second.second );
1505 // volumes: normal color, reversed color (delta)
1506 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1507 // faces: front color, back color (delta)
1508 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1509 // edges: color, width
1510 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1511 anActor->SetLineWidth( edgeWidth );
1513 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1514 anActor->SetOutlineWidth( outlineWidth );
1515 // 0D elements: color, size
1516 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1517 anActor->Set0DSize( elem0dSize );
1518 // balls: color, size
1519 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1520 // anActor->SetBallSize( ballSize );
1521 anActor->SetBallScale( ballScale );
1522 // orientation: color, scale, 3d flag
1523 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1524 anActor->SetFacesOrientationScale( orientationScale );
1525 anActor->SetFacesOrientation3DVectors( orientation3d );
1527 anActor->SetShrinkFactor( shrinkCoef );
1529 // for groups, set also proper color
1530 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1531 if ( !aGroupObject->_is_nil() ) {
1532 SMESH::ElementType anElementType = aGroupObject->GetType();
1534 switch( anElementType ) {
1536 aColor = nodeColor; break;
1538 aColor = edgeColor; break;
1540 aColor = faceColor; break;
1542 aColor = volumeColor; break;
1544 aColor = elem0dColor; break;
1546 aColor = ballColor; break;
1550 if ( aColor.isValid() ) {
1551 SALOMEDS::Color aGroupColor;
1552 aGroupColor.R = aColor.redF();
1553 aGroupColor.G = aColor.greenF();
1554 aGroupColor.B = aColor.blueF();
1555 aGroupObject->SetColor( aGroupColor );
1557 } // if ( !aGroupObject->_is_nil() )
1558 } // for ( ; It.More(); It.Next() )
1559 SMESH::RepaintCurrentView();
1560 } // if ( dlg.exec() )
1562 } // case SMESHOp::OpProperties:
1563 } // switch(theCommandID)
1564 SALOME_ListIteratorOfListIO It( selected );
1565 for( ; It.More(); It.Next()){
1566 Handle(SALOME_InteractiveObject) IObject = It.Value();
1567 if(IObject->hasEntry()){
1568 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1569 switch(theCommandID){
1570 case SMESHOp::OpDMWireframe:
1571 anActor->SetRepresentation(SMESH_Actor::eEdge);
1573 case SMESHOp::OpDMShading:
1574 anActor->SetRepresentation(SMESH_Actor::eSurface);
1576 case SMESHOp::OpDMShrink:
1577 if(anActor->IsShrunk())
1578 anActor->UnShrink();
1580 anActor->SetShrink();
1582 case SMESHOp::OpDMNodes:
1583 anActor->SetRepresentation(SMESH_Actor::ePoint);
1585 case SMESHOp::OpRepresentationLines:
1586 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1587 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1589 case SMESHOp::OpRepresentationArcs:
1590 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1591 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1597 SMESH::RepaintCurrentView();
1601 int ActionToControl( int theID, bool theReversed )
1603 NCollection_DoubleMap<int,int> ActionControl;
1604 ActionControl.Bind( 0, SMESH_Actor::eNone );
1605 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1606 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1607 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1608 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1609 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1610 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1611 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1612 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1613 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1614 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1615 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1616 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1617 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1618 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1619 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1620 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1621 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1622 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1623 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1624 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1625 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1626 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1627 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1628 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1629 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1630 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1632 return theReversed ? ActionControl.Find2( theID ) : ActionControl.Find1( theID );
1635 void Control( int theCommandID )
1637 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ) );
1638 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1639 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1640 SALOME_ListIO selected;
1642 aSel->selectedObjects( selected );
1644 if ( !selected.IsEmpty() ) {
1645 SALOME_ListIteratorOfListIO It(selected);
1646 for ( ; It.More(); It.Next())
1648 Handle(SALOME_InteractiveObject) anIO = It.Value();
1650 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1652 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1653 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
1654 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
1655 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
1656 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
1657 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry()) ) {
1658 anActor->SetControlMode(aControl);
1659 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1660 SMESH::RepaintCurrentView();
1661 #ifndef DISABLE_PLOT2DVIEWER
1662 if ( anActor->GetPlot2Histogram() ) {
1663 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1664 QString functorName = functorToString( anActor->GetFunctor() );
1665 QString aHistogramName("%1 : %2");
1666 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1667 aHistogram->setName( aHistogramName );
1668 aHistogram->setHorTitle( functorName );
1669 SMESH::ProcessIn2DViewers( anActor );
1681 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1682 SMESH::MeshObjectType theType,
1683 const QString theInTypeName,
1684 QString & theOutTypeName)
1686 SMESH_TypeFilter aTypeFilter( theType );
1688 if ( !theIO.IsNull() )
1690 entry = theIO->getEntry();
1691 LightApp_DataOwner owner( entry );
1692 if ( aTypeFilter.isOk( &owner )) {
1693 theOutTypeName = theInTypeName;
1701 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1703 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1704 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1706 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1707 CORBA::String_var anID = aSComp->GetID().c_str();
1708 if ( !strcmp(anID.in(),theIO->getEntry()) )
1714 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1715 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1716 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1717 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1718 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1726 QString CheckHomogeneousSelection()
1728 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1729 SALOME_ListIO selected;
1731 aSel->selectedObjects( selected );
1733 QString RefType = CheckTypeObject(selected.First());
1734 SALOME_ListIteratorOfListIO It(selected);
1735 for ( ; It.More(); It.Next())
1737 Handle(SALOME_InteractiveObject) IObject = It.Value();
1738 QString Type = CheckTypeObject(IObject);
1739 if ( Type.compare(RefType) != 0 )
1740 return "Heterogeneous Selection";
1746 uint randomize( uint size )
1748 static bool initialized = false;
1749 if ( !initialized ) {
1750 qsrand( QDateTime::currentDateTime().toTime_t() );
1754 v = uint( (double)( v ) / RAND_MAX * size );
1755 v = qMax( uint(0), qMin ( v, size-1 ) );
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", "default_grp_color" };
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] + info[SMDSEntity_Quad_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 void SMESHGUI::EmitSignalCloseView()
2244 emit SignalCloseView();
2247 //=============================================================================
2251 //=============================================================================
2252 void SMESHGUI::EmitSignalActivatedViewManager()
2254 emit SignalActivatedViewManager();
2257 //=============================================================================
2261 //=============================================================================
2262 QDialog *SMESHGUI::GetActiveDialogBox()
2264 return myActiveDialogBox;
2267 //=============================================================================
2271 //=============================================================================
2272 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2274 myActiveDialogBox = (QDialog *) aDlg;
2278 //=============================================================================
2282 //=============================================================================
2283 SUIT_Desktop* SMESHGUI::desktop()
2285 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2287 return app->desktop();
2292 //=============================================================================
2296 //=============================================================================
2297 SalomeApp_Study* SMESHGUI::activeStudy()
2299 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2301 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2306 //=============================================================================
2310 //=============================================================================
2311 void SMESHGUI::Modified( bool theIsUpdateActions )
2313 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2314 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2315 appStudy->Modified();
2316 if( theIsUpdateActions )
2317 app->updateActions();
2322 //=============================================================================
2326 //=============================================================================
2327 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2329 /* Here the position is on the bottom right corner - 10 */
2330 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2332 SUIT_Desktop *PP = desktop();
2333 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2334 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2338 //=============================================================================
2342 //=============================================================================
2343 static int isStudyLocked(_PTR(Study) theStudy){
2344 return theStudy->GetProperties()->IsLocked();
2347 static bool checkLock(_PTR(Study) theStudy) {
2348 if (isStudyLocked(theStudy)) {
2349 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2350 QObject::tr("WRN_WARNING"),
2351 QObject::tr("WRN_STUDY_LOCKED") );
2357 //=======================================================================
2358 //function : CheckActiveStudyLocked
2360 //=======================================================================
2362 bool SMESHGUI::isActiveStudyLocked()
2364 _PTR(Study) aStudy = activeStudy()->studyDS();
2365 return checkLock( aStudy );
2368 //=============================================================================
2372 //=============================================================================
2373 bool SMESHGUI::OnGUIEvent( int theCommandID )
2375 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2379 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2380 SUIT_ResourceMgr* mgr = resourceMgr();
2384 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2385 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2388 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2389 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2391 //QAction* act = action( theCommandID );
2393 switch (theCommandID) {
2394 case SMESHOp::OpDelete:
2395 if(checkLock(aStudy)) break;
2398 case SMESHOp::OpImportDAT:
2399 case SMESHOp::OpImportUNV:
2400 case SMESHOp::OpImportMED:
2401 case SMESHOp::OpImportSTL:
2403 case SMESHOp::OpImportCGNS:
2405 case SMESHOp::OpImportSAUV:
2406 case SMESHOp::OpImportGMF:
2408 if(checkLock(aStudy)) break;
2409 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2413 case SMESHOp::OpFileInformation:
2415 SALOME_ListIO selected;
2416 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2418 aSel->selectedObjects( selected );
2419 if( selected.Extent() )
2421 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2422 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2423 if ( !aMesh->_is_nil() )
2425 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2431 case SMESHOp::OpExportDAT:
2432 case SMESHOp::OpExportMED:
2433 case SMESHOp::OpExportUNV:
2434 case SMESHOp::OpExportSTL:
2436 case SMESHOp::OpExportCGNS:
2438 case SMESHOp::OpExportSAUV:
2439 case SMESHOp::OpExportGMF:
2440 case SMESHOp::OpPopupExportDAT:
2441 case SMESHOp::OpPopupExportMED:
2442 case SMESHOp::OpPopupExportUNV:
2443 case SMESHOp::OpPopupExportSTL:
2445 case SMESHOp::OpPopupExportCGNS:
2447 case SMESHOp::OpPopupExportSAUV:
2448 case SMESHOp::OpPopupExportGMF:
2450 ::ExportMeshToFile(theCommandID);
2454 case SMESHOp::OpReset: // SCALAR BAR
2456 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2457 SALOME_ListIO selected;
2459 aSel->selectedObjects( selected );
2461 SALOME_ListIteratorOfListIO it(selected);
2462 for( ; it.More(); it.Next()) {
2463 Handle(SALOME_InteractiveObject) anIO = it.Value();
2464 if( anIO->hasEntry() ) {
2465 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2466 anActor->SetControlMode( SMESH_Actor::eNone );
2467 #ifndef DISABLE_PLOT2DVIEWER
2468 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2473 SMESH::UpdateView();
2476 case SMESHOp::OpScalarBarProperties:
2478 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2481 case SMESHOp::OpShowScalarBar:
2483 // show/hide scalar bar
2484 ::ShowElement(theCommandID);
2487 case SMESHOp::OpSaveDistribution:
2489 // dump control distribution data to the text file
2490 ::SaveDistribution();
2494 case SMESHOp::OpShowDistribution:
2496 // show/hide distribution
2497 ::ShowElement(theCommandID);
2501 #ifndef DISABLE_PLOT2DVIEWER
2502 case SMESHOp::OpPlotDistribution:
2504 // plot distribution
2505 ::PlotDistribution();
2511 case SMESHOp::OpAutoColor:
2515 case SMESHOp::OpDisableAutoColor:
2516 ::DisableAutoColor();
2519 case SMESHOp::OpClipping:
2520 case SMESHOp::OpTransparency:
2521 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2524 case SMESHOp::OpDMWireframe:
2525 case SMESHOp::OpDMShading:
2526 case SMESHOp::OpDMNodes:
2527 case SMESHOp::OpDMShrink:
2528 ::SetDisplayMode(theCommandID, myMarkerMap);
2531 //2D quadratic representation
2532 case SMESHOp::OpRepresentationLines:
2533 case SMESHOp::OpRepresentationArcs:
2534 ::SetDisplayMode(theCommandID, myMarkerMap);
2538 case SMESHOp::OpDE0DElements:
2539 case SMESHOp::OpDEEdges:
2540 case SMESHOp::OpDEFaces:
2541 case SMESHOp::OpDEVolumes:
2542 case SMESHOp::OpDEBalls:
2543 case SMESHOp::OpDEAllEntity:
2544 ::SetDisplayEntity(theCommandID);
2547 // Choose entities to be displayed
2548 case SMESHOp::OpDEChoose:
2550 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2554 case SMESHOp::OpOrientationOnFaces:
2556 LightApp_SelectionMgr* mgr = selectionMgr();
2557 SALOME_ListIO selected; mgr->selectedObjects( selected );
2559 SALOME_ListIteratorOfListIO it(selected);
2560 for( ; it.More(); it.Next()) {
2561 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2562 if(anIObject->hasEntry()) {
2563 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2564 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2571 case SMESHOp::OpUpdate:
2573 if(checkLock(aStudy)) break;
2574 SUIT_OverrideCursor wc;
2576 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2579 SMESH::UpdateView();
2581 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2582 SMESH::OnVisuException();
2584 catch (...) { // PAL16774 (Crash after display of many groups)
2585 SMESH::OnVisuException();
2589 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2590 aSel->selectedObjects( l );
2591 aSel->setSelectedObjects( l );
2595 case SMESHOp::OpHide:
2596 case SMESHOp::OpShow:
2597 case SMESHOp::OpShowOnly:
2599 SMESH::EDisplaing anAction;
2600 switch (theCommandID) {
2601 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2602 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2603 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2606 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2607 SALOME_ListIO sel_objects, to_process;
2609 aSel->selectedObjects( sel_objects );
2611 if ( theCommandID==SMESHOp::OpShowOnly )
2613 MESSAGE("anAction = SMESH::eDisplayOnly");
2614 startOperation( myEraseAll );
2617 extractContainers( sel_objects, to_process );
2620 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2624 SALOME_ListIteratorOfListIO It( to_process );
2625 for ( ; It.More(); It.Next())
2627 Handle(SALOME_InteractiveObject) IOS = It.Value();
2628 if ( IOS->hasEntry() )
2630 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2631 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2632 break; // PAL16774 (Crash after display of many groups)
2634 if (anAction == SMESH::eDisplayOnly)
2635 anAction = SMESH::eDisplay;
2640 // PAL13338 + PAL15161 -->
2641 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2642 MESSAGE("anAction = SMESH::eDisplayOnly");
2643 SMESH::UpdateView();
2644 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2646 // PAL13338 + PAL15161 <--
2648 catch (...) { // PAL16774 (Crash after display of many groups)
2649 SMESH::OnVisuException();
2652 if (anAction == SMESH::eErase) {
2653 MESSAGE("anAction == SMESH::eErase");
2655 aSel->setSelectedObjects( l1 );
2658 aSel->setSelectedObjects( to_process );
2663 case SMESHOp::OpNode:
2665 if(checkLock(aStudy)) break;
2668 EmitSignalDeactivateDialog();
2670 ( new SMESHGUI_NodesDlg( this ) )->show();
2673 SUIT_MessageBox::warning(desktop(),
2674 tr("SMESH_WRN_WARNING"),
2675 tr("SMESH_WRN_VIEWER_VTK"));
2680 case SMESHOp::OpCreateMesh:
2681 case SMESHOp::OpCreateSubMesh:
2682 case SMESHOp::OpEditMeshOrSubMesh:
2683 case SMESHOp::OpCompute:
2684 case SMESHOp::OpPreCompute:
2685 case SMESHOp::OpEvaluate:
2686 case SMESHOp::OpMeshOrder:
2687 startOperation( theCommandID );
2689 case SMESHOp::OpCopyMesh:
2691 if (checkLock(aStudy)) break;
2692 EmitSignalDeactivateDialog();
2693 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2696 case SMESHOp::OpBuildCompoundMesh:
2698 if (checkLock(aStudy)) break;
2699 EmitSignalDeactivateDialog();
2700 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2704 case SMESHOp::OpDiagonalInversion:
2705 case SMESHOp::OpUnionOfTwoTriangle:
2709 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2710 tr( "NOT_A_VTK_VIEWER" ) );
2714 if ( checkLock( aStudy ) )
2717 /*Standard_Boolean aRes;
2718 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2719 if ( aMesh->_is_nil() )
2721 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2722 tr( "SMESH_BAD_SELECTION" ) );
2726 EmitSignalDeactivateDialog();
2727 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2728 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2730 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2733 case SMESHOp::OpOrientation:
2734 case SMESHOp::OpUnionOfTriangles:
2735 case SMESHOp::OpCuttingOfQuadrangles:
2736 case SMESHOp::OpSplitVolumes:
2740 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2741 tr( "NOT_A_VTK_VIEWER" ) );
2745 if ( checkLock( aStudy ) )
2748 EmitSignalDeactivateDialog();
2749 SMESHGUI_MultiEditDlg* aDlg = NULL;
2750 if ( theCommandID == SMESHOp::OpOrientation )
2751 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2752 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2753 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2754 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2755 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2757 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2762 case SMESHOp::OpSmoothing:
2764 if(checkLock(aStudy)) break;
2766 EmitSignalDeactivateDialog();
2767 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2770 SUIT_MessageBox::warning(desktop(),
2771 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2775 case SMESHOp::OpExtrusion:
2777 if (checkLock(aStudy)) break;
2779 EmitSignalDeactivateDialog();
2780 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2782 SUIT_MessageBox::warning(desktop(),
2783 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2787 case SMESHOp::OpExtrusionAlongAPath:
2789 if (checkLock(aStudy)) break;
2791 EmitSignalDeactivateDialog();
2792 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2794 SUIT_MessageBox::warning(desktop(),
2795 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2799 case SMESHOp::OpRevolution:
2801 if(checkLock(aStudy)) break;
2803 EmitSignalDeactivateDialog();
2804 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2807 SUIT_MessageBox::warning(desktop(),
2808 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2812 case SMESHOp::OpPatternMapping:
2814 if ( checkLock( aStudy ) )
2818 EmitSignalDeactivateDialog();
2819 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2822 SUIT_MessageBox::warning(desktop(),
2823 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2827 case SMESHOp::OpSplitBiQuadratic:
2828 case SMESHOp::OpConvertMeshToQuadratic:
2829 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2830 case SMESHOp::OpReorientFaces:
2831 case SMESHOp::OpCreateGeometryGroup:
2833 startOperation( theCommandID );
2836 case SMESHOp::OpCreateGroup:
2840 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2841 tr( "NOT_A_VTK_VIEWER" ) );
2845 if(checkLock(aStudy)) break;
2846 EmitSignalDeactivateDialog();
2847 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2849 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2850 SALOME_ListIO selected;
2852 aSel->selectedObjects( selected );
2854 int nbSel = selected.Extent();
2856 // check if mesh is selected
2857 aMesh = SMESH::GetMeshByIO( selected.First() );
2859 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2864 case SMESHOp::OpConstructGroup:
2868 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2869 tr( "NOT_A_VTK_VIEWER" ) );
2873 if(checkLock(aStudy)) break;
2874 EmitSignalDeactivateDialog();
2876 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2877 SALOME_ListIO selected;
2879 aSel->selectedObjects( selected );
2881 int nbSel = selected.Extent();
2883 // check if submesh is selected
2884 Handle(SALOME_InteractiveObject) IObject = selected.First();
2885 if (IObject->hasEntry()) {
2886 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2888 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2889 if (!aSubMesh->_is_nil()) {
2891 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2892 // get submesh elements list by types
2893 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2894 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2895 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2896 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2897 // create group for each type o elements
2898 QString aName = IObject->getName();
2899 QStringList anEntryList;
2900 if (aNodes->length() > 0) {
2901 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2902 aGroup->Add(aNodes.inout());
2903 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2904 anEntryList.append( aSObject->GetID().c_str() );
2906 if (aEdges->length() > 0) {
2907 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2908 aGroup->Add(aEdges.inout());
2909 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2910 anEntryList.append( aSObject->GetID().c_str() );
2912 if (aFaces->length() > 0) {
2913 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2914 aGroup->Add(aFaces.inout());
2915 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2916 anEntryList.append( aSObject->GetID().c_str() );
2918 if (aVolumes->length() > 0) {
2919 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2920 aGroup->Add(aVolumes.inout());
2921 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2922 anEntryList.append( aSObject->GetID().c_str() );
2925 anApp->browseObjects( anEntryList );
2927 catch(const SALOME::SALOME_Exception & S_ex){
2928 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2935 SUIT_MessageBox::warning(desktop(),
2936 tr("SMESH_WRN_WARNING"),
2937 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2942 case SMESHOp::OpEditGroup:
2946 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2947 tr( "NOT_A_VTK_VIEWER" ) );
2951 if(checkLock(aStudy)) break;
2952 EmitSignalDeactivateDialog();
2954 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2955 SALOME_ListIO selected;
2957 aSel->selectedObjects( selected );
2959 SALOME_ListIteratorOfListIO It (selected);
2960 int nbSelectedGroups = 0;
2961 for ( ; It.More(); It.Next() )
2963 SMESH::SMESH_GroupBase_var aGroup =
2964 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2965 if (!aGroup->_is_nil()) {
2967 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2971 if (nbSelectedGroups == 0)
2973 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2979 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
2981 if(checkLock(aStudy)) break;
2982 if (myState == 800) {
2983 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2984 if (aDlg) aDlg->onAdd();
2989 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
2991 if(checkLock(aStudy)) break;
2992 if (myState == 800) {
2993 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2994 if (aDlg) aDlg->onRemove();
2999 case SMESHOp::OpEditGeomGroupAsGroup:
3003 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3004 tr( "NOT_A_VTK_VIEWER" ) );
3008 if(checkLock(aStudy)) break;
3009 EmitSignalDeactivateDialog();
3011 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3012 SALOME_ListIO selected;
3014 aSel->selectedObjects( selected );
3016 SALOME_ListIteratorOfListIO It (selected);
3017 for ( ; It.More(); It.Next() )
3019 SMESH::SMESH_GroupOnGeom_var aGroup =
3020 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3021 if (!aGroup->_is_nil()) {
3022 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3027 SMESH::SMESH_GroupOnFilter_var aGroup =
3028 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3029 if (!aGroup->_is_nil()) {
3030 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3038 case SMESHOp::OpUnionGroups:
3039 case SMESHOp::OpIntersectGroups:
3040 case SMESHOp::OpCutGroups:
3044 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3045 tr( "NOT_A_VTK_VIEWER" ) );
3049 if ( checkLock( aStudy ) )
3052 EmitSignalDeactivateDialog();
3054 SMESHGUI_GroupOpDlg* aDlg = 0;
3055 if ( theCommandID == SMESHOp::OpUnionGroups )
3056 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3057 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3058 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3060 aDlg = new SMESHGUI_CutGroupsDlg( this );
3067 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3069 if ( checkLock( aStudy ) )
3072 EmitSignalDeactivateDialog();
3073 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3079 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3083 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3084 tr( "NOT_A_VTK_VIEWER" ) );
3088 if ( checkLock( aStudy ) )
3091 EmitSignalDeactivateDialog();
3093 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3097 case SMESHOp::OpMeshInformation:
3098 case SMESHOp::OpWhatIs:
3100 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3101 EmitSignalDeactivateDialog();
3102 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3103 SALOME_ListIO selected;
3105 aSel->selectedObjects( selected );
3107 if ( selected.Extent() > 1 ) { // a dlg for each IO
3108 SALOME_ListIteratorOfListIO It( selected );
3109 for ( ; It.More(); It.Next() ) {
3110 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3111 dlg->showInfo( It.Value() );
3116 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3122 case SMESHOp::OpFindElementByPoint:
3124 startOperation( theCommandID );
3128 case SMESHOp::OpEditHypothesis:
3130 if(checkLock(aStudy)) break;
3132 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3133 SALOME_ListIO selected;
3135 aSel->selectedObjects( selected );
3137 int nbSel = selected.Extent();
3140 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3141 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3143 if ( !aHypothesis->_is_nil() )
3145 SMESHGUI_GenericHypothesisCreator* aCreator =
3146 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3149 // set geometry of mesh and sub-mesh to aCreator
3150 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3151 if ( selected.Extent() == 1 )
3153 QString subGeomID, meshGeomID;
3154 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3155 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3157 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3158 aCreator->setShapeEntry( subGeomID );
3159 aCreator->setMainShapeEntry( meshGeomID );
3163 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3173 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3175 if(checkLock(aStudy)) break;
3176 SUIT_OverrideCursor wc;
3178 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3179 SALOME_ListIO selected;
3181 aSel->selectedObjects( selected, QString::null, false );
3183 SALOME_ListIteratorOfListIO It(selected);
3184 for (int i = 0; It.More(); It.Next(), i++) {
3185 Handle(SALOME_InteractiveObject) IObject = It.Value();
3186 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3189 aSel->setSelectedObjects( l1 );
3194 case SMESHOp::OpElem0D:
3195 case SMESHOp::OpBall:
3196 case SMESHOp::OpEdge:
3197 case SMESHOp::OpTriangle:
3198 case SMESHOp::OpQuadrangle:
3199 case SMESHOp::OpPolygon:
3200 case SMESHOp::OpTetrahedron:
3201 case SMESHOp::OpHexahedron:
3202 case SMESHOp::OpPentahedron:
3203 case SMESHOp::OpPyramid:
3204 case SMESHOp::OpHexagonalPrism:
3206 if(checkLock(aStudy)) break;
3208 EmitSignalDeactivateDialog();
3209 SMDSAbs_EntityType type = SMDSEntity_Edge;
3210 switch (theCommandID) {
3211 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3212 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3213 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3214 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3215 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3216 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3217 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3218 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3219 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3220 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3223 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3226 SUIT_MessageBox::warning(desktop(),
3227 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3231 case SMESHOp::OpPolyhedron:
3233 if(checkLock(aStudy)) break;
3235 EmitSignalDeactivateDialog();
3236 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3239 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3240 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3244 case SMESHOp::OpQuadraticEdge:
3245 case SMESHOp::OpQuadraticTriangle:
3246 case SMESHOp::OpBiQuadraticTriangle:
3247 case SMESHOp::OpQuadraticQuadrangle:
3248 case SMESHOp::OpBiQuadraticQuadrangle:
3249 case SMESHOp::OpQuadraticPolygon:
3250 case SMESHOp::OpQuadraticTetrahedron:
3251 case SMESHOp::OpQuadraticPyramid:
3252 case SMESHOp::OpQuadraticPentahedron:
3253 case SMESHOp::OpQuadraticHexahedron:
3254 case SMESHOp::OpTriQuadraticHexahedron:
3256 if(checkLock(aStudy)) break;
3258 EmitSignalDeactivateDialog();
3259 SMDSAbs_EntityType type = SMDSEntity_Last;
3261 switch (theCommandID) {
3262 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3263 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3264 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3265 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3266 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3267 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3268 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3269 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3270 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3271 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3272 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3275 if ( type != SMDSEntity_Last )
3276 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3279 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3280 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3284 case SMESHOp::OpRemoveNodes:
3286 if(checkLock(aStudy)) break;
3288 EmitSignalDeactivateDialog();
3289 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3292 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3293 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3297 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3299 if(checkLock(aStudy)) break;
3301 EmitSignalDeactivateDialog();
3302 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3306 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3307 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3311 case SMESHOp::OpClearMesh: {
3313 if(checkLock(aStudy)) break;
3315 SALOME_ListIO selected;
3316 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3317 aSel->selectedObjects( selected );
3319 SUIT_OverrideCursor wc;
3320 SALOME_ListIteratorOfListIO It (selected);
3321 for ( ; It.More(); It.Next() )
3323 Handle(SALOME_InteractiveObject) IOS = It.Value();
3324 SMESH::SMESH_Mesh_var aMesh =
3325 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3326 if ( aMesh->_is_nil()) continue;
3328 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3330 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3331 SMESH::ModifiedMesh( aMeshSObj, false, true);
3332 // hide groups and submeshes
3333 _PTR(ChildIterator) anIter =
3334 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3335 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3337 _PTR(SObject) so = anIter->Value();
3338 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3341 catch (const SALOME::SALOME_Exception& S_ex){
3343 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3347 SMESH::UpdateView();
3351 case SMESHOp::OpRemoveOrphanNodes:
3353 if(checkLock(aStudy)) break;
3354 SALOME_ListIO selected;
3355 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3356 aSel->selectedObjects( selected );
3357 if ( selected.Extent() == 1 ) {
3358 Handle(SALOME_InteractiveObject) anIO = selected.First();
3359 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3360 if ( !aMesh->_is_nil() ) {
3361 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3362 tr( "SMESH_WARNING" ),
3363 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3364 SUIT_MessageBox::Yes |
3365 SUIT_MessageBox::No,
3366 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3369 SUIT_OverrideCursor wc;
3370 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3371 int removed = aMeshEditor->RemoveOrphanNodes();
3372 SUIT_MessageBox::information(SMESHGUI::desktop(),
3373 tr("SMESH_INFORMATION"),
3374 tr("NB_NODES_REMOVED").arg(removed));
3375 if ( removed > 0 ) {
3376 SMESH::UpdateView();
3377 SMESHGUI::Modified();
3380 catch (const SALOME::SALOME_Exception& S_ex) {
3381 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3390 case SMESHOp::OpRenumberingNodes:
3392 if(checkLock(aStudy)) break;
3394 EmitSignalDeactivateDialog();
3395 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3399 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3400 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3404 case SMESHOp::OpRenumberingElements:
3406 if(checkLock(aStudy)) break;
3408 EmitSignalDeactivateDialog();
3409 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3413 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3414 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3418 case SMESHOp::OpTranslation:
3420 if(checkLock(aStudy)) break;
3422 EmitSignalDeactivateDialog();
3423 ( new SMESHGUI_TranslationDlg( this ) )->show();
3426 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3427 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3431 case SMESHOp::OpRotation:
3433 if(checkLock(aStudy)) break;
3435 EmitSignalDeactivateDialog();
3436 ( new SMESHGUI_RotationDlg( this ) )->show();
3439 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3440 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3444 case SMESHOp::OpSymmetry:
3446 if(checkLock(aStudy)) break;
3448 EmitSignalDeactivateDialog();
3449 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3452 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3453 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3457 case SMESHOp::OpScale:
3459 if(checkLock(aStudy)) break;
3461 EmitSignalDeactivateDialog();
3462 ( new SMESHGUI_ScaleDlg( this ) )->show();
3465 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3466 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3471 case SMESHOp::OpSewing:
3473 if(checkLock(aStudy)) break;
3475 EmitSignalDeactivateDialog();
3476 ( new SMESHGUI_SewingDlg( this ) )->show();
3479 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3480 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3484 case SMESHOp::OpMergeNodes:
3486 if(checkLock(aStudy)) break;
3488 EmitSignalDeactivateDialog();
3489 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3492 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3493 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3497 case SMESHOp::OpMergeElements:
3499 if (checkLock(aStudy)) break;
3501 EmitSignalDeactivateDialog();
3502 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3504 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3505 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3510 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3511 startOperation( SMESHOp::OpMoveNode );
3514 case SMESHOp::OpDuplicateNodes:
3516 if(checkLock(aStudy)) break;
3518 EmitSignalDeactivateDialog();
3519 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3522 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3523 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3528 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3529 startOperation( SMESHOp::OpElem0DOnElemNodes );
3532 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3534 static QList<int> aTypes;
3535 if ( aTypes.isEmpty() )
3537 aTypes.append( SMESH::NODE );
3538 aTypes.append( SMESH::EDGE );
3539 aTypes.append( SMESH::FACE );
3540 aTypes.append( SMESH::VOLUME );
3542 if (!myFilterLibraryDlg)
3543 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3544 else if (myFilterLibraryDlg->isHidden())
3545 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3546 myFilterLibraryDlg->raise();
3550 case SMESHOp::OpFreeNode:
3551 case SMESHOp::OpEqualNode:
3552 case SMESHOp::OpFreeEdge:
3553 case SMESHOp::OpFreeBorder:
3554 case SMESHOp::OpLength:
3555 case SMESHOp::OpConnection:
3556 case SMESHOp::OpEqualEdge:
3557 case SMESHOp::OpFreeFace:
3558 case SMESHOp::OpBareBorderFace:
3559 case SMESHOp::OpOverConstrainedFace:
3560 case SMESHOp::OpLength2D:
3561 case SMESHOp::OpConnection2D:
3562 case SMESHOp::OpArea:
3563 case SMESHOp::OpTaper:
3564 case SMESHOp::OpAspectRatio:
3565 case SMESHOp::OpMinimumAngle:
3566 case SMESHOp::OpWarpingAngle:
3567 case SMESHOp::OpSkew:
3568 case SMESHOp::OpMaxElementLength2D:
3569 case SMESHOp::OpEqualFace:
3570 case SMESHOp::OpAspectRatio3D:
3571 case SMESHOp::OpVolume:
3572 case SMESHOp::OpMaxElementLength3D:
3573 case SMESHOp::OpBareBorderVolume:
3574 case SMESHOp::OpOverConstrainedVolume:
3575 case SMESHOp::OpEqualVolume:
3578 LightApp_SelectionMgr* mgr = selectionMgr();
3579 SALOME_ListIO selected; mgr->selectedObjects( selected );
3581 if( !selected.IsEmpty() ) {
3582 SUIT_OverrideCursor wc;
3583 ::Control( theCommandID );
3586 SUIT_MessageBox::warning(desktop(),
3587 tr( "SMESH_WRN_WARNING" ),
3588 tr( "SMESH_BAD_SELECTION" ) );
3592 SUIT_MessageBox::warning(desktop(),
3593 tr( "SMESH_WRN_WARNING" ),
3594 tr( "NOT_A_VTK_VIEWER" ) );
3597 case SMESHOp::OpOverallMeshQuality:
3598 OverallMeshQuality();
3600 case SMESHOp::OpNumberingNodes:
3602 SUIT_OverrideCursor wc;
3603 LightApp_SelectionMgr* mgr = selectionMgr();
3604 SALOME_ListIO selected; mgr->selectedObjects( selected );
3606 SALOME_ListIteratorOfListIO it(selected);
3607 for( ; it.More(); it.Next()) {
3608 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3609 if(anIObject->hasEntry()) {
3610 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3611 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3617 case SMESHOp::OpNumberingElements:
3619 SUIT_OverrideCursor wc;
3620 LightApp_SelectionMgr* mgr = selectionMgr();
3621 SALOME_ListIO selected; mgr->selectedObjects( selected );
3623 SALOME_ListIteratorOfListIO it(selected);
3624 for( ; it.More(); it.Next()) {
3625 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3626 if(anIObject->hasEntry())
3627 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3628 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3633 case SMESHOp::OpPropertiesLength:
3634 case SMESHOp::OpPropertiesArea:
3635 case SMESHOp::OpPropertiesVolume:
3636 case SMESHOp::OpMinimumDistance:
3637 case SMESHOp::OpBoundingBox:
3639 int page = SMESHGUI_MeasureDlg::MinDistance;
3640 if ( theCommandID == SMESHOp::OpBoundingBox )
3641 page = SMESHGUI_MeasureDlg::BoundingBox;
3642 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3643 page = SMESHGUI_MeasureDlg::Length;
3644 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3645 page = SMESHGUI_MeasureDlg::Area;
3646 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3647 page = SMESHGUI_MeasureDlg::Volume;
3649 EmitSignalDeactivateDialog();
3650 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3654 case SMESHOp::OpSortChild:
3660 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3661 //updateObjBrowser();
3665 //=============================================================================
3669 //=============================================================================
3670 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3675 //=============================================================================
3679 //=============================================================================
3680 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3685 //=============================================================================
3689 //=============================================================================
3690 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3695 //=============================================================================
3696 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3697 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3699 //=============================================================================
3700 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3701 SUIT_ViewWindow* wnd )
3703 if(theIO->hasEntry()){
3704 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3705 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3709 //=======================================================================
3710 // function : createSMESHAction
3712 //=======================================================================
3713 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3714 const int key, const bool toggle, const QString& shortcutAction )
3717 QWidget* parent = application()->desktop();
3718 SUIT_ResourceMgr* resMgr = resourceMgr();
3720 if ( !icon_id.isEmpty() )
3721 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3723 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3724 if ( !pix.isNull() )
3725 icon = QIcon( pix );
3727 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3728 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3729 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3731 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3732 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3735 //=======================================================================
3736 // function : createPopupItem
3738 //=======================================================================
3739 void SMESHGUI::createPopupItem( const int id,
3740 const QString& clients,
3741 const QString& types,
3742 const QString& theRule,
3745 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3746 popupMgr()->insert( action( id ), pId, 0 );
3748 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3749 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3750 QString rule = "(%1) and (%2) and (%3)";
3751 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3752 if( clients.isEmpty() )
3753 rule = rule.arg( QString( "true" ) );
3755 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3756 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3759 bool cont = myRules.contains( id );
3761 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3763 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3764 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3767 //=======================================================================
3768 // function : initialize
3770 //=======================================================================
3771 void SMESHGUI::initialize( CAM_Application* app )
3773 SalomeApp_Module::initialize( app );
3775 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3777 /* Automatic Update flag */
3778 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3780 // ----- create actions --------------
3782 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3783 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3784 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3785 //createSMESHAction( 114, "NUM" );
3786 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3788 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3790 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3791 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3792 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3793 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3794 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3795 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3797 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3799 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3800 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3801 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3802 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3803 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3804 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3806 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3808 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3809 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3810 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3811 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3812 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3813 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3814 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3815 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3816 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3817 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3818 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3819 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3820 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3821 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3822 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3823 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3824 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3825 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3826 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3827 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3828 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3829 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3830 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3831 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3832 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3833 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3834 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3835 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3836 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3837 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3839 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3840 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3841 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3842 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3843 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3844 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3845 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3846 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3847 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3848 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3849 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3850 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3851 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3852 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3853 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3854 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3855 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3856 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3857 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3858 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3859 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3860 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3861 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3862 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3863 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3864 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3865 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3867 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3868 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3869 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3870 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3871 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3872 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3873 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3874 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3875 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3876 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3877 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3878 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3879 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3880 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3881 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3882 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3883 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3884 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3885 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3886 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3887 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3888 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3889 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3890 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3891 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3893 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3894 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3895 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3896 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3898 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3899 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3901 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3902 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3903 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3904 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3905 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3906 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3907 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3908 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3909 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3910 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3911 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3912 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3913 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3914 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3915 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3916 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3917 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3918 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3919 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3920 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3921 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3922 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3923 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3924 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3926 createSMESHAction( SMESHOp::OpReset, "RESET" );
3927 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3928 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
3929 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3930 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3931 #ifndef DISABLE_PLOT2DVIEWER
3932 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3934 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3935 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3936 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3937 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3938 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3939 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3940 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3941 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3942 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3943 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3944 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
3945 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
3946 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3948 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3949 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3951 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3952 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3953 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3954 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3955 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3956 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3957 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3958 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3959 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3961 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3962 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3963 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3964 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3965 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
3967 createSMESHAction( SMESHOp::OpHide, "HIDE" );
3968 createSMESHAction( SMESHOp::OpShow, "SHOW" );
3969 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
3971 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
3973 QList<int> aCtrlActions;
3974 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode // node controls
3975 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
3976 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
3977 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
3978 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
3979 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
3980 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
3981 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
3982 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
3983 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
3984 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
3985 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
3986 aCtrlGroup->setExclusive( true );
3987 for( int i = 0; i < aCtrlActions.size(); i++ )
3988 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
3990 // ----- create menu --------------
3991 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3992 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3993 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3994 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3995 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3996 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3997 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3998 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4000 createMenu( separator(), fileId );
4002 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4003 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4004 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4005 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4006 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4007 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4008 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4009 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4010 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4011 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4012 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4013 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4014 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4016 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4017 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4018 createMenu( SMESHOp::OpImportMED, importId, -1 );
4019 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4021 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4023 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4024 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4025 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4026 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4027 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4028 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4030 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4032 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4033 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4034 createMenu( separator(), fileId, 10 );
4036 createMenu( SMESHOp::OpDelete, editId, -1 );
4038 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4040 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4041 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4042 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4043 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4044 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4045 createMenu( separator(), meshId, -1 );
4046 createMenu( SMESHOp::OpCompute, meshId, -1 );
4047 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4048 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4049 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4050 createMenu( separator(), meshId, -1 );
4051 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4052 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4053 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4054 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4055 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4056 createMenu( separator(), meshId, -1 );
4057 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4058 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4059 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4060 createMenu( separator(), meshId, -1 );
4061 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4062 createMenu( separator(), meshId, -1 );
4063 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4064 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4065 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4066 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4067 createMenu( separator(), meshId, -1 );
4069 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4070 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4071 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4072 createMenu( SMESHOp::OpLength, edgeId, -1 );
4073 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4074 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4075 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4076 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4077 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4078 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4079 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4080 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4081 createMenu( SMESHOp::OpArea, faceId, -1 );
4082 createMenu( SMESHOp::OpTaper, faceId, -1 );
4083 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4084 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4085 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4086 createMenu( SMESHOp::OpSkew, faceId, -1 );
4087 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4088 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4089 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4090 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4091 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4092 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4093 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4094 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4095 createMenu( separator(), ctrlId, -1 );
4096 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4097 createMenu( separator(), ctrlId, -1 );
4098 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4100 createMenu( SMESHOp::OpNode, addId, -1 );
4101 createMenu( SMESHOp::OpElem0D, addId, -1 );
4102 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4103 createMenu( SMESHOp::OpBall, addId, -1 );
4104 createMenu( SMESHOp::OpEdge, addId, -1 );
4105 createMenu( SMESHOp::OpTriangle, addId, -1 );
4106 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4107 createMenu( SMESHOp::OpPolygon, addId, -1 );
4108 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4109 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4110 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4111 createMenu( SMESHOp::OpPyramid, addId, -1 );
4112 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4113 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4114 createMenu( separator(), addId, -1 );
4115 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4116 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4117 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4118 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4119 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4120 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4121 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4122 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4123 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4124 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4125 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4127 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4128 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4129 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4130 createMenu( separator(), removeId, -1 );
4131 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4132 createMenu( separator(), removeId, -1 );
4133 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4135 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4136 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4138 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4139 createMenu( SMESHOp::OpRotation, transfId, -1 );
4140 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4141 createMenu( SMESHOp::OpScale, transfId, -1 );
4142 createMenu( SMESHOp::OpSewing, transfId, -1 );
4143 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4144 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4145 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4147 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4148 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4149 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4150 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4151 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4152 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4153 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4154 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4155 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4156 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4157 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4158 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4159 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4160 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4161 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4162 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4164 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4165 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4166 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4167 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4168 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4169 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4171 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4172 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4173 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4174 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4176 // ----- create toolbars --------------
4177 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4178 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4179 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4180 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4181 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4182 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4183 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4184 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4185 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4186 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4187 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4188 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4189 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4190 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4191 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4193 createTool( SMESHOp::OpCreateMesh, meshTb );
4194 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4195 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4196 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4197 createTool( SMESHOp::OpCopyMesh, meshTb );
4198 createTool( separator(), meshTb );
4199 createTool( SMESHOp::OpCompute, meshTb );
4200 createTool( SMESHOp::OpPreCompute, meshTb );
4201 createTool( SMESHOp::OpEvaluate, meshTb );
4202 createTool( SMESHOp::OpMeshOrder, meshTb );
4204 createTool( SMESHOp::OpCreateGroup, groupTb );
4205 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4206 createTool( SMESHOp::OpConstructGroup, groupTb );
4207 createTool( SMESHOp::OpEditGroup, groupTb );
4209 createTool( SMESHOp::OpMeshInformation, info );
4210 //createTool( SMESHOp::OpStdInfo, meshTb );
4211 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4212 createTool( SMESHOp::OpFindElementByPoint, info );
4214 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4215 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4217 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4218 createTool( SMESHOp::OpLength, ctrl1dTb );
4219 createTool( SMESHOp::OpConnection, ctrl1dTb );
4220 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4222 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4223 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4224 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4225 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4226 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4227 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4228 createTool( SMESHOp::OpArea, ctrl2dTb );
4229 createTool( SMESHOp::OpTaper, ctrl2dTb );
4230 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4231 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4232 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4233 createTool( SMESHOp::OpSkew, ctrl2dTb );
4234 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4235 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4237 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4238 createTool( SMESHOp::OpVolume, ctrl3dTb );
4239 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4240 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4241 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4242 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4244 createTool( SMESHOp::OpNode, addElemTb );
4245 createTool( SMESHOp::OpElem0D, addElemTb );
4246 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4247 createTool( SMESHOp::OpBall, addElemTb );
4248 createTool( SMESHOp::OpEdge, addElemTb );
4249 createTool( SMESHOp::OpTriangle, addElemTb );
4250 createTool( SMESHOp::OpQuadrangle, addElemTb );
4251 createTool( SMESHOp::OpPolygon, addElemTb );
4252 createTool( SMESHOp::OpTetrahedron, addElemTb );
4253 createTool( SMESHOp::OpHexahedron, addElemTb );
4254 createTool( SMESHOp::OpPentahedron, addElemTb );
4255 createTool( SMESHOp::OpPyramid, addElemTb );
4256 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4257 createTool( SMESHOp::OpPolyhedron, addElemTb );
4259 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4260 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4261 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4262 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4263 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4264 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4265 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4266 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4267 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4268 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4269 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4271 createTool( SMESHOp::OpRemoveNodes, remTb );
4272 createTool( SMESHOp::OpRemoveElements, remTb );
4273 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4274 createTool( SMESHOp::OpClearMesh, remTb );
4276 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4277 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4279 createTool( SMESHOp::OpTranslation, transformTb );
4280 createTool( SMESHOp::OpRotation, transformTb );
4281 createTool( SMESHOp::OpSymmetry, transformTb );
4282 createTool( SMESHOp::OpScale, transformTb );
4283 createTool( SMESHOp::OpSewing, transformTb );
4284 createTool( SMESHOp::OpMergeNodes, transformTb );
4285 createTool( SMESHOp::OpMergeElements, transformTb );
4286 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4288 createTool( SMESHOp::OpMoveNode, modifyTb );
4289 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4290 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4291 createTool( SMESHOp::OpOrientation, modifyTb );
4292 createTool( SMESHOp::OpReorientFaces, modifyTb );
4293 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4294 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4295 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4296 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4297 createTool( SMESHOp::OpSmoothing, modifyTb );
4298 createTool( SMESHOp::OpExtrusion, modifyTb );
4299 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4300 createTool( SMESHOp::OpRevolution, modifyTb );
4301 createTool( SMESHOp::OpPatternMapping, modifyTb );
4302 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4303 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4305 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4307 createTool( SMESHOp::OpUpdate, dispModeTb );
4309 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4310 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4313 QString OB = "'ObjectBrowser'",
4314 View = "'" + SVTK_Viewer::Type() + "'",
4316 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4317 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4318 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4319 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4320 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4321 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4322 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4323 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4324 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4325 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4326 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4328 mesh_part = mesh + " " + subMesh + " " + group,
4329 mesh_group = mesh + " " + group,
4330 hyp_alg = hypo + " " + algo;
4332 // popup for object browser
4334 isInvisible("not( isVisible )"),
4335 isEmpty("numberOfNodes = 0"),
4336 isNotEmpty("numberOfNodes <> 0"),
4338 // has nodes, edges, etc in VISIBLE! actor
4339 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4340 hasElems("(count( elemTypes ) > 0)"),
4341 hasDifferentElems("(count( elemTypes ) > 1)"),
4342 hasBalls("({'BallElem'} in elemTypes)"),
4343 hasElems0d("({'Elem0d'} in elemTypes)"),
4344 hasEdges("({'Edge'} in elemTypes)"),
4345 hasFaces("({'Face'} in elemTypes)"),
4346 hasVolumes("({'Volume'} in elemTypes)"),
4347 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4349 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4350 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4351 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, mesh );
4352 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, subMesh, "&& hasGeomReference" );
4353 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4354 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4356 popupMgr()->insert( separator(), -1, 0 );
4357 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& isComputable" );
4358 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& isPreComputable" );
4359 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& isComputable" );
4360 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& isComputable && hasGeomReference" );
4361 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4362 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4363 createPopupItem( SMESHOp::OpFindElementByPoint, OB, mesh_group );
4364 createPopupItem( SMESHOp::OpOverallMeshQuality, OB, mesh_part );
4365 popupMgr()->insert( separator(), -1, 0 );
4366 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh );
4367 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& hasGeomReference" );
4368 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4369 popupMgr()->insert( separator(), -1, 0 );
4370 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4371 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4372 popupMgr()->insert( separator(), -1, 0 );
4373 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh + " " + subMesh ); // convert to quadratic
4374 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh + " " + group, // create 2D mesh from 3D
4376 popupMgr()->insert( separator(), -1, 0 );
4377 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4378 popupMgr()->insert( separator(), -1, 0 );
4380 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4381 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4382 QString only_one_2D = only_one_non_empty + " && dim>1";
4384 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4385 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4386 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4387 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4389 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4391 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4392 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4393 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4394 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4395 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4396 popupMgr()->insert( separator(), -1, 0 );
4399 createPopupItem( SMESHOp::OpEditGroup, View, group );
4400 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4401 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4403 popupMgr()->insert( separator(), -1, 0 );
4404 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4405 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4406 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4407 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4408 popupMgr()->insert( separator(), -1, 0 );
4410 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4411 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4412 popupMgr()->insert( separator(), -1, 0 );
4414 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4415 QString aType = QString( "%1type in {%2}" ).arg( lc );
4416 aType = aType.arg( mesh_part );
4417 QString aMeshInVTK = aClient + "&&" + aType;
4419 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4420 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4421 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4423 //-------------------------------------------------
4425 //-------------------------------------------------
4426 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4428 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4429 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4430 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4432 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4433 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4434 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4436 popupMgr()->insert( separator(), -1, -1 );
4438 //-------------------------------------------------
4440 //-------------------------------------------------
4441 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4443 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4444 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4445 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4447 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4448 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4449 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4451 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4452 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4453 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4455 popupMgr()->insert( separator(), anId, -1 );
4457 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4458 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4459 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4461 //-------------------------------------------------
4463 //-------------------------------------------------
4464 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4466 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4468 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4469 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4470 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4472 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4473 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4474 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4476 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4477 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4478 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4480 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4481 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4482 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4484 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4485 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4486 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4488 popupMgr()->insert( separator(), anId, -1 );
4490 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4491 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4493 popupMgr()->insert( separator(), anId, -1 );
4495 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4496 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4499 //-------------------------------------------------
4500 // Representation of the 2D Quadratic elements
4501 //-------------------------------------------------
4502 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4503 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4504 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4505 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4507 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4508 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4509 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4511 //-------------------------------------------------
4512 // Orientation of faces
4513 //-------------------------------------------------
4514 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4515 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4516 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4518 //-------------------------------------------------
4520 //-------------------------------------------------
4521 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4522 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4524 //-------------------------------------------------
4526 //-------------------------------------------------
4527 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4528 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4530 //-------------------------------------------------
4532 //-------------------------------------------------
4534 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4535 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4536 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4537 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4539 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4541 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4542 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4544 popupMgr()->insert( separator(), anId, -1 );
4546 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4548 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4549 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4550 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4552 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4553 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4554 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4556 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4558 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4559 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4560 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4562 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4563 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4564 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4566 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4567 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4568 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4569 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4570 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4571 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4573 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4575 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4576 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4577 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4579 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4580 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4581 QtxPopupMgr::VisibleRule );
4582 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4584 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4585 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4586 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4588 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4589 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4590 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4592 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4593 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4594 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4596 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4597 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4598 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4600 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4601 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4602 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4604 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4605 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4606 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4608 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4609 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4610 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4612 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4613 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4614 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4616 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4617 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4618 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4620 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4621 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4622 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4624 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4625 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4626 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4627 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4628 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4629 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4631 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4633 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4634 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4635 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4637 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4638 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4639 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4641 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4642 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4643 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4645 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4646 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4647 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4649 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4650 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4651 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4653 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4654 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4655 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4657 popupMgr()->insert( separator(), anId, -1 );
4659 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4660 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4661 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4662 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4663 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4665 popupMgr()->insert( separator(), anId, -1 );
4667 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4669 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4670 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4672 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4673 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4674 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4676 #ifndef DISABLE_PLOT2DVIEWER
4677 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4678 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4681 //-------------------------------------------------
4683 //-------------------------------------------------
4684 popupMgr()->insert( separator(), -1, -1 );
4685 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4686 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4687 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4688 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4690 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4691 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4693 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4694 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4696 popupMgr()->insert( separator(), -1, -1 );
4698 //-------------------------------------------------
4700 //-------------------------------------------------
4701 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4702 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4704 popupMgr()->insert( separator(), -1, -1 );
4706 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4707 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4708 popupMgr()->insert( separator(), -1, -1 );
4710 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4711 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4713 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4714 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4717 //================================================================================
4719 * \brief Return true if SMESH or GEOM objects are selected.
4720 * Is called form LightApp_Module::activateModule() which clear selection if
4721 * not isSelectionCompatible()
4723 //================================================================================
4725 bool SMESHGUI::isSelectionCompatible()
4727 bool isCompatible = true;
4728 SALOME_ListIO selected;
4729 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4730 Sel->selectedObjects( selected );
4732 SALOME_ListIteratorOfListIO It( selected );
4733 for ( ; isCompatible && It.More(); It.Next())
4735 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4736 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4738 return isCompatible;
4742 bool SMESHGUI::reusableOperation( const int id )
4744 // compute, evaluate and precompute are not reusable operations
4745 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4748 bool SMESHGUI::activateModule( SUIT_Study* study )
4750 bool res = SalomeApp_Module::activateModule( study );
4752 setMenuShown( true );
4753 setToolShown( true );
4755 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4756 PyGILState_STATE gstate = PyGILState_Ensure();
4757 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4758 if ( !pluginsmanager ) {
4762 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4767 PyGILState_Release(gstate);
4768 // end of SMESH plugins loading
4770 // Reset actions accelerator keys
4771 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4773 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4774 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4775 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4776 if ( _PTR(Study) aStudy = s->studyDS() )
4777 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4780 // get all view currently opened in the study and connect their signals to
4781 // the corresponding slots of the class.
4782 SUIT_Desktop* aDesk = study->application()->desktop();
4784 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4785 SUIT_ViewWindow* wnd;
4786 foreach ( wnd, wndList )
4790 Py_XDECREF(pluginsmanager);
4794 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4796 setMenuShown( false );
4797 setToolShown( false );
4799 EmitSignalCloseAllDialogs();
4801 // Unset actions accelerator keys
4802 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4804 return SalomeApp_Module::deactivateModule( study );
4807 void SMESHGUI::studyClosed( SUIT_Study* s )
4811 SMESH::RemoveVisuData( s->id() );
4812 SalomeApp_Module::studyClosed( s );
4815 void SMESHGUI::OnGUIEvent()
4817 const QObject* obj = sender();
4818 if ( !obj || !obj->inherits( "QAction" ) )
4820 int id = actionId((QAction*)obj);
4825 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4827 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4828 if ( CORBA::is_nil( myComponentSMESH ) )
4830 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4832 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4833 return aGUI.myComponentSMESH;
4836 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4837 return myComponentSMESH;
4840 QString SMESHGUI::engineIOR() const
4842 CORBA::ORB_var anORB = getApp()->orb();
4843 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4844 return QString( anIOR.in() );
4847 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4849 SalomeApp_Module::contextMenuPopup( client, menu, title );
4851 selectionMgr()->selectedObjects( lst );
4852 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4853 Handle(SALOME_InteractiveObject) io = lst.First();
4854 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4855 _PTR(Study) study = appStudy->studyDS();
4856 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4858 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4859 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4860 aName.remove( (aName.length() - 1), 1 );
4866 LightApp_Selection* SMESHGUI::createSelection() const
4868 return new SMESHGUI_Selection();
4871 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4873 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4874 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4875 #ifndef DISABLE_PYCONSOLE
4876 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4880 void SMESHGUI::viewManagers( QStringList& list ) const
4882 list.append( SVTK_Viewer::Type() );
4885 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4887 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4888 SMESH::UpdateSelectionProp( this );
4890 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4891 for(int i = 0; i < aViews.count() ; i++){
4892 SUIT_ViewWindow *sf = aViews[i];
4895 EmitSignalActivatedViewManager();
4899 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4901 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4902 myClippingPlaneInfoMap.erase( theViewManager );
4905 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4907 theActor->AddObserver( SMESH::DeleteActorEvent,
4908 myEventCallbackCommand.GetPointer(),
4912 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4913 unsigned long theEvent,
4914 void* theClientData,
4917 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4918 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
4919 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4920 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4921 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4922 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4923 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4924 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4925 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4926 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4927 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4928 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4929 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4930 if( anActor == *anIter3 ) {
4931 anActorList.erase( anIter3 );
4942 void SMESHGUI::createPreferences()
4944 // General tab ------------------------------------------------------------------------
4945 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4947 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4948 setPreferenceProperty( autoUpdate, "columns", 2 );
4949 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4950 setPreferenceProperty( lim, "min", 0 );
4951 setPreferenceProperty( lim, "max", 100000000 );
4952 setPreferenceProperty( lim, "step", 1000 );
4953 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4954 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4956 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4957 setPreferenceProperty( qaGroup, "columns", 2 );
4958 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4959 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4960 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4961 setPreferenceProperty( prec, "min", 0 );
4962 setPreferenceProperty( prec, "max", 100 );
4963 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4964 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4965 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4966 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4967 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4969 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
4970 setPreferenceProperty( dispgroup, "columns", 2 );
4971 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4973 modes.append( tr("MEN_WIRE") );
4974 modes.append( tr("MEN_SHADE") );
4975 modes.append( tr("MEN_NODES") );
4976 modes.append( tr("MEN_SHRINK") );
4977 QList<QVariant> indices;
4978 indices.append( 0 );
4979 indices.append( 1 );
4980 indices.append( 2 );
4981 indices.append( 3 );
4982 setPreferenceProperty( dispmode, "strings", modes );
4983 setPreferenceProperty( dispmode, "indexes", indices );
4985 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
4986 setPreferenceProperty( arcgroup, "columns", 2 );
4987 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4988 QStringList quadraticModes;
4989 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4990 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4992 indices.append( 0 );
4993 indices.append( 1 );
4994 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4995 setPreferenceProperty( quadraticmode, "indexes", indices );
4997 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4998 "SMESH", "max_angle" );
4999 setPreferenceProperty( maxAngle, "min", 1 );
5000 setPreferenceProperty( maxAngle, "max", 90 );
5004 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5005 setPreferenceProperty( exportgroup, "columns", 2 );
5006 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5007 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5009 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5010 setPreferenceProperty( computeGroup, "columns", 2 );
5011 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5013 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5014 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5015 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5017 indices.append( 0 );
5018 indices.append( 1 );
5019 indices.append( 2 );
5020 setPreferenceProperty( notifyMode, "strings", modes );
5021 setPreferenceProperty( notifyMode, "indexes", indices );
5023 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5024 setPreferenceProperty( infoGroup, "columns", 2 );
5025 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5027 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5028 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5030 indices.append( 0 );
5031 indices.append( 1 );
5032 setPreferenceProperty( elemInfo, "strings", modes );
5033 setPreferenceProperty( elemInfo, "indexes", indices );
5034 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5035 setPreferenceProperty( nodesLim, "min", 0 );
5036 setPreferenceProperty( nodesLim, "max", 10000000 );
5037 setPreferenceProperty( nodesLim, "step", 10000 );
5038 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5039 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5040 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5041 setPreferenceProperty( ctrlLim, "min", 0 );
5042 setPreferenceProperty( ctrlLim, "max", 10000000 );
5043 setPreferenceProperty( ctrlLim, "step", 1000 );
5044 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5045 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5046 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5047 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5048 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5050 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5051 setPreferenceProperty( segGroup, "columns", 2 );
5052 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5053 "SMESH", "segmentation" );
5054 setPreferenceProperty( segLen, "min", 1 );
5055 setPreferenceProperty( segLen, "max", 10000000 );
5056 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5057 "SMESH", "nb_segments_per_edge" );
5058 setPreferenceProperty( nbSeg, "min", 1 );
5059 setPreferenceProperty( nbSeg, "max", 10000000 );
5061 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5062 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5063 "SMESH", "forget_mesh_on_hyp_modif" );
5066 // Quantities with individual precision settings
5067 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5068 setPreferenceProperty( precGroup, "columns", 2 );
5070 const int nbQuantities = 6;
5071 int precs[nbQuantities], ii = 0;
5072 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5073 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5074 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5075 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5076 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5077 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5078 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5079 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5080 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5081 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5082 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5083 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5085 // Set property for precision value for spinboxes
5086 for ( ii = 0; ii < nbQuantities; ii++ ){
5087 setPreferenceProperty( precs[ii], "min", -14 );
5088 setPreferenceProperty( precs[ii], "max", 14 );
5089 setPreferenceProperty( precs[ii], "precision", 2 );
5092 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5093 setPreferenceProperty( previewGroup, "columns", 2 );
5094 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5095 setPreferenceProperty( chunkSize, "min", 1 );
5096 setPreferenceProperty( chunkSize, "max", 1000 );
5097 setPreferenceProperty( chunkSize, "step", 50 );
5099 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5100 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5102 // Mesh tab ------------------------------------------------------------------------
5103 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5104 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5105 setPreferenceProperty( nodeGroup, "columns", 3 );
5107 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5109 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5111 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5112 QList<QVariant> aMarkerTypeIndicesList;
5113 QList<QVariant> aMarkerTypeIconsList;
5114 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5115 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5116 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5117 aMarkerTypeIndicesList << i;
5118 aMarkerTypeIconsList << pixmap;
5120 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5121 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5123 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5125 QList<QVariant> aMarkerScaleIndicesList;
5126 QStringList aMarkerScaleValuesList;
5127 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5128 aMarkerScaleIndicesList << i;
5129 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5130 aMarkerScaleValuesList << QString::number( i );
5132 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5133 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5135 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5136 //setPreferenceProperty( elemGroup, "columns", 2 );
5138 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5139 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5140 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5141 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5142 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5143 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5144 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5145 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5146 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5149 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5150 setPreferenceProperty( grpGroup, "columns", 2 );
5152 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5153 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5155 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5156 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5157 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5158 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5159 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5160 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5161 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5162 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5163 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5164 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5165 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5166 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5167 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5168 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5170 setPreferenceProperty( size0d, "min", 1 );
5171 setPreferenceProperty( size0d, "max", 10 );
5173 // setPreferenceProperty( ballSize, "min", 1 );
5174 // setPreferenceProperty( ballSize, "max", 10 );
5176 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5177 setPreferenceProperty( ballDiameter, "max", 1e9 );
5178 setPreferenceProperty( ballDiameter, "step", 0.1 );
5180 setPreferenceProperty( ballScale, "min", 1e-2 );
5181 setPreferenceProperty( ballScale, "max", 1e7 );
5182 setPreferenceProperty( ballScale, "step", 0.5 );
5184 setPreferenceProperty( elemW, "min", 1 );
5185 setPreferenceProperty( elemW, "max", 5 );
5187 setPreferenceProperty( outW, "min", 1 );
5188 setPreferenceProperty( outW, "max", 5 );
5190 setPreferenceProperty( shrink, "min", 0 );
5191 setPreferenceProperty( shrink, "max", 100 );
5193 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5194 setPreferenceProperty( numGroup, "columns", 2 );
5196 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5197 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5199 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5200 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5202 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5203 setPreferenceProperty( orientGroup, "columns", 1 );
5205 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5206 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5208 setPreferenceProperty( orientScale, "min", 0.05 );
5209 setPreferenceProperty( orientScale, "max", 0.5 );
5210 setPreferenceProperty( orientScale, "step", 0.05 );
5212 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5214 // Selection tab ------------------------------------------------------------------------
5215 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5217 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5218 setPreferenceProperty( selGroup, "columns", 2 );
5220 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5221 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5223 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5224 setPreferenceProperty( preGroup, "columns", 2 );
5226 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5228 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5229 setPreferenceProperty( precSelGroup, "columns", 2 );
5231 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5232 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5233 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5235 // Scalar Bar tab ------------------------------------------------------------------------
5236 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5237 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5238 setPreferenceProperty( fontGr, "columns", 2 );
5240 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5241 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5243 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5244 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5246 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5247 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5249 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5250 setPreferenceProperty( numcol, "min", 2 );
5251 setPreferenceProperty( numcol, "max", 256 );
5253 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5254 setPreferenceProperty( numlab, "min", 2 );
5255 setPreferenceProperty( numlab, "max", 65 );
5257 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5258 setPreferenceProperty( orientGr, "columns", 2 );
5259 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5260 QStringList orients;
5261 orients.append( tr( "SMESH_VERTICAL" ) );
5262 orients.append( tr( "SMESH_HORIZONTAL" ) );
5263 indices.clear(); indices.append( 0 ); indices.append( 1 );
5264 setPreferenceProperty( orient, "strings", orients );
5265 setPreferenceProperty( orient, "indexes", indices );
5267 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5268 setPreferenceProperty( posVSizeGr, "columns", 2 );
5269 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5270 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5271 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5272 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5273 setPreferenceProperty( xv, "step", 0.1 );
5274 setPreferenceProperty( xv, "min", 0.0 );
5275 setPreferenceProperty( xv, "max", 1.0 );
5276 setPreferenceProperty( yv, "step", 0.1 );
5277 setPreferenceProperty( yv, "min", 0.0 );
5278 setPreferenceProperty( yv, "max", 1.0 );
5279 setPreferenceProperty( wv, "step", 0.1 );
5280 setPreferenceProperty( wv, "min", 0.0 );
5281 setPreferenceProperty( wv, "max", 1.0 );
5282 setPreferenceProperty( hv, "min", 0.0 );
5283 setPreferenceProperty( hv, "max", 1.0 );
5284 setPreferenceProperty( hv, "step", 0.1 );
5286 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5287 setPreferenceProperty( posHSizeGr, "columns", 2 );
5288 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5289 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5290 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5291 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5292 setPreferenceProperty( xv, "min", 0.0 );
5293 setPreferenceProperty( xv, "max", 1.0 );
5294 setPreferenceProperty( xv, "step", 0.1 );
5295 setPreferenceProperty( xh, "min", 0.0 );
5296 setPreferenceProperty( xh, "max", 1.0 );
5297 setPreferenceProperty( xh, "step", 0.1 );
5298 setPreferenceProperty( yh, "min", 0.0 );
5299 setPreferenceProperty( yh, "max", 1.0 );
5300 setPreferenceProperty( yh, "step", 0.1 );
5301 setPreferenceProperty( wh, "min", 0.0 );
5302 setPreferenceProperty( wh, "max", 1.0 );
5303 setPreferenceProperty( wh, "step", 0.1 );
5304 setPreferenceProperty( hh, "min", 0.0 );
5305 setPreferenceProperty( hh, "max", 1.0 );
5306 setPreferenceProperty( hh, "step", 0.1 );
5308 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5309 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5310 setPreferenceProperty( distributionGr, "columns", 3 );
5312 types.append( tr( "SMESH_MONOCOLOR" ) );
5313 types.append( tr( "SMESH_MULTICOLOR" ) );
5314 indices.clear(); indices.append( 0 ); indices.append( 1 );
5315 setPreferenceProperty( coloringType, "strings", types );
5316 setPreferenceProperty( coloringType, "indexes", indices );
5317 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5321 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5323 if ( sect=="SMESH" ) {
5324 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5325 float aTol = 1.00000009999999;
5326 std::string aWarning;
5327 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5329 if ( name== "selection_object_color" ||
5330 name=="selection_element_color" ||
5331 name== "highlight_color" ||
5332 name=="selection_precision_node" ||
5333 name=="selection_precision_element" ||
5334 name=="selection_precision_object" )
5336 SMESH::UpdateSelectionProp( this );
5338 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5340 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5341 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5342 if ( sbX1+sbW > aTol ) {
5343 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5346 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5347 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5350 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5352 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5353 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5354 if ( sbY1 + sbH > aTol ) {
5355 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5356 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5357 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5360 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5362 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5363 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5364 if ( sbX1 + sbW > aTol ) {
5365 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5368 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5369 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5372 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5374 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5375 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5376 if ( sbY1 + sbH > aTol ) {
5377 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5380 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5381 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5384 else if ( name == "segmentation" )
5386 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5387 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5389 else if ( name == "nb_segments_per_edge" )
5391 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5392 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5394 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5396 QString val = aResourceMgr->stringValue( "SMESH", name );
5397 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5399 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5401 SMESH::UpdateFontProp( this );
5403 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5405 SMESH::UpdateFontProp( this );
5408 if ( aWarning.size() != 0 ) {
5409 aWarning += "The default values are applied instead.";
5410 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5411 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5412 QObject::tr(aWarning.c_str()));
5417 //================================================================================
5419 * \brief Update something in accordance with update flags
5420 * \param theFlags - update flags
5422 * Update viewer or/and object browser etc. in accordance with update flags ( see
5423 * LightApp_UpdateFlags enumeration ).
5425 //================================================================================
5426 void SMESHGUI::update( const int flags )
5428 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5429 SMESH::UpdateView();
5431 SalomeApp_Module::update( flags );
5434 //================================================================================
5436 * \brief Set default selection mode
5438 * SLOT called when operation commited. Sets default selection mode
5440 //================================================================================
5441 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5443 SVTK_ViewWindow* vtkWnd =
5444 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5446 vtkWnd->SetSelectionMode( ActorSelection );
5449 //================================================================================
5451 * \brief Set default selection mode
5453 * SLOT called when operation aborted. Sets default selection mode
5455 //================================================================================
5456 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5458 SVTK_ViewWindow* vtkWnd =
5459 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5461 vtkWnd->SetSelectionMode( ActorSelection );
5464 //================================================================================
5466 * \brief Creates operation with given identifier
5467 * \param id - identifier of operation to be started
5468 * \return Pointer on created operation or NULL if operation is not created
5470 * Virtual method redefined from the base class creates operation with given id.
5471 * It is called called automatically from startOperation method of base class.
5473 //================================================================================
5474 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5476 LightApp_Operation* op = 0;
5477 // to do : create operation here
5480 case SMESHOp::OpSplitBiQuadratic:
5481 op = new SMESHGUI_SplitBiQuadOp();
5483 case SMESHOp::OpConvertMeshToQuadratic:
5484 op = new SMESHGUI_ConvToQuadOp();
5486 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5487 op = new SMESHGUI_Make2DFrom3DOp();
5489 case SMESHOp::OpReorientFaces:
5490 op = new SMESHGUI_ReorientFacesOp();
5492 case SMESHOp::OpCreateMesh:
5493 op = new SMESHGUI_MeshOp( true, true );
5495 case SMESHOp::OpCreateSubMesh:
5496 op = new SMESHGUI_MeshOp( true, false );
5498 case SMESHOp::OpEditMeshOrSubMesh:
5499 op = new SMESHGUI_MeshOp( false );
5501 case SMESHOp::OpCompute:
5502 op = new SMESHGUI_ComputeOp();
5504 case SMESHOp::OpPreCompute:
5505 op = new SMESHGUI_PrecomputeOp();
5507 case SMESHOp::OpEvaluate:
5508 op = new SMESHGUI_EvaluateOp();
5510 case SMESHOp::OpMeshOrder:
5511 op = new SMESHGUI_MeshOrderOp();
5513 case SMESHOp::OpCreateGeometryGroup:
5514 op = new SMESHGUI_GroupOnShapeOp();
5516 case SMESHOp::OpFindElementByPoint:
5517 op = new SMESHGUI_FindElemByPointOp();
5519 case SMESHOp::OpMoveNode: // Make mesh pass through point
5520 op = new SMESHGUI_MakeNodeAtPointOp();
5522 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5523 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5530 op = SalomeApp_Module::createOperation( id );
5534 //================================================================================
5536 * \brief Stops current operations and starts a given one
5537 * \param id - The id of the operation to start
5539 //================================================================================
5541 void SMESHGUI::switchToOperation(int id)
5543 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5544 activeStudy()->abortAllOperations();
5545 startOperation( id );
5548 LightApp_Displayer* SMESHGUI::displayer()
5551 myDisplayer = new SMESHGUI_Displayer( getApp() );
5555 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5558 int aTolerance = 64;
5559 int anIterations = 0;
5565 if( anIterations % aPeriod == 0 )
5568 if( aTolerance < 1 )
5572 aHue = (int)( 360.0 * rand() / RAND_MAX );
5575 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5576 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5577 for( ; it != itEnd; ++it )
5579 SALOMEDS::Color anAutoColor = *it;
5580 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5583 aQColor.getHsv( &h, &s, &v );
5584 if( abs( h - aHue ) < aTolerance )
5596 aColor.setHsv( aHue, 255, 255 );
5598 SALOMEDS::Color aSColor;
5599 aSColor.R = aColor.redF();
5600 aSColor.G = aColor.greenF();
5601 aSColor.B = aColor.blueF();
5606 const char* gSeparator = "_"; // character used to separate parameter names
5607 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5608 const char* gPathSep = "|"; // character used to separate paths
5611 * \brief Store visual parameters
5613 * This method is called just before the study document is saved.
5614 * Store visual parameters in AttributeParameter attribue(s)
5616 void SMESHGUI::storeVisualParameters (int savePoint)
5619 Kernel_Utils::Localizer loc;
5621 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5622 if (!appStudy || !appStudy->studyDS())
5624 _PTR(Study) studyDS = appStudy->studyDS();
5626 // componentName is used for encoding of entries when storing them in IParameters
5627 std::string componentName = myComponentSMESH->ComponentDataType();
5628 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5629 //if (!aSComponent) return;
5632 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5633 componentName.c_str(),
5635 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5637 // store map of custom markers
5638 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5639 if( !aMarkerMap.empty() )
5641 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5642 for( ; anIter != aMarkerMap.end(); anIter++ )
5644 int anId = anIter->first;
5645 VTK::MarkerData aMarkerData = anIter->second;
5646 std::string aMarkerFileName = aMarkerData.first;
5647 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5648 if( aMarkerTexture.size() < 3 )
5649 continue; // should contain at least width, height and the first value
5651 QString aPropertyName( "texture" );
5652 aPropertyName += gSeparator;
5653 aPropertyName += QString::number( anId );
5655 QString aPropertyValue = aMarkerFileName.c_str();
5656 aPropertyValue += gPathSep;
5658 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5659 ushort aWidth = *aTextureIter++;
5660 ushort aHeight = *aTextureIter++;
5661 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5662 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5663 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5664 aPropertyValue += QString::number( *aTextureIter );
5666 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5670 // viewers counters are used for storing view_numbers in IParameters
5673 // main cycle to store parameters of displayed objects
5674 QList<SUIT_ViewManager*> lst;
5675 QList<SUIT_ViewManager*>::Iterator it;
5676 getApp()->viewManagers(lst);
5677 for (it = lst.begin(); it != lst.end(); it++)
5679 SUIT_ViewManager* vman = *it;
5680 QString vType = vman->getType();
5682 // saving VTK actors properties
5683 if (vType == SVTK_Viewer::Type())
5685 // store the clipping planes attached to the view manager
5686 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5687 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5688 if( anIter != myClippingPlaneInfoMap.end() )
5689 aClippingPlaneInfoList = anIter->second;
5691 if( !aClippingPlaneInfoList.empty() ) {
5692 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5693 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5695 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5696 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5698 QString aPropertyName( "ClippingPlane" );
5699 aPropertyName += gSeparator;
5700 aPropertyName += QString::number( vtkViewers );
5701 aPropertyName += gSeparator;
5702 aPropertyName += QString::number( anId );
5704 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5705 aPropertyValue += gDigitsSep;
5706 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5707 aPropertyValue += gDigitsSep;
5708 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5709 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5710 aPropertyValue += gDigitsSep;
5711 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5712 aPropertyValue += gDigitsSep;
5713 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5714 aPropertyValue += gDigitsSep;
5715 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5716 aPropertyValue += gDigitsSep;
5717 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5718 aPropertyValue += gDigitsSep;
5719 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5720 aPropertyValue += gDigitsSep;
5721 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5723 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5724 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5725 aPropertyValue += gDigitsSep;
5726 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5727 aPropertyValue += gDigitsSep;
5728 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5729 aPropertyValue += gDigitsSep;
5730 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5733 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5737 QVector<SUIT_ViewWindow*> views = vman->getViews();
5738 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5740 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5742 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5743 vtkActorCollection* allActors = aCopy.GetActors();
5744 allActors->InitTraversal();
5745 while (vtkActor* actor = allActors->GetNextActor())
5747 if (actor->GetVisibility()) // store only visible actors
5749 SMESH_Actor* aSmeshActor = 0;
5750 if (actor->IsA("SMESH_Actor"))
5751 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5752 if (aSmeshActor && aSmeshActor->hasIO())
5754 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5757 // entry is "encoded" = it does NOT contain component adress,
5758 // since it is a subject to change on next component loading
5759 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5761 std::string param, vtkParam = vType.toLatin1().data();
5762 vtkParam += gSeparator;
5763 vtkParam += QString::number(vtkViewers).toLatin1().data();
5764 vtkParam += gSeparator;
5767 param = vtkParam + "Visibility";
5768 ip->setParameter(entry, param, "On");
5771 param = vtkParam + "Representation";
5772 ip->setParameter(entry, param, QString::number
5773 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5776 param = vtkParam + "IsShrunk";
5777 ip->setParameter(entry, param, QString::number
5778 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5780 // Displayed entities
5781 unsigned int aMode = aSmeshActor->GetEntityMode();
5782 bool isE = aMode & SMESH_Actor::eEdges;
5783 bool isF = aMode & SMESH_Actor::eFaces;
5784 bool isV = aMode & SMESH_Actor::eVolumes;
5785 bool is0d = aMode & SMESH_Actor::e0DElements;
5786 bool isB = aMode & SMESH_Actor::eBallElem;
5788 QString modeStr ("e");
5789 modeStr += gDigitsSep; modeStr += QString::number(isE);
5790 modeStr += gDigitsSep; modeStr += "f";
5791 modeStr += gDigitsSep; modeStr += QString::number(isF);
5792 modeStr += gDigitsSep; modeStr += "v";
5793 modeStr += gDigitsSep; modeStr += QString::number(isV);
5794 modeStr += gDigitsSep; modeStr += "0d";
5795 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5796 modeStr += gDigitsSep; modeStr += "b";
5797 modeStr += gDigitsSep; modeStr += QString::number(isB);
5799 param = vtkParam + "Entities";
5800 ip->setParameter(entry, param, modeStr.toLatin1().data());
5806 aSmeshActor->GetSufaceColor(r, g, b, delta);
5807 QStringList colorStr;
5808 colorStr << "surface";
5809 colorStr << QString::number(r);
5810 colorStr << QString::number(g);
5811 colorStr << QString::number(b);
5813 colorStr << "backsurface";
5814 colorStr << QString::number(delta);
5816 aSmeshActor->GetVolumeColor(r, g, b, delta);
5817 colorStr << "volume";
5818 colorStr << QString::number(r);
5819 colorStr << QString::number(g);
5820 colorStr << QString::number(b);
5821 colorStr << QString::number(delta);
5823 aSmeshActor->GetEdgeColor(r, g, b);
5825 colorStr << QString::number(r);
5826 colorStr << QString::number(g);
5827 colorStr << QString::number(b);
5829 aSmeshActor->GetNodeColor(r, g, b);
5831 colorStr << QString::number(r);
5832 colorStr << QString::number(g);
5833 colorStr << QString::number(b);
5835 aSmeshActor->GetOutlineColor(r, g, b);
5836 colorStr << "outline";
5837 colorStr << QString::number(r);
5838 colorStr << QString::number(g);
5839 colorStr << QString::number(b);
5841 aSmeshActor->Get0DColor(r, g, b);
5842 colorStr << "elem0d";
5843 colorStr << QString::number(r);
5844 colorStr << QString::number(g);
5845 colorStr << QString::number(b);
5847 aSmeshActor->GetBallColor(r, g, b);
5849 colorStr << QString::number(r);
5850 colorStr << QString::number(g);
5851 colorStr << QString::number(b);
5853 aSmeshActor->GetFacesOrientationColor(r, g, b);
5854 colorStr << "orientation";
5855 colorStr << QString::number(r);
5856 colorStr << QString::number(g);
5857 colorStr << QString::number(b);
5859 param = vtkParam + "Colors";
5860 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5863 QStringList sizeStr;
5865 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5866 sizeStr << "outline";
5867 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5868 sizeStr << "elem0d";
5869 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5871 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5872 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5873 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5874 sizeStr << "shrink";
5875 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5876 sizeStr << "orientation";
5877 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5878 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5880 param = vtkParam + "Sizes";
5881 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5886 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5887 if( aMarkerType == VTK::MT_USER ) {
5888 markerStr += "custom";
5889 markerStr += gDigitsSep;
5890 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5894 markerStr += gDigitsSep;
5895 markerStr += QString::number( (int)aMarkerType );
5896 markerStr += gDigitsSep;
5897 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5900 param = vtkParam + "PointMarker";
5901 ip->setParameter(entry, param, markerStr.toLatin1().data());
5904 param = vtkParam + "Opacity";
5905 ip->setParameter(entry, param,
5906 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5909 param = vtkParam + "ClippingPlane";
5911 if( !aClippingPlaneInfoList.empty() ) {
5912 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5913 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5915 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5916 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5917 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5918 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5919 if( aSmeshActor == *anIter2 ) {
5920 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5921 QString::number( anId ).toLatin1().constData() );
5928 ip->setParameter( entry, param, "Off" );
5929 } // if (io->hasEntry())
5930 } // SMESH_Actor && hasIO
5932 } // while.. actors traversal
5936 } // if (SVTK view model)
5937 } // for (viewManagers)
5940 // data structures for clipping planes processing
5944 bool isOpenGLClipping;
5945 vtkIdType RelativeOrientation;
5948 int AbsoluteOrientation;
5949 double X, Y, Z, Dx, Dy, Dz;
5951 typedef std::list<TPlaneData> TPlaneDataList;
5952 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5954 typedef std::list<vtkActor*> TActorList;
5957 TActorList ActorList;
5958 SUIT_ViewManager* ViewManager;
5960 typedef std::list<TPlaneInfo> TPlaneInfoList;
5961 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5964 * \brief Restore visual parameters
5966 * This method is called after the study document is opened.
5967 * Restore visual parameters from AttributeParameter attribue(s)
5969 void SMESHGUI::restoreVisualParameters (int savePoint)
5972 Kernel_Utils::Localizer loc;
5974 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5975 if (!appStudy || !appStudy->studyDS())
5977 _PTR(Study) studyDS = appStudy->studyDS();
5979 // componentName is used for encoding of entries when storing them in IParameters
5980 std::string componentName = myComponentSMESH->ComponentDataType();
5981 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5982 //if (!aSComponent) return;
5985 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5986 componentName.c_str(),
5988 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5990 // restore map of custom markers and map of clipping planes
5991 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5992 TPlaneDataMap aPlaneDataMap;
5994 std::vector<std::string> properties = ip->getProperties();
5995 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5997 std::string property = *propIt;
5998 QString aPropertyName( property.c_str() );
5999 QString aPropertyValue( ip->getProperty( property ).c_str() );
6001 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6002 if( aPropertyNameList.isEmpty() )
6005 QString aPropertyType = aPropertyNameList[0];
6006 if( aPropertyType == "texture" )
6008 if( aPropertyNameList.size() != 2 )
6012 int anId = aPropertyNameList[1].toInt( &ok );
6013 if( !ok || anId < 1 )
6016 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6017 if( aPropertyValueList.size() != 2 )
6020 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6021 QString aMarkerTextureString = aPropertyValueList[1];
6022 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6023 if( aMarkerTextureStringList.size() != 3 )
6027 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6032 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6036 VTK::MarkerTexture aMarkerTexture;
6037 aMarkerTexture.push_back( aWidth );
6038 aMarkerTexture.push_back( aHeight );
6040 QString aMarkerTextureData = aMarkerTextureStringList[2];
6041 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6043 QChar aChar = aMarkerTextureData.at( i );
6044 if( aChar.isDigit() )
6045 aMarkerTexture.push_back( aChar.digitValue() );
6048 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6050 else if( aPropertyType == "ClippingPlane" )
6052 if( aPropertyNameList.size() != 3 )
6056 int aViewId = aPropertyNameList[1].toInt( &ok );
6057 if( !ok || aViewId < 0 )
6061 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6062 if( !ok || aClippingPlaneId < 0 )
6065 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6066 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6069 TPlaneData aPlaneData;
6070 aPlaneData.Id = aClippingPlaneId;
6073 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6078 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6082 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6085 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6090 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6095 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6100 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6105 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6110 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6115 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6119 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6121 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6126 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6131 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6136 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6141 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6142 aPlaneDataList.push_back( aPlaneData );
6146 TPlaneInfoMap aPlaneInfoMap;
6148 std::vector<std::string> entries = ip->getEntries();
6150 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6152 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6153 QString entry (ip->decodeEntry(*entIt).c_str());
6155 // Check that the entry corresponds to a real object in the Study
6156 // as the object may be deleted or modified after the visual state is saved.
6157 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6158 if (!so) continue; //Skip the not existent entry
6160 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6161 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6163 std::vector<std::string>::iterator namesIt = paramNames.begin();
6164 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6166 // actors are stored in a map after displaying of them for
6167 // quicker access in the future: map < viewID to actor >
6168 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6170 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6172 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6173 // '_' is used as separator and should not be used in viewer type or parameter names.
6174 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6175 if (lst.size() != 3)
6178 QString viewerTypStr = lst[0];
6179 QString viewIndexStr = lst[1];
6180 QString paramNameStr = lst[2];
6183 int viewIndex = viewIndexStr.toUInt(&ok);
6184 if (!ok) // bad conversion of view index to integer
6188 if (viewerTypStr == SVTK_Viewer::Type())
6190 SMESH_Actor* aSmeshActor = 0;
6191 if (vtkActors.IsBound(viewIndex))
6192 aSmeshActor = vtkActors.Find(viewIndex);
6194 QList<SUIT_ViewManager*> lst;
6195 getApp()->viewManagers(viewerTypStr, lst);
6197 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6198 SUIT_ViewManager* vman = NULL;
6199 if (viewIndex >= 0 && viewIndex < lst.count())
6200 vman = lst.at(viewIndex);
6202 if (paramNameStr == "Visibility")
6204 if (!aSmeshActor && displayer() && vman)
6206 SUIT_ViewModel* vmodel = vman->getViewModel();
6207 // SVTK view model can be casted to SALOME_View
6208 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6210 // store displayed actor in a temporary map for quicker
6211 // access later when restoring other parameters
6212 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6213 vtkRenderer* Renderer = vtkView->getRenderer();
6214 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6215 vtkActorCollection* theActors = aCopy.GetActors();
6216 theActors->InitTraversal();
6217 bool isFound = false;
6218 vtkActor *ac = theActors->GetNextActor();
6219 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6220 if (ac->IsA("SMESH_Actor")) {
6221 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6222 if (aGeomAc->hasIO()) {
6223 Handle(SALOME_InteractiveObject) io =
6224 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6225 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6227 vtkActors.Bind(viewIndex, aGeomAc);
6233 } // if (paramNameStr == "Visibility")
6236 // the rest properties "work" with SMESH_Actor
6239 QString val ((*valuesIt).c_str());
6242 if (paramNameStr == "Representation") {
6243 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6246 else if (paramNameStr == "IsShrunk") {
6248 if (!aSmeshActor->IsShrunk())
6249 aSmeshActor->SetShrink();
6252 if (aSmeshActor->IsShrunk())
6253 aSmeshActor->UnShrink();
6256 // Displayed entities
6257 else if (paramNameStr == "Entities") {
6258 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6259 int aEntityMode = SMESH_Actor::eAllEntity;
6260 for ( int i = 0; i < mode.count(); i+=2 ) {
6261 if ( i < mode.count()-1 ) {
6262 QString type = mode[i];
6263 bool val = mode[i+1].toInt();
6264 if ( type == "e" && !val )
6265 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6266 else if ( type == "f" && !val )
6267 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6268 else if ( type == "v" && !val )
6269 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6270 else if ( type == "0d" && !val )
6271 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6272 else if ( type == "b" && !val )
6273 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6276 aSmeshActor->SetEntityMode( aEntityMode );
6279 else if (paramNameStr == "Colors") {
6280 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6287 QColor outlineColor;
6288 QColor orientationColor;
6294 // below lines are required to get default values for delta coefficients
6295 // of backface color for faces and color of reversed volumes
6296 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6297 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6298 for ( int i = 0; i < colors.count(); i++ ) {
6299 QString type = colors[i];
6300 if ( type == "surface" ) {
6301 // face color is set by 3 values r:g:b, where
6302 // - r,g,b - is rgb color components
6303 if ( i+1 >= colors.count() ) break; // format error
6304 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6305 if ( i+2 >= colors.count() ) break; // format error
6306 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6307 if ( i+3 >= colors.count() ) break; // format error
6308 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6309 faceColor.setRgbF( r, g, b );
6312 else if ( type == "backsurface" ) {
6313 // backface color can be defined in several ways
6314 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6315 // - in latest versions, it is set as delta coefficient
6316 bool rgbOk = false, deltaOk;
6317 if ( i+1 >= colors.count() ) break; // format error
6318 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6319 int delta = colors[i+1].toInt( &deltaOk );
6321 if ( i+1 < colors.count() ) // index is shifted to 1
6322 g = colors[i+1].toDouble( &rgbOk );
6323 if ( rgbOk ) i++; // shift index
6324 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6325 b = colors[i+1].toDouble( &rgbOk );
6327 // - as currently there's no way to set directly backsurface color as it was before,
6328 // we ignore old dump where r,g,b triple was set
6329 // - also we check that delta parameter is set properly
6330 if ( !rgbOk && deltaOk )
6333 else if ( type == "volume" ) {
6334 // volume color is set by 4 values r:g:b:delta, where
6335 // - r,g,b - is a normal volume rgb color components
6336 // - delta - is a reversed volume color delta coefficient
6337 if ( i+1 >= colors.count() ) break; // format error
6338 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6339 if ( i+2 >= colors.count() ) break; // format error
6340 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6341 if ( i+3 >= colors.count() ) break; // format error
6342 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6343 if ( i+4 >= colors.count() ) break; // format error
6344 int delta = colors[i+4].toInt( &bOk );
6345 if ( !bOk ) break; // format error
6346 volumeColor.setRgbF( r, g, b );
6350 else if ( type == "edge" ) {
6351 // edge color is set by 3 values r:g:b, where
6352 // - r,g,b - is rgb color components
6353 if ( i+1 >= colors.count() ) break; // format error
6354 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6355 if ( i+2 >= colors.count() ) break; // format error
6356 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6357 if ( i+3 >= colors.count() ) break; // format error
6358 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6359 edgeColor.setRgbF( r, g, b );
6362 else if ( type == "node" ) {
6363 // node color is set by 3 values r:g:b, where
6364 // - r,g,b - is rgb color components
6365 if ( i+1 >= colors.count() ) break; // format error
6366 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6367 if ( i+2 >= colors.count() ) break; // format error
6368 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6369 if ( i+3 >= colors.count() ) break; // format error
6370 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6371 nodeColor.setRgbF( r, g, b );
6374 else if ( type == "elem0d" ) {
6375 // 0d element color is set by 3 values r:g:b, where
6376 // - r,g,b - is rgb color components
6377 if ( i+1 >= colors.count() ) break; // format error
6378 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6379 if ( i+2 >= colors.count() ) break; // format error
6380 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6381 if ( i+3 >= colors.count() ) break; // format error
6382 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6383 elem0dColor.setRgbF( r, g, b );
6386 else if ( type == "ball" ) {
6387 // ball color is set by 3 values r:g:b, where
6388 // - r,g,b - is rgb color components
6389 if ( i+1 >= colors.count() ) break; // format error
6390 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6391 if ( i+2 >= colors.count() ) break; // format error
6392 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6393 if ( i+3 >= colors.count() ) break; // format error
6394 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6395 ballColor.setRgbF( r, g, b );
6398 else if ( type == "outline" ) {
6399 // outline color is set by 3 values r:g:b, where
6400 // - r,g,b - is rgb color components
6401 if ( i+1 >= colors.count() ) break; // format error
6402 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6403 if ( i+2 >= colors.count() ) break; // format error
6404 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6405 if ( i+3 >= colors.count() ) break; // format error
6406 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6407 outlineColor.setRgbF( r, g, b );
6410 else if ( type == "orientation" ) {
6411 // orientation color is set by 3 values r:g:b, where
6412 // - r,g,b - is rgb color components
6413 if ( i+1 >= colors.count() ) break; // format error
6414 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6415 if ( i+2 >= colors.count() ) break; // format error
6416 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6417 if ( i+3 >= colors.count() ) break; // format error
6418 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6419 orientationColor.setRgbF( r, g, b );
6424 if ( nodeColor.isValid() )
6425 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6427 if ( edgeColor.isValid() )
6428 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6430 if ( faceColor.isValid() )
6431 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6433 if ( volumeColor.isValid() )
6434 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6435 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6436 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6438 if ( elem0dColor.isValid() )
6439 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6441 if ( ballColor.isValid() )
6442 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6444 if ( outlineColor.isValid() )
6445 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6446 // orientation color
6447 if ( orientationColor.isValid() )
6448 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6451 else if (paramNameStr == "Sizes") {
6452 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6455 int outlineWidth = -1;
6456 int elem0dSize = -1;
6457 //int ballSize = -1;
6458 double ballDiameter = -1.0;
6459 double ballScale = -1.0;
6460 double shrinkSize = -1;
6461 double orientationSize = -1;
6462 bool orientation3d = false;
6463 for ( int i = 0; i < sizes.count(); i++ ) {
6464 QString type = sizes[i];
6465 if ( type == "line" ) {
6466 // line (wireframe) width is given as single integer value
6467 if ( i+1 >= sizes.count() ) break; // format error
6468 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6472 if ( type == "outline" ) {
6473 // outline width is given as single integer value
6474 if ( i+1 >= sizes.count() ) break; // format error
6475 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6479 else if ( type == "elem0d" ) {
6480 // 0d element size is given as single integer value
6481 if ( i+1 >= sizes.count() ) break; // format error
6482 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6486 else if ( type == "ball" ) {
6487 // balls are specified by two values: size:scale, where
6488 // - size - is a integer value specifying size
6489 // - scale - is a double value specifying scale factor
6490 if ( i+1 >= sizes.count() ) break; // format error
6491 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6492 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6493 if ( i+2 >= sizes.count() ) break; // format error
6494 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6500 else if ( type == "shrink" ) {
6501 // shrink factor is given as single floating point value
6502 if ( i+1 >= sizes.count() ) break; // format error
6503 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6507 else if ( type == "orientation" ) {
6508 // orientation vectors are specified by two values size:3d, where
6509 // - size - is a floating point value specifying scale factor
6510 // - 3d - is a boolean
6511 if ( i+1 >= sizes.count() ) break; // format error
6512 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6513 if ( i+2 >= sizes.count() ) break; // format error
6514 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6515 orientationSize = v1;
6516 orientation3d = (bool)v2;
6520 // line (wireframe) width
6521 if ( lineWidth > 0 )
6522 aSmeshActor->SetLineWidth( lineWidth );
6524 if ( outlineWidth > 0 )
6525 aSmeshActor->SetOutlineWidth( outlineWidth );
6526 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6527 aSmeshActor->SetOutlineWidth( lineWidth );
6529 if ( elem0dSize > 0 )
6530 aSmeshActor->Set0DSize( elem0dSize );
6532 /*if ( ballSize > 0 )
6533 aSmeshActor->SetBallSize( ballSize );*/
6535 if ( ballDiameter > 0 )
6536 aSmeshActor->SetBallSize( ballDiameter );
6538 if ( ballScale > 0.0 )
6539 aSmeshActor->SetBallScale( ballScale );
6541 if ( shrinkSize > 0 )
6542 aSmeshActor->SetShrinkFactor( shrinkSize );
6543 // orientation vectors
6544 if ( orientationSize > 0 ) {
6545 aSmeshActor->SetFacesOrientationScale( orientationSize );
6546 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6550 else if (paramNameStr == "PointMarker") {
6551 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6552 if( data.count() >= 2 ) {
6554 int aParam1 = data[1].toInt( &ok );
6556 if( data[0] == "std" && data.count() == 3 ) {
6557 int aParam2 = data[2].toInt( &ok );
6558 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6560 else if( data[0] == "custom" ) {
6561 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6562 if( markerIt != aMarkerMap.end() ) {
6563 VTK::MarkerData aMarkerData = markerIt->second;
6564 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6571 else if (paramNameStr == "Opacity") {
6572 aSmeshActor->SetOpacity(val.toFloat());
6575 else if (paramNameStr.startsWith("ClippingPlane")) {
6576 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6577 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6578 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6579 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6580 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6581 // new format - val looks like "Off" or "0" (plane id)
6582 // (note: in new format "Off" value is used only for consistency,
6583 // so it is processed together with values in old format)
6584 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6585 if( anIsOldFormat ) {
6586 if (paramNameStr == "ClippingPlane1" || val == "Off")
6587 aSmeshActor->RemoveAllClippingPlanes();
6589 QList<SUIT_ViewManager*> lst;
6590 getApp()->viewManagers(viewerTypStr, lst);
6591 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6592 if (viewIndex >= 0 && viewIndex < lst.count()) {
6593 SUIT_ViewManager* vman = lst.at(viewIndex);
6594 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6596 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6598 SMESH::TActorList anActorList;
6599 anActorList.push_back( aSmeshActor );
6600 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6601 aPlane->myViewWindow = vtkView;
6602 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6603 aPlane->PlaneMode = aMode;
6604 bool isOpenGLClipping = ( bool )vals[1].toInt();
6605 aPlane->IsOpenGLClipping = isOpenGLClipping;
6606 if ( aMode == SMESH::Absolute ) {
6607 aPlane->myAbsoluteOrientation = vals[2].toInt();
6608 aPlane->X = vals[3].toFloat();
6609 aPlane->Y = vals[4].toFloat();
6610 aPlane->Z = vals[5].toFloat();
6611 aPlane->Dx = vals[6].toFloat();
6612 aPlane->Dy = vals[7].toFloat();
6613 aPlane->Dz = vals[8].toFloat();
6615 else if ( aMode == SMESH::Relative ) {
6616 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6617 aPlane->myDistance = vals[3].toFloat();
6618 aPlane->myAngle[0] = vals[4].toFloat();
6619 aPlane->myAngle[1] = vals[5].toFloat();
6623 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6624 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6625 aClippingPlaneInfo.Plane = aPlane;
6626 aClippingPlaneInfo.ActorList = anActorList;
6627 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6635 int aPlaneId = val.toInt( &ok );
6636 if( ok && aPlaneId >= 0 ) {
6637 bool anIsDefinedPlane = false;
6638 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6639 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6640 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6641 TPlaneInfo& aPlaneInfo = *anIter;
6642 if( aPlaneInfo.PlaneId == aPlaneId ) {
6643 aPlaneInfo.ActorList.push_back( aSmeshActor );
6644 anIsDefinedPlane = true;
6648 if( !anIsDefinedPlane ) {
6649 TPlaneInfo aPlaneInfo;
6650 aPlaneInfo.PlaneId = aPlaneId;
6651 aPlaneInfo.ActorList.push_back( aSmeshActor );
6652 aPlaneInfo.ViewManager = vman;
6654 // to make the list sorted by plane id
6655 anIter = aPlaneInfoList.begin();
6656 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6657 const TPlaneInfo& aPlaneInfoRef = *anIter;
6658 if( aPlaneInfoRef.PlaneId > aPlaneId )
6661 aPlaneInfoList.insert( anIter, aPlaneInfo );
6666 } // if (aSmeshActor)
6667 } // other parameters than Visibility
6669 } // for names/parameters iterator
6670 } // for entries iterator
6672 // take into account planes with empty list of actors referred to them
6673 QList<SUIT_ViewManager*> aVMList;
6674 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6676 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6677 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6678 int aViewId = aPlaneDataIter->first;
6679 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6680 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6682 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6684 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6685 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6686 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6687 const TPlaneData& aPlaneData = *anIter2;
6688 int aPlaneId = aPlaneData.Id;
6690 bool anIsFound = false;
6691 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6692 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6693 const TPlaneInfo& aPlaneInfo = *anIter3;
6694 if( aPlaneInfo.PlaneId == aPlaneId ) {
6701 TPlaneInfo aPlaneInfo; // ActorList field is empty
6702 aPlaneInfo.PlaneId = aPlaneId;
6703 aPlaneInfo.ViewManager = aViewManager;
6705 // to make the list sorted by plane id
6706 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6707 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6708 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6709 if( aPlaneInfoRef.PlaneId > aPlaneId )
6712 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6718 // add clipping planes to actors according to the restored parameters
6719 // and update the clipping plane map
6720 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6721 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6722 int aViewId = anIter1->first;
6723 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6725 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6726 if( anIter2 == aPlaneDataMap.end() )
6728 const TPlaneDataList& aPlaneDataList = anIter2->second;
6730 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6731 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6732 const TPlaneInfo& aPlaneInfo = *anIter3;
6733 int aPlaneId = aPlaneInfo.PlaneId;
6734 const TActorList& anActorList = aPlaneInfo.ActorList;
6735 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6739 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6743 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6745 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6746 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6747 const TPlaneData& aPlaneData = *anIter4;
6748 if( aPlaneData.Id == aPlaneId ) {
6749 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6750 aPlane->myViewWindow = aViewWindow;
6751 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6752 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6753 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6754 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6755 aPlane->X = aPlaneData.X;
6756 aPlane->Y = aPlaneData.Y;
6757 aPlane->Z = aPlaneData.Z;
6758 aPlane->Dx = aPlaneData.Dx;
6759 aPlane->Dy = aPlaneData.Dy;
6760 aPlane->Dz = aPlaneData.Dz;
6762 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6763 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6764 aPlane->myDistance = aPlaneData.Distance;
6765 aPlane->myAngle[0] = aPlaneData.Angle[0];
6766 aPlane->myAngle[1] = aPlaneData.Angle[1];
6769 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6770 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6771 aClippingPlaneInfo.Plane = aPlane;
6772 aClippingPlaneInfo.ActorList = anActorList;
6773 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6784 // update all VTK views
6785 QList<SUIT_ViewManager*> lst;
6786 getApp()->viewManagers(lst);
6787 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6788 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6789 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6790 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6791 // set OpenGL clipping planes
6792 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6793 vtkActorCollection* anAllActors = aCopy.GetActors();
6794 anAllActors->InitTraversal();
6795 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6796 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6797 anActor->SetOpenGLClippingPlane();
6799 vtkView->getRenderer()->ResetCameraClippingRange();
6806 \brief Adds preferences for dfont of VTK viewer
6808 \param pIf group identifier
6809 \param param parameter
6810 \return identifier of preferences
6812 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6814 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6816 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6819 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6820 fam.append( tr( "SMESH_FONT_COURIER" ) );
6821 fam.append( tr( "SMESH_FONT_TIMES" ) );
6823 setPreferenceProperty( tfont, "fonts", fam );
6825 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6826 if ( needSize ) f = f | QtxFontEdit::Size;
6827 setPreferenceProperty( tfont, "features", f );
6833 \brief Actions after hypothesis edition
6834 Updates object browser after hypothesis edition
6836 void SMESHGUI::onHypothesisEdit( int result )
6839 SMESHGUI::Modified();
6840 updateObjBrowser( true );
6844 \brief Actions after choosing menu of control modes
6845 Updates control mode actions according to current selection
6847 void SMESHGUI::onUpdateControlActions()
6849 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
6850 SALOME_ListIO selected;
6852 aSel->selectedObjects( selected );
6854 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6855 if ( selected.Extent() ) {
6856 if ( selected.First()->hasEntry() ) {
6857 aControl = SMESH::FindActorByEntry( selected.First()->getEntry() )->GetControlMode();
6858 SALOME_ListIteratorOfListIO it(selected);
6859 for ( ; it.More(); it.Next() ) {
6860 Handle(SALOME_InteractiveObject) anIO = it.Value();
6861 if ( anIO->hasEntry() ) {
6862 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6863 if ( aControl != anActor->GetControlMode() ) {
6864 aControl = SMESH_Actor::eNone;
6873 int anAction = ActionToControl( aControl, true );
6875 action( anAction )->setChecked( true );
6877 QMenu* send = (QMenu*)sender();
6878 QList<QAction*> actions = send->actions();
6879 for ( int i = 0; i < actions.size(); i++ )
6880 actions[i]->setChecked( false );
6886 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6887 \param pview view being closed
6889 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6890 #ifndef DISABLE_PLOT2DVIEWER
6891 //Crear all Plot2d Viewers if need.
6892 SMESH::ClearPlot2Viewers(pview);
6894 EmitSignalCloseView();
6897 void SMESHGUI::message( const QString& msg )
6900 QStringList data = msg.split("/");
6901 if ( data.count() > 0 ) {
6902 if ( data.first() == "mesh_loading" ) {
6904 QString entry = data.count() > 1 ? data[1] : QString();
6905 if ( entry.isEmpty() )
6908 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6910 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6913 name = SMESH::fromUtf8(obj->GetName());
6914 if ( name.isEmpty() )
6917 if ( data.last() == "stop" )
6918 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6920 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6921 QApplication::processEvents();
6927 \brief Connects or disconnects signals about activating and cloning view on the module slots
6928 \param pview view which is connected/disconnected
6930 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6934 SUIT_ViewManager* viewMgr = pview->getViewManager();
6936 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6937 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6939 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6940 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6945 \brief Return \c true if object can be renamed
6947 bool SMESHGUI::renameAllowed( const QString& entry) const {
6948 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6952 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6956 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6961 if(appStudy->isComponent(entry) || obj->isReference())
6964 // check type to prevent renaming of inappropriate objects
6965 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6966 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6967 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6968 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6969 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6970 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6977 Rename object by entry.
6978 \param entry entry of the object
6979 \param name new name of the object
6980 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6982 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6984 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6988 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6993 _PTR(Study) aStudy = appStudy->studyDS();
6998 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7000 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7005 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7006 _PTR(GenericAttribute) anAttr;
7007 _PTR(AttributeName) aName;
7009 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7011 // check type to prevent renaming of inappropriate objects
7012 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
7013 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7014 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7015 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7016 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7017 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7018 if ( !name.isEmpty() ) {
7019 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
7021 // update name of group object and its actor
7022 Handle(SALOME_InteractiveObject) IObject =
7023 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7025 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7026 if( !aGroupObject->_is_nil() ) {
7027 aGroupObject->SetName( qPrintable(name) );
7028 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7029 anActor->setName( qPrintable(name) );
7039 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7041 static QList<QColor> colors;
7043 if ( colors.isEmpty() ) {
7045 for (int s = 0; s < 2 ; s++)
7047 for (int v = 100; v >= 40; v = v - 20)
7049 for (int h = 0; h < 359 ; h = h + 60)
7051 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7056 static int currentColor = randomize( colors.size() );
7058 SALOMEDS::Color color;
7059 color.R = (double)colors[currentColor].red() / 255.0;
7060 color.G = (double)colors[currentColor].green() / 255.0;
7061 color.B = (double)colors[currentColor].blue() / 255.0;
7063 currentColor = (currentColor+1) % colors.count();