1 // Copyright (C) 2007-2015 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 //To disable automatic genericobj management, the following line should be commented.
182 //Otherwise, it should be uncommented.
183 //Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
184 #define WITHGENERICOBJ
186 // Below macro, when uncommented, switches on simplified (more performant) algorithm
187 // of auto-color picking up
188 #define SIMPLE_AUTOCOLOR
193 //=============================================================
194 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
197 void ExportMeshToFile(int theCommandID);
199 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
201 void SetDisplayEntity(int theCommandID);
203 int ActionToControl( int theID, bool theReversed = false );
205 void Control( int theCommandID );
208 //================================================================================
210 * \brief Reads meshes from file
212 //================================================================================
214 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
218 std::string myExtension;
220 if ( theCommandID == SMESHOp::OpImportMED ) {
221 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
222 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
224 else if ( theCommandID == SMESHOp::OpImportUNV ) {
225 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
227 else if ( theCommandID == SMESHOp::OpImportDAT ) {
228 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
230 else if ( theCommandID == SMESHOp::OpImportSTL ) {
231 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
234 else if ( theCommandID == SMESHOp::OpImportCGNS ) {
235 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
238 else if ( theCommandID == SMESHOp::OpImportSAUV ) {
239 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
240 filter.append( QObject::tr( "All files (*)" ) );
242 else if ( theCommandID == SMESHOp::OpImportGMF ) {
243 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
244 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
247 QString anInitialPath = "";
248 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
249 anInitialPath = QDir::currentPath();
251 QStringList filenames;
252 bool toCreateGroups = true;
254 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
255 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
256 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
257 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
258 // fd->setNameFilters( filter );
259 // fd->SetChecked( true );
261 // filenames << fd->selectedFile();
262 // toCreateGroups = fd->IsChecked();
268 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
271 QObject::tr( "SMESH_IMPORT_MESH" ) );
273 if ( filenames.count() > 0 ) {
274 SUIT_OverrideCursor wc;
275 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
278 QStringList anEntryList;
279 bool isEmpty = false;
280 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
281 QString filename = *it;
282 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
284 switch ( theCommandID ) {
285 case SMESHOp::OpImportDAT:
287 // DAT format (currently unsupported)
288 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
289 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
292 case SMESHOp::OpImportUNV:
295 aMeshes->length( 1 );
296 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
297 if ( aMeshes[0]->_is_nil() )
298 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
299 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
302 case SMESHOp::OpImportMED:
305 SMESH::DriverMED_ReadStatus res;
306 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
307 if ( res != SMESH::DRS_OK ) {
308 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
309 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
313 case SMESHOp::OpImportSTL:
316 aMeshes->length( 1 );
317 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
318 if ( aMeshes[0]->_is_nil() ) {
319 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
320 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
325 case SMESHOp::OpImportCGNS:
328 SMESH::DriverMED_ReadStatus res;
329 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
330 if ( res != SMESH::DRS_OK ) {
331 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
332 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
337 case SMESHOp::OpImportSAUV:
340 SMESH::DriverMED_ReadStatus res;
341 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
342 if ( res != SMESH::DRS_OK ) {
343 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
344 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
348 case SMESHOp::OpImportGMF:
351 SMESH::ComputeError_var res;
352 aMeshes->length( 1 );
353 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
356 if ( res->code != SMESH::DRS_OK ) {
357 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
358 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
359 if ( strlen( res->comment.in() ) > 0 ) {
360 errors.back() += ": ";
361 errors.back() += res->comment.in();
368 catch ( const SALOME::SALOME_Exception& S_ex ) {
369 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
370 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
373 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
374 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
376 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
377 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
378 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
379 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
380 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
382 anEntryList.append( aMeshSO->GetID().c_str() );
390 // update Object browser
391 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
393 // browse to the published meshes
394 if( LightApp_Application* anApp =
395 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
396 anApp->browseObjects( anEntryList );
398 // show Error message box if there were errors
399 if ( errors.count() > 0 ) {
400 SUIT_MessageBox::critical( SMESHGUI::desktop(),
401 QObject::tr( "SMESH_ERROR" ),
402 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
405 // show warning message box, if some imported mesh is empty
407 SUIT_MessageBox::warning( SMESHGUI::desktop(),
408 QObject::tr( "SMESH_WRN_WARNING" ),
409 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
414 //================================================================================
416 * \brief Export selected meshes or groups into a file
418 //================================================================================
420 void ExportMeshToFile( int theCommandID )
422 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
423 SALOME_ListIO selected;
425 aSel->selectedObjects( selected );
427 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT || theCommandID == SMESHOp::OpPopupExportDAT );
428 const bool isMED = ( theCommandID == SMESHOp::OpExportMED || theCommandID == SMESHOp::OpPopupExportMED );
429 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV || theCommandID == SMESHOp::OpPopupExportUNV );
430 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL || theCommandID == SMESHOp::OpPopupExportSTL );
432 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS || theCommandID == SMESHOp::OpPopupExportCGNS );
434 const bool isCGNS= false;
436 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV || theCommandID == SMESHOp::OpPopupExportSAUV );
437 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF || theCommandID == SMESHOp::OpPopupExportGMF );
439 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
440 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
443 // get mesh object from selection and check duplication of their names
444 bool hasDuplicatedMeshNames = false;
445 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
446 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
447 SALOME_ListIteratorOfListIO It( selected );
448 for( ; It.More(); It.Next() )
450 Handle(SALOME_InteractiveObject) anIObject = It.Value();
451 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
452 if ( aMeshItem->_is_nil() ) {
453 SUIT_MessageBox::warning( SMESHGUI::desktop(),
454 QObject::tr( "SMESH_WRN_WARNING" ),
455 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
459 QString aMeshName = anIObject->getName();
461 // check for name duplications
462 if ( !hasDuplicatedMeshNames )
463 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
464 if( aMeshName == (*aMeshIter).second ) {
465 hasDuplicatedMeshNames = true;
470 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
473 if( hasDuplicatedMeshNames && isMED ) {
474 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
475 QObject::tr("SMESH_WRN_WARNING"),
476 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
477 QObject::tr("SMESH_BUT_YES"),
478 QObject::tr("SMESH_BUT_NO"), 0, 1);
483 aMeshIter = aMeshList.begin();
484 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
485 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
486 QString aMeshName = (*aMeshIter).second;
488 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
490 // check for equal group names within each mesh
491 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
492 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
493 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
494 int aRet = SUIT_MessageBox::warning
495 (SMESHGUI::desktop(),
496 QObject::tr("SMESH_WRN_WARNING"),
497 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
498 QObject::tr("SMESH_BUT_YES"),
499 QObject::tr("SMESH_BUT_NO"), 0, 1);
506 // Warn the user about presence of not supported elements
508 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
512 notSupportedElemTypes.push_back( SMESH::Entity_0D );
513 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
518 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
519 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
520 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
521 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
522 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
523 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
524 notSupportedElemTypes.push_back( SMESH::Entity_0D );
525 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
530 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
531 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
532 notSupportedElemTypes.push_back( SMESH::Entity_0D );
533 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
538 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
543 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
544 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
545 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
546 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
547 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
548 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
549 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
550 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
555 notSupportedElemTypes.push_back( SMESH::Entity_0D );
556 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
557 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
558 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
559 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
560 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
561 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
562 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
563 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
565 if ( ! notSupportedElemTypes.empty() )
567 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
568 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
569 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
570 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
572 if ( !presentNotSupported.empty() )
575 const char* typeMsg[SMESH::Entity_Last] = {
576 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
577 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
578 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
579 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
580 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
581 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
582 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
583 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
585 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
586 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
587 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
588 if ( iType != presentNotSupported.size() - 1 )
589 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
591 int aRet = SUIT_MessageBox::warning
592 (SMESHGUI::desktop(),
593 QObject::tr("SMESH_WRN_WARNING"),
594 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
595 QObject::tr("SMESH_BUT_YES"),
596 QObject::tr("SMESH_BUT_NO"), 0, 1);
601 // Get parameters of export operation
604 SMESH::MED_VERSION aFormat;
605 // Init the parameters with the default values
606 bool aIsASCII_STL = true;
607 bool toCreateGroups = false;
608 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
610 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
611 bool toOverwrite = true;
612 bool toFindOutDim = true;
614 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
615 QString anInitialPath = "";
616 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
617 anInitialPath = QDir::currentPath();
619 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
621 // Get a file name to write in and additional otions
622 if ( isUNV || isDAT || isGMF ) // Export w/o options
625 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
627 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
629 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
630 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
631 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
632 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
633 anInitialPath + QString("/") + aMeshName,
634 aFilter, aTitle, false);
636 else if ( isCGNS )// Export to CGNS
638 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
639 fd->setWindowTitle( aTitle );
640 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
641 if ( !anInitialPath.isEmpty() )
642 fd->setDirectory( anInitialPath );
643 fd->selectFile(aMeshName);
644 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
645 fd->setValidator( fv );
648 aFilename = fd->selectedFile();
649 toOverwrite = fv->isOverwrite();
653 else if ( isSTL ) // Export to STL
655 QMap<QString, int> aFilterMap;
656 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
657 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
660 QMap<QString, int>::const_iterator it = aFilterMap.begin();
661 for ( ; it != aFilterMap.end(); ++it )
662 filters.push_back( it.key() );
664 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
665 fd->setWindowTitle( aTitle );
666 fd->setNameFilters( filters );
667 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
668 if ( !anInitialPath.isEmpty() )
669 fd->setDirectory( anInitialPath );
670 fd->selectFile(aMeshName);
674 aFilename = fd->selectedFile();
675 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
680 else if ( isMED || isSAUV ) // Export to MED or SAUV
682 QMap<QString, SMESH::MED_VERSION> aFilterMap;
683 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
685 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
686 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
687 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
690 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
691 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
692 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
696 QString aDefaultFilter;
697 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
698 for ( ; it != aFilterMap.end(); ++it ) {
699 filters.push_back( it.key() );
700 if (it.value() == SMESH::MED_V2_2)
701 aDefaultFilter = it.key();
703 QStringList checkBoxes;
704 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
706 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
707 QList< QWidget* > wdgList;
708 if ( fieldSelWdg->GetAllFeilds( aMeshList, aFieldList ))
709 wdgList.append( fieldSelWdg );
711 SalomeApp_CheckFileDlg* fd =
712 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
713 fd->setWindowTitle( aTitle );
714 fd->setNameFilters( filters );
715 fd->selectNameFilter( aDefaultFilter );
716 fd->SetChecked( toCreateGroups, 0 );
717 fd->SetChecked( toFindOutDim, 1 );
718 if ( !anInitialPath.isEmpty() )
719 fd->setDirectory( anInitialPath );
720 fd->selectFile(aMeshName);
723 QListView *lview = fd->findChild<QListView*>("listView");
725 lview->setMinimumHeight(200);
727 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
729 tview->setMinimumHeight(200);
732 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
733 fd->setValidator( fv );
738 aFilename = fd->selectedFile();
740 aFilename = QString::null;
743 aFormat = aFilterMap[fd->selectedNameFilter()];
744 toOverwrite = fv->isOverwrite();
746 if ( !aFilename.isEmpty() ) {
747 // med-2.1 does not support poly elements
748 if ( aFormat==SMESH::MED_V2_1 )
749 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
750 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
751 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
752 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
753 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
755 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
756 QObject::tr("SMESH_WRN_WARNING"),
757 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
758 QObject::tr("SMESH_BUT_YES"),
759 QObject::tr("SMESH_BUT_NO"), 0, 1);
767 // can't append to an existing using other format
768 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
769 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
770 if( !isVersionOk || aVersion != aFormat ) {
771 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
772 QObject::tr("SMESH_WRN_WARNING"),
773 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
774 QObject::tr("SMESH_BUT_YES"),
775 QObject::tr("SMESH_BUT_NO"), 0, 1);
782 QStringList aMeshNamesCollisionList;
783 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
784 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
785 QString anExistingMeshName( aMeshNames[ i ] );
786 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
787 QString anExportMeshName = (*aMeshIter).second;
788 if( anExportMeshName == anExistingMeshName ) {
789 aMeshNamesCollisionList.append( anExportMeshName );
794 if( !aMeshNamesCollisionList.isEmpty() ) {
795 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
796 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
797 QObject::tr("SMESH_WRN_WARNING"),
798 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
799 QObject::tr("SMESH_BUT_YES"),
800 QObject::tr("SMESH_BUT_NO"),
801 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
810 toCreateGroups = fd->IsChecked(0);
811 toFindOutDim = fd->IsChecked(1);
812 fieldSelWdg->GetSelectedFeilds();
813 if ( !fieldSelWdg->parent() )
824 if ( !aFilename.isEmpty() ) {
825 // Check whether the file already exists and delete it if yes
826 QFile aFile( aFilename );
827 if ( aFile.exists() && toOverwrite )
829 SUIT_OverrideCursor wc;
832 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
833 // bool Renumber = false;
834 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
836 // Renumber= resMgr->booleanValue("renumbering");
838 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
839 // aMeshEditor->RenumberNodes();
840 // aMeshEditor->RenumberElements();
841 // if ( SMESHGUI::automaticUpdate() )
842 // SMESH::UpdateView();
846 aMeshIter = aMeshList.begin();
847 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
849 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
850 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
851 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
852 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
853 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
854 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
855 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
856 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
858 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
859 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
860 fields, geoAssFields.toLatin1().data() );
865 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
867 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
868 if( !aMeshItem->_is_nil() )
869 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
874 if ( aMeshOrGroup->_is_equivalent( aMesh ))
875 aMesh->ExportDAT( aFilename.toUtf8().data() );
877 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
881 if ( aMeshOrGroup->_is_equivalent( aMesh ))
882 aMesh->ExportUNV( aFilename.toUtf8().data() );
884 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
888 if ( aMeshOrGroup->_is_equivalent( aMesh ))
889 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
891 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
895 aMeshIter = aMeshList.begin();
896 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
898 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
899 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
900 aMeshItem->ExportCGNS( aMeshOrGroup,
901 aFilename.toUtf8().data(),
902 toOverwrite && aMeshIndex == 0 );
907 toCreateGroups = true;
908 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
911 catch (const SALOME::SALOME_Exception& S_ex){
913 SUIT_MessageBox::warning(SMESHGUI::desktop(),
914 QObject::tr("SMESH_WRN_WARNING"),
915 QObject::tr("SMESH_EXPORT_FAILED"));
921 inline void InverseEntityMode(unsigned int& theOutputMode,
922 unsigned int theMode)
924 bool anIsNotPresent = ~theOutputMode & theMode;
926 theOutputMode |= theMode;
928 theOutputMode &= ~theMode;
931 void SetDisplayEntity(int theCommandID){
932 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
933 SALOME_ListIO selected;
935 aSel->selectedObjects( selected );
937 if(selected.Extent() >= 1){
938 SALOME_ListIteratorOfListIO It( selected );
939 for( ; It.More(); It.Next()){
940 Handle(SALOME_InteractiveObject) IObject = It.Value();
941 if(IObject->hasEntry()){
942 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
943 unsigned int aMode = anActor->GetEntityMode();
944 switch(theCommandID){
945 case SMESHOp::OpDE0DElements:
946 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
948 case SMESHOp::OpDEEdges:
949 InverseEntityMode(aMode,SMESH_Actor::eEdges);
951 case SMESHOp::OpDEFaces:
952 InverseEntityMode(aMode,SMESH_Actor::eFaces);
954 case SMESHOp::OpDEVolumes:
955 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
957 case SMESHOp::OpDEBalls:
958 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
960 case SMESHOp::OpDEAllEntity:
961 aMode = SMESH_Actor::eAllEntity;
965 anActor->SetEntityMode(aMode);
974 SALOME_ListIO selected;
975 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
979 LightApp_SelectionMgr* aSel = app->selectionMgr();
980 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
981 if( !aSel || !appStudy )
984 aSel->selectedObjects( selected );
985 if( selected.IsEmpty() )
988 Handle(SALOME_InteractiveObject) anIObject = selected.First();
990 _PTR(Study) aStudy = appStudy->studyDS();
991 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
992 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
993 if( aMainObject->_is_nil() )
996 SUIT_OverrideCursor wc;
998 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1000 QList<SALOMEDS::Color> aReservedColors;
1002 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1003 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1005 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1006 //SALOMEDS::Color aColor = aGroupObject->GetColor();
1008 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1009 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1010 #else // old algorithm for auto-colors
1011 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1012 aReservedColors.append( aColor );
1013 #endif // SIMPLE_AUTOCOLOR
1014 aGroupObject->SetColor( aColor );
1016 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1017 if (aGroupSObject) {
1020 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1021 switch ( aGroupObject->GetType ()) {
1023 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1025 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1027 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1029 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1031 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1032 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1035 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1036 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1042 SMESH::RepaintCurrentView();
1045 void OverallMeshQuality() {
1046 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1047 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1048 SALOME_ListIO selected;
1050 aSel->selectedObjects( selected );
1052 if ( selected.IsEmpty() ) return;
1053 SALOME_ListIteratorOfListIO It( selected );
1054 for ( ; It.More(); It.Next() ) {
1055 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1056 ctrlDlg->showInfo( It.Value() );
1061 QString functorToString( SMESH::Controls::FunctorPtr f )
1063 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1064 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1065 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1066 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1067 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1068 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1069 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1070 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1071 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1072 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1073 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1074 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1075 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1076 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1077 type = QObject::tr( "WARP_ELEMENTS" );
1078 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1079 type = QObject::tr( "TAPER_ELEMENTS" );
1080 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1081 type = QObject::tr( "SKEW_ELEMENTS" );
1082 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1083 type = QObject::tr( "AREA_ELEMENTS" );
1084 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1085 type = QObject::tr( "LENGTH_EDGES" );
1086 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1087 type = QObject::tr( "LENGTH2D_EDGES" );
1088 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1089 type = QObject::tr( "MULTI_BORDERS" );
1090 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1091 type = QObject::tr( "MULTI2D_BORDERS" );
1092 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1093 type = QObject::tr( "FREE_NODES" );
1094 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1095 type = QObject::tr( "FREE_EDGES" );
1096 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1097 type = QObject::tr( "FREE_BORDERS" );
1098 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1099 type = QObject::tr( "FREE_FACES" );
1100 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1101 type = QObject::tr( "BARE_BORDER_VOLUME" );
1102 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1103 type = QObject::tr( "BARE_BORDER_FACE" );
1104 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1105 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1106 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1107 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1108 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1109 type = QObject::tr( "EQUAL_NODE" );
1110 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1111 type = QObject::tr( "EQUAL_EDGE" );
1112 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1113 type = QObject::tr( "EQUAL_FACE" );
1114 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1115 type = QObject::tr( "EQUAL_VOLUME" );
1119 void SaveDistribution()
1121 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1122 SALOME_ListIO selected;
1124 aSel->selectedObjects( selected );
1126 if ( selected.Extent() == 1 ) {
1127 Handle(SALOME_InteractiveObject) anIO = selected.First();
1128 if ( anIO->hasEntry() ) {
1129 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1130 if ( anActor && anActor->GetScalarBarActor() && 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 = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1136 std::vector<int> elements;
1137 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1138 if ( mesh->_is_nil() ) {
1139 SMESH::SMESH_IDSource_var idSource =
1140 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1141 if ( !idSource->_is_nil() )
1143 SMESH::long_array_var ids = idSource->GetIDs();
1144 elements.resize( ids->length() );
1145 for ( unsigned i = 0; i < elements.size(); ++i )
1146 elements[i] = ids[i];
1149 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1150 vtkLookupTable* lookupTable =
1151 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1152 double * minmax = lookupTable->GetRange();
1153 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1154 std::vector<int> nbEvents;
1155 std::vector<double> funValues;
1156 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
1157 QString anInitialPath = "";
1158 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1159 anInitialPath = QDir::currentPath();
1160 QString aMeshName = anIO->getName();
1162 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1163 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1164 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1165 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1166 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1169 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1171 if ( !aFilename.isEmpty() ) {
1172 QFile f( aFilename );
1173 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1174 QTextStream out( &f );
1175 out << "# Mesh: " << aMeshName << endl;
1176 out << "# Control: " << functorToString( aFunctor ) << endl;
1178 out.setFieldWidth( 10 );
1179 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1180 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1191 void ShowElement(int theCommandID ) {
1192 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1193 SALOME_ListIO selected;
1195 aSel->selectedObjects( selected );
1197 if ( selected.Extent() == 1 ) {
1198 Handle(SALOME_InteractiveObject) anIO = selected.First();
1199 if ( anIO->hasEntry() ) {
1200 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1201 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1202 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1203 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1204 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1206 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1207 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1214 #ifndef DISABLE_PLOT2DVIEWER
1215 void PlotDistribution() {
1216 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1220 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1221 SALOME_ListIO selected;
1223 aSel->selectedObjects( selected );
1225 if ( selected.Extent() == 1 ) {
1226 Handle(SALOME_InteractiveObject) anIO = selected.First();
1227 if ( anIO->hasEntry() ) {
1228 //Find Actor by entry before getting Plot2d viewer,
1229 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1230 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1232 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1237 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1241 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1245 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1246 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1247 QString functorName = functorToString( anActor->GetFunctor());
1248 QString aHistogramName("%1 : %2");
1249 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1250 aHistogram->setName(aHistogramName);
1251 aHistogram->setHorTitle(functorName);
1252 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1253 aPlot->displayObject(aHistogram, true);
1258 #endif //DISABLE_PLOT2DVIEWER
1260 void DisableAutoColor(){
1261 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1262 SALOME_ListIO selected;
1264 aSel->selectedObjects( selected );
1266 if(selected.Extent()){
1267 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1268 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1269 if ( !aMesh->_is_nil() ) {
1270 aMesh->SetAutoColor( false );
1275 void sortChildren(){
1276 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1277 SALOME_ListIO selected;
1279 aSel->selectedObjects( selected );
1281 if(selected.Extent()){
1282 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1283 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1284 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1286 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1287 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1294 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1296 SALOME_ListIO selected;
1297 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1301 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1302 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1303 if( !aSel || !appStudy )
1306 if( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1307 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1308 aModule->EmitSignalDeactivateDialog();
1309 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1310 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1315 _PTR(Study) aStudy = appStudy->studyDS();
1317 aSel->selectedObjects( selected );
1319 if(selected.Extent() >= 1){
1320 switch(theCommandID){
1321 case SMESHOp::OpTransparency:{
1322 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1323 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1326 case SMESHOp::OpProperties: {
1328 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1329 QColor orientationColor, outlineColor, volumeColor;
1330 int deltaF = 0, deltaV = 0;
1333 double ballScale = 1.0;
1335 int outlineWidth = 1;
1336 double shrinkCoef = 0.0;
1337 double orientationScale = 0.0;
1338 bool orientation3d = false;
1339 VTK::MarkerType markerType = VTK::MT_NONE;
1340 VTK::MarkerScale markerScale = VTK::MS_NONE;
1342 bool hasNodes = false;
1343 int presentEntities = 0;
1344 bool firstTime = true;
1346 SALOME_ListIteratorOfListIO It( selected );
1347 for ( ; It.More(); It.Next() ) {
1348 Handle(SALOME_InteractiveObject) IObject = It.Value();
1349 if ( !IObject->hasEntry() ) continue;
1350 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1351 if ( !anActor || !anActor->GetObject() ) continue;
1354 // nodes: color, marker
1355 anActor->GetNodeColor( color[0], color[1], color[2] );
1356 nodeColor.setRgbF( color[0], color[1], color[2] );
1357 markerType = anActor->GetMarkerType();
1358 markerScale = anActor->GetMarkerScale();
1359 markerId = anActor->GetMarkerTexture();
1360 // edges: color, width
1361 anActor->GetEdgeColor( color[0], color[1], color[2] );
1362 edgeColor.setRgbF( color[0], color[1], color[2] );
1363 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1364 // faces: front color, back color (delta)
1365 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1366 faceColor.setRgbF( color[0], color[1], color[2] );
1367 // faces: front color, back color (delta)
1368 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1369 volumeColor.setRgbF( color[0], color[1], color[2] );
1370 // 0d elements: color, size
1371 anActor->Get0DColor( color[0], color[1], color[2] );
1372 elem0dColor.setRgbF( color[0], color[1], color[2] );
1373 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1374 // balls: color, size
1375 anActor->GetBallColor( color[0], color[1], color[2] );
1376 ballColor.setRgbF( color[0], color[1], color[2] );
1377 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1378 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1380 anActor->GetOutlineColor( color[0], color[1], color[2] );
1381 outlineColor.setRgbF( color[0], color[1], color[2] );
1382 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1383 // orientation vectors: color, scale, 3d flag
1384 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1385 orientationColor.setRgbF( color[0], color[1], color[2] );
1386 orientationScale = anActor->GetFacesOrientationScale();
1387 orientation3d = anActor->GetFacesOrientation3DVectors();
1389 shrinkCoef = anActor->GetShrinkFactor();
1392 firstTime = false; // we only take properties from first object (for performance reasons)
1395 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1396 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1397 presentEntities = presentEntities | SMESH_Actor::eEdges;
1398 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1399 presentEntities = presentEntities | SMESH_Actor::eFaces;
1400 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1401 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1402 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1403 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1404 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1405 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1407 // as we know that all types of elements are present, we can exit the loop
1408 if ( presentEntities == SMESH_Actor::eAllEntity )
1412 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1413 // nodes: color, marker
1414 dlg.setNodeColor( nodeColor );
1415 if( markerType != VTK::MT_USER )
1416 dlg.setNodeMarker( markerType, markerScale );
1418 dlg.setNodeCustomMarker( markerId );
1419 // edges: color, line width
1420 dlg.setEdgeColor( edgeColor );
1421 dlg.setEdgeWidth( edgeWidth );
1422 // faces: front color, back color
1423 dlg.setFaceColor( faceColor, deltaF );
1424 // volumes: normal color, reversed color
1425 dlg.setVolumeColor( volumeColor, deltaV );
1426 // outlines: color, line width
1427 dlg.setOutlineColor( outlineColor );
1428 dlg.setOutlineWidth( outlineWidth );
1429 // 0d elements: color, size
1430 dlg.setElem0dColor( elem0dColor );
1431 dlg.setElem0dSize( elem0dSize );
1432 // balls: color, size
1433 dlg.setBallColor( ballColor );
1434 //dlg.setBallSize( ballSize );
1435 dlg.setBallScale( ballScale );
1436 // orientation: color, scale, 3d flag
1437 dlg.setOrientationColor( orientationColor );
1438 dlg.setOrientationSize( int( orientationScale * 100. ) );
1439 dlg.setOrientation3d( orientation3d );
1440 // shrink: scale factor
1441 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1442 // hide unused controls
1443 dlg.showControls( presentEntities, hasNodes );
1446 nodeColor = dlg.nodeColor();
1447 markerType = dlg.nodeMarkerType();
1448 markerScale = dlg.nodeMarkerScale();
1449 markerId = dlg.nodeMarkerId();
1450 edgeColor = dlg.edgeColor();
1451 edgeWidth = dlg.edgeWidth();
1452 faceColor = dlg.faceColor();
1453 deltaF = dlg.faceColorDelta();
1454 volumeColor = dlg.volumeColor();
1455 deltaV = dlg.volumeColorDelta();
1456 outlineColor = dlg.outlineColor();
1457 outlineWidth = dlg.outlineWidth();
1458 elem0dColor = dlg.elem0dColor();
1459 elem0dSize = dlg.elem0dSize();
1460 ballColor = dlg.ballColor();
1461 // ballSize = dlg.ballSize();
1462 ballScale = dlg.ballScale();
1463 orientationColor = dlg.orientationColor();
1464 orientationScale = dlg.orientationSize() / 100.;
1465 orientation3d = dlg.orientation3d();
1466 shrinkCoef = dlg.shrinkCoef() / 100.;
1468 // store point markers map that might be changed by the user
1469 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1471 // set properties from dialog box to the presentations
1472 SALOME_ListIteratorOfListIO It( selected );
1473 for ( ; It.More(); It.Next() ) {
1474 Handle(SALOME_InteractiveObject) IObject = It.Value();
1475 if ( !IObject->hasEntry() ) continue;
1476 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1477 if ( !anActor ) continue;
1479 // nodes: color, marker
1480 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1481 if ( markerType != VTK::MT_USER ) {
1482 anActor->SetMarkerStd( markerType, markerScale );
1485 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1486 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1487 if ( iter != markerMap.end() )
1488 anActor->SetMarkerTexture( markerId, iter->second.second );
1490 // volumes: normal color, reversed color (delta)
1491 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1492 // faces: front color, back color (delta)
1493 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1494 // edges: color, width
1495 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1496 anActor->SetLineWidth( edgeWidth );
1498 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1499 anActor->SetOutlineWidth( outlineWidth );
1500 // 0D elements: color, size
1501 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1502 anActor->Set0DSize( elem0dSize );
1503 // balls: color, size
1504 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1505 // anActor->SetBallSize( ballSize );
1506 anActor->SetBallScale( ballScale );
1507 // orientation: color, scale, 3d flag
1508 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1509 anActor->SetFacesOrientationScale( orientationScale );
1510 anActor->SetFacesOrientation3DVectors( orientation3d );
1512 anActor->SetShrinkFactor( shrinkCoef );
1514 // for groups, set also proper color
1515 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1516 if ( !aGroupObject->_is_nil() ) {
1517 SMESH::ElementType anElementType = aGroupObject->GetType();
1519 switch( anElementType ) {
1521 aColor = nodeColor; break;
1523 aColor = edgeColor; break;
1525 aColor = faceColor; break;
1527 aColor = volumeColor; break;
1529 aColor = elem0dColor; break;
1531 aColor = ballColor; break;
1535 if ( aColor.isValid() ) {
1536 SALOMEDS::Color aGroupColor;
1537 aGroupColor.R = aColor.redF();
1538 aGroupColor.G = aColor.greenF();
1539 aGroupColor.B = aColor.blueF();
1540 aGroupObject->SetColor( aGroupColor );
1542 } // if ( !aGroupObject->_is_nil() )
1543 } // for ( ; It.More(); It.Next() )
1544 SMESH::RepaintCurrentView();
1545 } // if ( dlg.exec() )
1547 } // case SMESHOp::OpProperties:
1548 } // switch(theCommandID)
1549 SALOME_ListIteratorOfListIO It( selected );
1550 for( ; It.More(); It.Next()){
1551 Handle(SALOME_InteractiveObject) IObject = It.Value();
1552 if(IObject->hasEntry()){
1553 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1554 switch(theCommandID){
1555 case SMESHOp::OpDMWireframe:
1556 anActor->SetRepresentation(SMESH_Actor::eEdge);
1558 case SMESHOp::OpDMShading:
1559 anActor->SetRepresentation(SMESH_Actor::eSurface);
1561 case SMESHOp::OpDMShrink:
1562 if(anActor->IsShrunk())
1563 anActor->UnShrink();
1565 anActor->SetShrink();
1567 case SMESHOp::OpDMNodes:
1568 anActor->SetRepresentation(SMESH_Actor::ePoint);
1570 case SMESHOp::OpRepresentationLines:
1571 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1572 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1574 case SMESHOp::OpRepresentationArcs:
1575 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1576 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1582 SMESH::RepaintCurrentView();
1586 int ActionToControl( int theID, bool theReversed )
1588 NCollection_DoubleMap<int,int> ActionControl;
1589 ActionControl.Bind( 0, SMESH_Actor::eNone );
1590 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1591 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1592 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1593 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1594 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1595 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1596 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1597 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1598 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1599 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1600 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1601 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1602 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1603 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1604 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1605 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1606 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1607 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1608 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1609 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1610 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1611 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1612 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1613 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1614 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1615 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1617 return theReversed ? ActionControl.Find2( theID ) : ActionControl.Find1( theID );
1620 void Control( int theCommandID )
1622 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ) );
1623 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1624 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1625 SALOME_ListIO selected;
1627 aSel->selectedObjects( selected );
1629 if( !selected.IsEmpty() ){
1630 SALOME_ListIteratorOfListIO It(selected);
1631 for ( ; It.More(); It.Next())
1633 Handle(SALOME_InteractiveObject) anIO = It.Value();
1635 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1637 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1638 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
1639 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
1640 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
1641 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
1642 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1643 anActor->SetControlMode(aControl);
1644 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1645 SMESH::RepaintCurrentView();
1646 #ifndef DISABLE_PLOT2DVIEWER
1647 if(anActor->GetPlot2Histogram()) {
1648 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1649 QString functorName = functorToString( anActor->GetFunctor());
1650 QString aHistogramName("%1 : %2");
1651 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1652 aHistogram->setName(aHistogramName);
1653 aHistogram->setHorTitle(functorName);
1654 SMESH::ProcessIn2DViewers(anActor);
1666 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1667 SMESH::MeshObjectType theType,
1668 const QString theInTypeName,
1669 QString & theOutTypeName)
1671 SMESH_TypeFilter aTypeFilter( theType );
1673 if( !theIO.IsNull() )
1675 entry = theIO->getEntry();
1676 LightApp_DataOwner owner( entry );
1677 if ( aTypeFilter.isOk( &owner )) {
1678 theOutTypeName = theInTypeName;
1686 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1688 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1689 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1691 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1692 CORBA::String_var anID = aSComp->GetID().c_str();
1693 if (!strcmp(anID.in(),theIO->getEntry()))
1699 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1700 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1701 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1702 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1703 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1711 QString CheckHomogeneousSelection()
1713 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1714 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1715 SALOME_ListIO selected;
1717 aSel->selectedObjects( selected );
1719 QString RefType = CheckTypeObject(selected.First());
1720 SALOME_ListIteratorOfListIO It(selected);
1721 for ( ; It.More(); It.Next())
1723 Handle(SALOME_InteractiveObject) IObject = It.Value();
1724 QString Type = CheckTypeObject(IObject);
1725 if (Type.compare(RefType) != 0)
1726 return "Heterogeneous Selection";
1732 uint randomize( uint size )
1734 static bool initialized = false;
1735 if ( !initialized ) {
1736 qsrand( QDateTime::currentDateTime().toTime_t() );
1740 v = uint( (double)( v ) / RAND_MAX * size );
1741 v = qMax( uint(0), qMin ( v, size-1 ) );
1747 void SMESHGUI::OnEditDelete()
1749 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1750 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1751 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1753 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1754 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1755 _PTR(GenericAttribute) anAttr;
1756 _PTR(AttributeIOR) anIOR;
1758 int objectCount = 0;
1760 QString aParentComponent = QString::null;
1761 Handle(SALOME_InteractiveObject) anIO;
1762 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1764 anIO = anIt.Value();
1765 QString cur = anIO->getComponentDataType();
1766 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1768 // check if object is reference
1769 _PTR(SObject) aRefSObj;
1770 aNameList.append("\n - ");
1771 if ( aSO->ReferencedObject( aRefSObj ) ) {
1772 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1773 aNameList.append( aRefName );
1774 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1777 aNameList.append(anIO->getName());
1781 if( aParentComponent.isNull() )
1782 aParentComponent = cur;
1783 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1784 aParentComponent = "";
1787 if ( objectCount == 0 )
1788 return; // No Valid Objects Selected
1790 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1791 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1792 QObject::tr("ERR_ERROR"),
1793 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1796 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1797 if (SUIT_MessageBox::warning
1798 (SMESHGUI::desktop(),
1799 QObject::tr("SMESH_WRN_WARNING"),
1800 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1801 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1802 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1805 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1807 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1808 // then treat them all starting from the deepest objects (at list back)
1809 std::list< _PTR(SObject) > listSO;
1810 SALOME_ListIteratorOfListIO It(selected);
1811 for( ; It.More(); It.Next()) // loop on selected IO's
1813 Handle(SALOME_InteractiveObject) IObject = It.Value();
1814 if(IObject->hasEntry()) {
1815 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1817 // disable removal of "SMESH" component object
1818 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1820 if ( engineIOR() == anIOR->Value().c_str() )
1823 //Check the referenced object
1824 _PTR(SObject) aRefSObject;
1825 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1826 aSO = aRefSObject; // Delete main Object instead of reference
1828 listSO.push_back( aSO );
1829 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1830 for ( ; itSO != listSO.end(); ++itSO ) {
1831 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1832 for (it->InitEx(false); it->More(); it->Next())
1833 listSO.push_back( it->Value() );
1837 // Check if none of objects to delete is referred from outside
1838 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1839 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1841 _PTR(SObject) SO = *ritSO;
1842 if ( !SO ) continue;
1843 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1844 for (size_t i = 0; i < aReferences.size(); i++) {
1845 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1846 std::string type = aComponent->ComponentDataType();
1847 if ( type != "SMESH" )
1849 SUIT_MessageBox::warning( anApp->desktop(),
1850 QObject::tr("WRN_WARNING"),
1851 QObject::tr("DEP_OBJECT") );
1852 return; // outside SMESH, there is an object depending on a SMESH object
1857 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1858 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1860 Handle(SALOME_InteractiveObject) IObject = It.Value();
1861 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1862 if ( !mesh->_is_nil() )
1866 // Treat SO's in the list starting from the back
1867 aStudyBuilder->NewCommand(); // There is a transaction
1868 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1870 _PTR(SObject) SO = *ritSO;
1871 if ( !SO ) continue;
1872 std::string anEntry = SO->GetID();
1874 /** Erase graphical object and remove all its data **/
1875 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1876 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1878 /** Remove an object from data structures **/
1879 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1880 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1881 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1882 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1883 aMesh->RemoveGroup( aGroup );
1885 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1886 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1887 aMesh->RemoveSubMesh( aSubMesh );
1889 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1891 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1894 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1895 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1896 QString objType = CheckTypeObject(IObject);
1897 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1898 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1899 aStudyBuilder->RemoveObjectWithChildren( SO );
1901 else {// default action: remove SObject from the study
1902 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1903 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1905 aStudyBuilder->RemoveObjectWithChildren( SO );
1909 } /* listSO back loop */
1911 aStudyBuilder->CommitCommand();
1913 /* Clear any previous selection */
1915 aSel->setSelectedObjects( l1 );
1917 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1921 SMESHGUI_EXPORT CAM_Module* createModule()
1923 return new SMESHGUI();
1926 SMESHGUI_EXPORT char* getModuleVersion() {
1927 return (char*)SMESH_VERSION_STR;
1931 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1933 //=============================================================================
1937 //=============================================================================
1938 SMESHGUI::SMESHGUI() :
1939 SalomeApp_Module( "SMESH" )
1941 if ( CORBA::is_nil( myComponentSMESH ) )
1943 CORBA::Boolean anIsEmbeddedMode;
1944 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1945 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1947 // 0019923: EDF 765 SMESH : default values of hypothesis
1948 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1949 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1950 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1951 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1952 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1954 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1955 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1956 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1958 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1959 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1963 myActiveDialogBox = 0;
1964 myFilterLibraryDlg = 0;
1968 myEventCallbackCommand = vtkCallbackCommand::New();
1969 myEventCallbackCommand->Delete();
1970 myEventCallbackCommand->SetClientData( this );
1971 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1974 /* load resources for all available meshers */
1975 SMESH::InitAvailableHypotheses();
1978 //=============================================================================
1982 //=============================================================================
1983 SMESHGUI::~SMESHGUI()
1987 //=============================================================================
1991 //=============================================================================
1992 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1994 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1996 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2001 //=============================================================================
2005 //=============================================================================
2006 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2008 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2012 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2013 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2014 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2015 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2016 return autoUpdate && !exceeded;
2019 //=============================================================================
2023 //=============================================================================
2024 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2025 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2027 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2031 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2032 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2033 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2035 SMESH::long_array_var info = theMesh->GetMeshInfo();
2036 long nbOdElems = info[SMDSEntity_0D];
2037 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2038 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2039 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2040 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2041 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2042 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2043 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2044 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
2045 info[SMDSEntity_Polyhedra] +
2046 info[SMDSEntity_Hexagonal_Prism];
2047 long nbBalls = info[SMDSEntity_Ball];
2049 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2050 *nbElements = requestedSize;
2052 *entities = SMESH_Actor::eAllEntity;
2055 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2057 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2059 if ( incrementalLimit ) {
2062 if ( nbOdElems > 0 ) {
2063 if ( total + nbOdElems > updateLimit ) {
2064 *entities = *entities & ~SMESH_Actor::e0DElements;
2065 *hidden = *hidden | SMESH_Actor::e0DElements;
2072 if ( nbEdges > 0 ) {
2073 if ( total + nbEdges > updateLimit ) {
2074 *entities = *entities & ~SMESH_Actor::eEdges;
2075 *hidden = *hidden | SMESH_Actor::eEdges;
2082 if ( nbFaces > 0 ) {
2083 if ( total + nbFaces > updateLimit ) {
2084 *entities = *entities & ~SMESH_Actor::eFaces;
2085 *hidden = *hidden | SMESH_Actor::eFaces;
2092 if ( nbVolumes > 0 ) {
2093 if ( total + nbVolumes > updateLimit ) {
2094 *entities = *entities & ~SMESH_Actor::eVolumes;
2095 *hidden = *hidden | SMESH_Actor::eVolumes;
2102 if ( nbBalls > 0 ) {
2103 if ( total + nbBalls > updateLimit ) {
2104 *entities = *entities & ~SMESH_Actor::eBallElem;
2105 *hidden = *hidden | SMESH_Actor::eBallElem;
2113 return autoUpdate && !exceeded;
2116 //=============================================================================
2120 //=============================================================================
2121 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2123 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2126 //=============================================================================
2130 //=============================================================================
2131 SMESHGUI* SMESHGUI::GetSMESHGUI()
2133 SMESHGUI* smeshMod = 0;
2134 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2137 CAM_Module* module = app->module( "Mesh" );
2138 smeshMod = dynamic_cast<SMESHGUI*>( module );
2141 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2143 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2146 _PTR(Study) aStudy = study->studyDS();
2148 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2157 Standard_EXPORT SMESHGUI* GetComponentGUI()
2159 return SMESHGUI::GetSMESHGUI();
2163 //=============================================================================
2167 //=============================================================================
2168 void SMESHGUI::SetState(int aState)
2173 //=============================================================================
2177 //=============================================================================
2178 void SMESHGUI::ResetState()
2183 //=============================================================================
2187 //=============================================================================
2188 void SMESHGUI::EmitSignalDeactivateDialog()
2190 emit SignalDeactivateActiveDialog();
2193 //=============================================================================
2197 //=============================================================================
2198 void SMESHGUI::EmitSignalStudyFrameChanged()
2200 emit SignalStudyFrameChanged();
2203 //=============================================================================
2207 //=============================================================================
2208 void SMESHGUI::EmitSignalCloseAllDialogs()
2210 emit SignalCloseAllDialogs();
2213 //=============================================================================
2217 //=============================================================================
2218 void SMESHGUI::EmitSignalVisibilityChanged()
2220 emit SignalVisibilityChanged();
2223 //=============================================================================
2227 //=============================================================================
2228 void SMESHGUI::EmitSignalCloseView()
2230 emit SignalCloseView();
2233 //=============================================================================
2237 //=============================================================================
2238 void SMESHGUI::EmitSignalActivatedViewManager()
2240 emit SignalActivatedViewManager();
2243 //=============================================================================
2247 //=============================================================================
2248 QDialog *SMESHGUI::GetActiveDialogBox()
2250 return myActiveDialogBox;
2253 //=============================================================================
2257 //=============================================================================
2258 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2260 myActiveDialogBox = (QDialog *) aDlg;
2264 //=============================================================================
2268 //=============================================================================
2269 SUIT_Desktop* SMESHGUI::desktop()
2271 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2273 return app->desktop();
2278 //=============================================================================
2282 //=============================================================================
2283 SalomeApp_Study* SMESHGUI::activeStudy()
2285 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2287 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2292 //=============================================================================
2296 //=============================================================================
2297 void SMESHGUI::Modified( bool theIsUpdateActions )
2299 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2300 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2301 appStudy->Modified();
2302 if( theIsUpdateActions )
2303 app->updateActions();
2308 //=============================================================================
2312 //=============================================================================
2313 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2315 /* Here the position is on the bottom right corner - 10 */
2316 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2318 SUIT_Desktop *PP = desktop();
2319 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2320 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2324 //=============================================================================
2328 //=============================================================================
2329 static int isStudyLocked(_PTR(Study) theStudy){
2330 return theStudy->GetProperties()->IsLocked();
2333 static bool checkLock(_PTR(Study) theStudy) {
2334 if (isStudyLocked(theStudy)) {
2335 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2336 QObject::tr("WRN_WARNING"),
2337 QObject::tr("WRN_STUDY_LOCKED") );
2343 //=======================================================================
2344 //function : CheckActiveStudyLocked
2346 //=======================================================================
2348 bool SMESHGUI::isActiveStudyLocked()
2350 _PTR(Study) aStudy = activeStudy()->studyDS();
2351 return checkLock( aStudy );
2354 //=============================================================================
2358 //=============================================================================
2359 bool SMESHGUI::OnGUIEvent( int theCommandID )
2361 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2365 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2366 SUIT_ResourceMgr* mgr = resourceMgr();
2370 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2371 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2374 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2375 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2377 //QAction* act = action( theCommandID );
2379 switch (theCommandID) {
2380 case SMESHOp::OpDelete:
2381 if(checkLock(aStudy)) break;
2384 case SMESHOp::OpImportDAT:
2385 case SMESHOp::OpImportUNV:
2386 case SMESHOp::OpImportMED:
2387 case SMESHOp::OpImportSTL:
2389 case SMESHOp::OpImportCGNS:
2391 case SMESHOp::OpImportSAUV:
2392 case SMESHOp::OpImportGMF:
2394 if(checkLock(aStudy)) break;
2395 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2399 case SMESHOp::OpFileInformation:
2401 SALOME_ListIO selected;
2402 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2404 aSel->selectedObjects( selected );
2405 if( selected.Extent() )
2407 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2408 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2409 if ( !aMesh->_is_nil() )
2411 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2417 case SMESHOp::OpExportDAT:
2418 case SMESHOp::OpExportMED:
2419 case SMESHOp::OpExportUNV:
2420 case SMESHOp::OpExportSTL:
2422 case SMESHOp::OpExportCGNS:
2424 case SMESHOp::OpExportSAUV:
2425 case SMESHOp::OpExportGMF:
2426 case SMESHOp::OpPopupExportDAT:
2427 case SMESHOp::OpPopupExportMED:
2428 case SMESHOp::OpPopupExportUNV:
2429 case SMESHOp::OpPopupExportSTL:
2431 case SMESHOp::OpPopupExportCGNS:
2433 case SMESHOp::OpPopupExportSAUV:
2434 case SMESHOp::OpPopupExportGMF:
2436 ::ExportMeshToFile(theCommandID);
2440 case SMESHOp::OpReset: // SCALAR BAR
2442 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2443 SALOME_ListIO selected;
2445 aSel->selectedObjects( selected );
2447 SALOME_ListIteratorOfListIO it(selected);
2448 for( ; it.More(); it.Next()) {
2449 Handle(SALOME_InteractiveObject) anIO = it.Value();
2450 if( anIO->hasEntry() ) {
2451 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2452 anActor->SetControlMode( SMESH_Actor::eNone );
2453 #ifndef DISABLE_PLOT2DVIEWER
2454 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2459 SMESH::UpdateView();
2462 case SMESHOp::OpScalarBarProperties:
2464 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2467 case SMESHOp::OpShowScalarBar:
2469 // show/hide scalar bar
2470 ::ShowElement(theCommandID);
2473 case SMESHOp::OpSaveDistribution:
2475 // dump control distribution data to the text file
2476 ::SaveDistribution();
2480 case SMESHOp::OpShowDistribution:
2482 // show/hide distribution
2483 ::ShowElement(theCommandID);
2487 #ifndef DISABLE_PLOT2DVIEWER
2488 case SMESHOp::OpPlotDistribution:
2490 // plot distribution
2491 ::PlotDistribution();
2497 case SMESHOp::OpAutoColor:
2501 case SMESHOp::OpDisableAutoColor:
2502 ::DisableAutoColor();
2505 case SMESHOp::OpClipping:
2506 case SMESHOp::OpTransparency:
2507 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2510 case SMESHOp::OpDMWireframe:
2511 case SMESHOp::OpDMShading:
2512 case SMESHOp::OpDMNodes:
2513 case SMESHOp::OpDMShrink:
2514 ::SetDisplayMode(theCommandID, myMarkerMap);
2517 //2D quadratic representation
2518 case SMESHOp::OpRepresentationLines:
2519 case SMESHOp::OpRepresentationArcs:
2520 ::SetDisplayMode(theCommandID, myMarkerMap);
2524 case SMESHOp::OpDE0DElements:
2525 case SMESHOp::OpDEEdges:
2526 case SMESHOp::OpDEFaces:
2527 case SMESHOp::OpDEVolumes:
2528 case SMESHOp::OpDEBalls:
2529 case SMESHOp::OpDEAllEntity:
2530 ::SetDisplayEntity(theCommandID);
2533 // Choose entities to be displayed
2534 case SMESHOp::OpDEChoose:
2536 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2540 case SMESHOp::OpOrientationOnFaces:
2542 LightApp_SelectionMgr* mgr = selectionMgr();
2543 SALOME_ListIO selected; mgr->selectedObjects( selected );
2545 SALOME_ListIteratorOfListIO it(selected);
2546 for( ; it.More(); it.Next()) {
2547 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2548 if(anIObject->hasEntry()) {
2549 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2550 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2557 case SMESHOp::OpUpdate:
2559 if(checkLock(aStudy)) break;
2560 SUIT_OverrideCursor wc;
2562 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2565 SMESH::UpdateView();
2567 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2568 SMESH::OnVisuException();
2570 catch (...) { // PAL16774 (Crash after display of many groups)
2571 SMESH::OnVisuException();
2575 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2576 aSel->selectedObjects( l );
2577 aSel->setSelectedObjects( l );
2581 case SMESHOp::OpHide:
2582 case SMESHOp::OpShow:
2583 case SMESHOp::OpShowOnly:
2585 SMESH::EDisplaing anAction;
2586 switch (theCommandID) {
2587 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2588 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2589 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2592 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2593 SALOME_ListIO sel_objects, to_process;
2595 aSel->selectedObjects( sel_objects );
2597 if ( theCommandID==SMESHOp::OpShowOnly )
2599 MESSAGE("anAction = SMESH::eDisplayOnly");
2600 startOperation( myEraseAll );
2603 extractContainers( sel_objects, to_process );
2606 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2610 SALOME_ListIteratorOfListIO It( to_process );
2611 for ( ; It.More(); It.Next())
2613 Handle(SALOME_InteractiveObject) IOS = It.Value();
2614 if ( IOS->hasEntry() )
2616 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2617 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2618 break; // PAL16774 (Crash after display of many groups)
2620 if (anAction == SMESH::eDisplayOnly)
2621 anAction = SMESH::eDisplay;
2626 // PAL13338 + PAL15161 -->
2627 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2628 MESSAGE("anAction = SMESH::eDisplayOnly");
2629 SMESH::UpdateView();
2630 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2632 // PAL13338 + PAL15161 <--
2634 catch (...) { // PAL16774 (Crash after display of many groups)
2635 SMESH::OnVisuException();
2638 if (anAction == SMESH::eErase) {
2639 MESSAGE("anAction == SMESH::eErase");
2641 aSel->setSelectedObjects( l1 );
2644 aSel->setSelectedObjects( to_process );
2649 case SMESHOp::OpNode:
2651 if(checkLock(aStudy)) break;
2654 EmitSignalDeactivateDialog();
2656 ( new SMESHGUI_NodesDlg( this ) )->show();
2659 SUIT_MessageBox::warning(desktop(),
2660 tr("SMESH_WRN_WARNING"),
2661 tr("SMESH_WRN_VIEWER_VTK"));
2666 case SMESHOp::OpCreateMesh:
2667 case SMESHOp::OpCreateSubMesh:
2668 case SMESHOp::OpEditMeshOrSubMesh:
2669 case SMESHOp::OpCompute:
2670 case SMESHOp::OpPreCompute:
2671 case SMESHOp::OpEvaluate:
2672 case SMESHOp::OpMeshOrder:
2673 startOperation( theCommandID );
2675 case SMESHOp::OpCopyMesh:
2677 if (checkLock(aStudy)) break;
2678 EmitSignalDeactivateDialog();
2679 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2682 case SMESHOp::OpBuildCompoundMesh:
2684 if (checkLock(aStudy)) break;
2685 EmitSignalDeactivateDialog();
2686 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2690 case SMESHOp::OpDiagonalInversion:
2691 case SMESHOp::OpUnionOfTwoTriangle:
2695 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2696 tr( "NOT_A_VTK_VIEWER" ) );
2700 if ( checkLock( aStudy ) )
2703 /*Standard_Boolean aRes;
2704 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2705 if ( aMesh->_is_nil() )
2707 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2708 tr( "SMESH_BAD_SELECTION" ) );
2712 EmitSignalDeactivateDialog();
2713 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2714 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2716 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2719 case SMESHOp::OpOrientation:
2720 case SMESHOp::OpUnionOfTriangles:
2721 case SMESHOp::OpCuttingOfQuadrangles:
2722 case SMESHOp::OpSplitVolumes:
2726 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2727 tr( "NOT_A_VTK_VIEWER" ) );
2731 if ( checkLock( aStudy ) )
2734 EmitSignalDeactivateDialog();
2735 SMESHGUI_MultiEditDlg* aDlg = NULL;
2736 if ( theCommandID == SMESHOp::OpOrientation )
2737 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2738 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2739 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2740 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2741 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2743 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2748 case SMESHOp::OpSmoothing:
2750 if(checkLock(aStudy)) break;
2752 EmitSignalDeactivateDialog();
2753 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2756 SUIT_MessageBox::warning(desktop(),
2757 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2761 case SMESHOp::OpExtrusion:
2763 if (checkLock(aStudy)) break;
2765 EmitSignalDeactivateDialog();
2766 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2768 SUIT_MessageBox::warning(desktop(),
2769 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2773 case SMESHOp::OpExtrusionAlongAPath:
2775 if (checkLock(aStudy)) break;
2777 EmitSignalDeactivateDialog();
2778 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2780 SUIT_MessageBox::warning(desktop(),
2781 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2785 case SMESHOp::OpRevolution:
2787 if(checkLock(aStudy)) break;
2789 EmitSignalDeactivateDialog();
2790 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2793 SUIT_MessageBox::warning(desktop(),
2794 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2798 case SMESHOp::OpPatternMapping:
2800 if ( checkLock( aStudy ) )
2804 EmitSignalDeactivateDialog();
2805 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2808 SUIT_MessageBox::warning(desktop(),
2809 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2813 case SMESHOp::OpSplitBiQuadratic:
2814 case SMESHOp::OpConvertMeshToQuadratic:
2815 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2816 case SMESHOp::OpReorientFaces:
2817 case SMESHOp::OpCreateGeometryGroup:
2819 startOperation( theCommandID );
2822 case SMESHOp::OpCreateGroup:
2826 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2827 tr( "NOT_A_VTK_VIEWER" ) );
2831 if(checkLock(aStudy)) break;
2832 EmitSignalDeactivateDialog();
2833 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2835 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2836 SALOME_ListIO selected;
2838 aSel->selectedObjects( selected );
2840 int nbSel = selected.Extent();
2842 // check if mesh is selected
2843 aMesh = SMESH::GetMeshByIO( selected.First() );
2845 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2850 case SMESHOp::OpConstructGroup:
2854 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2855 tr( "NOT_A_VTK_VIEWER" ) );
2859 if(checkLock(aStudy)) break;
2860 EmitSignalDeactivateDialog();
2862 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2863 SALOME_ListIO selected;
2865 aSel->selectedObjects( selected );
2867 int nbSel = selected.Extent();
2869 // check if submesh is selected
2870 Handle(SALOME_InteractiveObject) IObject = selected.First();
2871 if (IObject->hasEntry()) {
2872 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2874 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2875 if (!aSubMesh->_is_nil()) {
2877 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2878 // get submesh elements list by types
2879 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2880 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2881 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2882 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2883 // create group for each type o elements
2884 QString aName = IObject->getName();
2885 QStringList anEntryList;
2886 if (aNodes->length() > 0) {
2887 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2888 aGroup->Add(aNodes.inout());
2889 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2890 anEntryList.append( aSObject->GetID().c_str() );
2892 if (aEdges->length() > 0) {
2893 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2894 aGroup->Add(aEdges.inout());
2895 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2896 anEntryList.append( aSObject->GetID().c_str() );
2898 if (aFaces->length() > 0) {
2899 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2900 aGroup->Add(aFaces.inout());
2901 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2902 anEntryList.append( aSObject->GetID().c_str() );
2904 if (aVolumes->length() > 0) {
2905 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2906 aGroup->Add(aVolumes.inout());
2907 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2908 anEntryList.append( aSObject->GetID().c_str() );
2911 anApp->browseObjects( anEntryList );
2913 catch(const SALOME::SALOME_Exception & S_ex){
2914 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2921 SUIT_MessageBox::warning(desktop(),
2922 tr("SMESH_WRN_WARNING"),
2923 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2928 case SMESHOp::OpEditGroup:
2932 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2933 tr( "NOT_A_VTK_VIEWER" ) );
2937 if(checkLock(aStudy)) break;
2938 EmitSignalDeactivateDialog();
2940 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2941 SALOME_ListIO selected;
2943 aSel->selectedObjects( selected );
2945 SALOME_ListIteratorOfListIO It (selected);
2946 int nbSelectedGroups = 0;
2947 for ( ; It.More(); It.Next() )
2949 SMESH::SMESH_GroupBase_var aGroup =
2950 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2951 if (!aGroup->_is_nil()) {
2953 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2957 if (nbSelectedGroups == 0)
2959 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2965 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
2967 if(checkLock(aStudy)) break;
2968 if (myState == 800) {
2969 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2970 if (aDlg) aDlg->onAdd();
2975 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
2977 if(checkLock(aStudy)) break;
2978 if (myState == 800) {
2979 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2980 if (aDlg) aDlg->onRemove();
2985 case SMESHOp::OpEditGeomGroupAsGroup:
2989 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2990 tr( "NOT_A_VTK_VIEWER" ) );
2994 if(checkLock(aStudy)) break;
2995 EmitSignalDeactivateDialog();
2997 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2998 SALOME_ListIO selected;
3000 aSel->selectedObjects( selected );
3002 SALOME_ListIteratorOfListIO It (selected);
3003 for ( ; It.More(); It.Next() )
3005 SMESH::SMESH_GroupOnGeom_var aGroup =
3006 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3007 if (!aGroup->_is_nil()) {
3008 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3013 SMESH::SMESH_GroupOnFilter_var aGroup =
3014 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3015 if (!aGroup->_is_nil()) {
3016 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3024 case SMESHOp::OpUnionGroups:
3025 case SMESHOp::OpIntersectGroups:
3026 case SMESHOp::OpCutGroups:
3030 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3031 tr( "NOT_A_VTK_VIEWER" ) );
3035 if ( checkLock( aStudy ) )
3038 EmitSignalDeactivateDialog();
3040 SMESHGUI_GroupOpDlg* aDlg = 0;
3041 if ( theCommandID == SMESHOp::OpUnionGroups )
3042 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3043 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3044 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3046 aDlg = new SMESHGUI_CutGroupsDlg( this );
3053 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3055 if ( checkLock( aStudy ) )
3058 EmitSignalDeactivateDialog();
3059 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3065 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3069 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3070 tr( "NOT_A_VTK_VIEWER" ) );
3074 if ( checkLock( aStudy ) )
3077 EmitSignalDeactivateDialog();
3079 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3083 case SMESHOp::OpMeshInformation:
3084 case SMESHOp::OpWhatIs:
3086 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3087 EmitSignalDeactivateDialog();
3088 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3089 SALOME_ListIO selected;
3091 aSel->selectedObjects( selected );
3093 if ( selected.Extent() > 1 ) { // a dlg for each IO
3094 SALOME_ListIteratorOfListIO It( selected );
3095 for ( ; It.More(); It.Next() ) {
3096 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3097 dlg->showInfo( It.Value() );
3102 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3108 case SMESHOp::OpFindElementByPoint:
3110 startOperation( theCommandID );
3114 case SMESHOp::OpEditHypothesis:
3116 if(checkLock(aStudy)) break;
3118 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3119 SALOME_ListIO selected;
3121 aSel->selectedObjects( selected );
3123 int nbSel = selected.Extent();
3126 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3127 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3129 if ( !aHypothesis->_is_nil() )
3131 SMESHGUI_GenericHypothesisCreator* aCreator =
3132 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3135 // set geometry of mesh and sub-mesh to aCreator
3136 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3137 if ( selected.Extent() == 1 )
3139 QString subGeomID, meshGeomID;
3140 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3141 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3143 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3144 aCreator->setShapeEntry( subGeomID );
3145 aCreator->setMainShapeEntry( meshGeomID );
3149 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3159 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3161 if(checkLock(aStudy)) break;
3162 SUIT_OverrideCursor wc;
3164 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3165 SALOME_ListIO selected;
3167 aSel->selectedObjects( selected, QString::null, false );
3169 SALOME_ListIteratorOfListIO It(selected);
3170 for (int i = 0; It.More(); It.Next(), i++) {
3171 Handle(SALOME_InteractiveObject) IObject = It.Value();
3172 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3175 aSel->setSelectedObjects( l1 );
3180 case SMESHOp::OpElem0D:
3181 case SMESHOp::OpBall:
3182 case SMESHOp::OpEdge:
3183 case SMESHOp::OpTriangle:
3184 case SMESHOp::OpQuadrangle:
3185 case SMESHOp::OpPolygon:
3186 case SMESHOp::OpTetrahedron:
3187 case SMESHOp::OpHexahedron:
3188 case SMESHOp::OpPentahedron:
3189 case SMESHOp::OpPyramid:
3190 case SMESHOp::OpHexagonalPrism:
3192 if(checkLock(aStudy)) break;
3194 EmitSignalDeactivateDialog();
3195 SMDSAbs_EntityType type = SMDSEntity_Edge;
3196 switch (theCommandID) {
3197 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3198 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3199 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3200 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3201 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3202 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3203 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3204 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3205 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3206 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3209 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3212 SUIT_MessageBox::warning(desktop(),
3213 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3217 case SMESHOp::OpPolyhedron:
3219 if(checkLock(aStudy)) break;
3221 EmitSignalDeactivateDialog();
3222 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3225 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3226 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3230 case SMESHOp::OpQuadraticEdge:
3231 case SMESHOp::OpQuadraticTriangle:
3232 case SMESHOp::OpBiQuadraticTriangle:
3233 case SMESHOp::OpQuadraticQuadrangle:
3234 case SMESHOp::OpBiQuadraticQuadrangle:
3235 case SMESHOp::OpQuadraticPolygon:
3236 case SMESHOp::OpQuadraticTetrahedron:
3237 case SMESHOp::OpQuadraticPyramid:
3238 case SMESHOp::OpQuadraticPentahedron:
3239 case SMESHOp::OpQuadraticHexahedron:
3240 case SMESHOp::OpTriQuadraticHexahedron:
3242 if(checkLock(aStudy)) break;
3244 EmitSignalDeactivateDialog();
3245 SMDSAbs_EntityType type = SMDSEntity_Last;
3247 switch (theCommandID) {
3248 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3249 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3250 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3251 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3252 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3253 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3254 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3255 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3256 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3257 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3258 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3261 if ( type != SMDSEntity_Last )
3262 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3265 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3266 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3270 case SMESHOp::OpRemoveNodes:
3272 if(checkLock(aStudy)) break;
3274 EmitSignalDeactivateDialog();
3275 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3278 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3279 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3283 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3285 if(checkLock(aStudy)) break;
3287 EmitSignalDeactivateDialog();
3288 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3292 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3293 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3297 case SMESHOp::OpClearMesh: {
3299 if(checkLock(aStudy)) break;
3301 SALOME_ListIO selected;
3302 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3303 aSel->selectedObjects( selected );
3305 SUIT_OverrideCursor wc;
3306 SALOME_ListIteratorOfListIO It (selected);
3307 for ( ; It.More(); It.Next() )
3309 Handle(SALOME_InteractiveObject) IOS = It.Value();
3310 SMESH::SMESH_Mesh_var aMesh =
3311 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3312 if ( aMesh->_is_nil()) continue;
3314 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3316 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3317 SMESH::ModifiedMesh( aMeshSObj, false, true);
3318 // hide groups and submeshes
3319 _PTR(ChildIterator) anIter =
3320 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3321 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3323 _PTR(SObject) so = anIter->Value();
3324 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3327 catch (const SALOME::SALOME_Exception& S_ex){
3329 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3333 SMESH::UpdateView();
3337 case SMESHOp::OpRemoveOrphanNodes:
3339 if(checkLock(aStudy)) break;
3340 SALOME_ListIO selected;
3341 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3342 aSel->selectedObjects( selected );
3343 if ( selected.Extent() == 1 ) {
3344 Handle(SALOME_InteractiveObject) anIO = selected.First();
3345 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3346 if ( !aMesh->_is_nil() ) {
3347 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3348 tr( "SMESH_WARNING" ),
3349 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3350 SUIT_MessageBox::Yes |
3351 SUIT_MessageBox::No,
3352 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3355 SUIT_OverrideCursor wc;
3356 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3357 int removed = aMeshEditor->RemoveOrphanNodes();
3358 SUIT_MessageBox::information(SMESHGUI::desktop(),
3359 tr("SMESH_INFORMATION"),
3360 tr("NB_NODES_REMOVED").arg(removed));
3361 if ( removed > 0 ) {
3362 SMESH::UpdateView();
3363 SMESHGUI::Modified();
3366 catch (const SALOME::SALOME_Exception& S_ex) {
3367 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3376 case SMESHOp::OpRenumberingNodes:
3378 if(checkLock(aStudy)) break;
3380 EmitSignalDeactivateDialog();
3381 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3385 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3386 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3390 case SMESHOp::OpRenumberingElements:
3392 if(checkLock(aStudy)) break;
3394 EmitSignalDeactivateDialog();
3395 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3399 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3400 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3404 case SMESHOp::OpTranslation:
3406 if(checkLock(aStudy)) break;
3408 EmitSignalDeactivateDialog();
3409 ( new SMESHGUI_TranslationDlg( this ) )->show();
3412 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3413 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3417 case SMESHOp::OpRotation:
3419 if(checkLock(aStudy)) break;
3421 EmitSignalDeactivateDialog();
3422 ( new SMESHGUI_RotationDlg( this ) )->show();
3425 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3426 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3430 case SMESHOp::OpSymmetry:
3432 if(checkLock(aStudy)) break;
3434 EmitSignalDeactivateDialog();
3435 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3438 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3439 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3443 case SMESHOp::OpScale:
3445 if(checkLock(aStudy)) break;
3447 EmitSignalDeactivateDialog();
3448 ( new SMESHGUI_ScaleDlg( this ) )->show();
3451 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3452 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3457 case SMESHOp::OpSewing:
3459 if(checkLock(aStudy)) break;
3461 EmitSignalDeactivateDialog();
3462 ( new SMESHGUI_SewingDlg( this ) )->show();
3465 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3466 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3470 case SMESHOp::OpMergeNodes:
3472 if(checkLock(aStudy)) break;
3474 EmitSignalDeactivateDialog();
3475 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3478 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3479 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3483 case SMESHOp::OpMergeElements:
3485 if (checkLock(aStudy)) break;
3487 EmitSignalDeactivateDialog();
3488 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3490 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3491 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3496 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3497 startOperation( SMESHOp::OpMoveNode );
3500 case SMESHOp::OpDuplicateNodes:
3502 if(checkLock(aStudy)) break;
3504 EmitSignalDeactivateDialog();
3505 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3508 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3509 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3514 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3515 startOperation( SMESHOp::OpElem0DOnElemNodes );
3518 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3520 static QList<int> aTypes;
3521 if ( aTypes.isEmpty() )
3523 aTypes.append( SMESH::NODE );
3524 aTypes.append( SMESH::EDGE );
3525 aTypes.append( SMESH::FACE );
3526 aTypes.append( SMESH::VOLUME );
3528 if (!myFilterLibraryDlg)
3529 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3530 else if (myFilterLibraryDlg->isHidden())
3531 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3532 myFilterLibraryDlg->raise();
3536 case SMESHOp::OpFreeNode:
3537 case SMESHOp::OpEqualNode:
3538 case SMESHOp::OpFreeEdge:
3539 case SMESHOp::OpFreeBorder:
3540 case SMESHOp::OpLength:
3541 case SMESHOp::OpConnection:
3542 case SMESHOp::OpEqualEdge:
3543 case SMESHOp::OpFreeFace:
3544 case SMESHOp::OpBareBorderFace:
3545 case SMESHOp::OpOverConstrainedFace:
3546 case SMESHOp::OpLength2D:
3547 case SMESHOp::OpConnection2D:
3548 case SMESHOp::OpArea:
3549 case SMESHOp::OpTaper:
3550 case SMESHOp::OpAspectRatio:
3551 case SMESHOp::OpMinimumAngle:
3552 case SMESHOp::OpWarpingAngle:
3553 case SMESHOp::OpSkew:
3554 case SMESHOp::OpMaxElementLength2D:
3555 case SMESHOp::OpEqualFace:
3556 case SMESHOp::OpAspectRatio3D:
3557 case SMESHOp::OpVolume:
3558 case SMESHOp::OpMaxElementLength3D:
3559 case SMESHOp::OpBareBorderVolume:
3560 case SMESHOp::OpOverConstrainedVolume:
3561 case SMESHOp::OpEqualVolume:
3564 LightApp_SelectionMgr* mgr = selectionMgr();
3565 SALOME_ListIO selected; mgr->selectedObjects( selected );
3567 if( !selected.IsEmpty() ) {
3568 SUIT_OverrideCursor wc;
3569 ::Control( theCommandID );
3572 SUIT_MessageBox::warning(desktop(),
3573 tr( "SMESH_WRN_WARNING" ),
3574 tr( "SMESH_BAD_SELECTION" ) );
3578 SUIT_MessageBox::warning(desktop(),
3579 tr( "SMESH_WRN_WARNING" ),
3580 tr( "NOT_A_VTK_VIEWER" ) );
3583 case SMESHOp::OpOverallMeshQuality:
3584 OverallMeshQuality();
3586 case SMESHOp::OpNumberingNodes:
3588 SUIT_OverrideCursor wc;
3589 LightApp_SelectionMgr* mgr = selectionMgr();
3590 SALOME_ListIO selected; mgr->selectedObjects( selected );
3592 SALOME_ListIteratorOfListIO it(selected);
3593 for( ; it.More(); it.Next()) {
3594 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3595 if(anIObject->hasEntry()) {
3596 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3597 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3603 case SMESHOp::OpNumberingElements:
3605 SUIT_OverrideCursor wc;
3606 LightApp_SelectionMgr* mgr = selectionMgr();
3607 SALOME_ListIO selected; mgr->selectedObjects( selected );
3609 SALOME_ListIteratorOfListIO it(selected);
3610 for( ; it.More(); it.Next()) {
3611 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3612 if(anIObject->hasEntry())
3613 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3614 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3619 case SMESHOp::OpPropertiesLength:
3620 case SMESHOp::OpPropertiesArea:
3621 case SMESHOp::OpPropertiesVolume:
3622 case SMESHOp::OpMinimumDistance:
3623 case SMESHOp::OpBoundingBox:
3625 int page = SMESHGUI_MeasureDlg::MinDistance;
3626 if ( theCommandID == SMESHOp::OpBoundingBox )
3627 page = SMESHGUI_MeasureDlg::BoundingBox;
3628 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3629 page = SMESHGUI_MeasureDlg::Length;
3630 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3631 page = SMESHGUI_MeasureDlg::Area;
3632 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3633 page = SMESHGUI_MeasureDlg::Volume;
3635 EmitSignalDeactivateDialog();
3636 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3640 case SMESHOp::OpSortChild:
3646 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3647 //updateObjBrowser();
3651 //=============================================================================
3655 //=============================================================================
3656 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3661 //=============================================================================
3665 //=============================================================================
3666 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3671 //=============================================================================
3675 //=============================================================================
3676 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3681 //=============================================================================
3682 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3683 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3685 //=============================================================================
3686 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3687 SUIT_ViewWindow* wnd )
3689 if(theIO->hasEntry()){
3690 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3691 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3695 //=======================================================================
3696 // function : createSMESHAction
3698 //=======================================================================
3699 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3700 const int key, const bool toggle, const QString& shortcutAction )
3703 QWidget* parent = application()->desktop();
3704 SUIT_ResourceMgr* resMgr = resourceMgr();
3706 if ( !icon_id.isEmpty() )
3707 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3709 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3710 if ( !pix.isNull() )
3711 icon = QIcon( pix );
3713 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3714 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3715 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3717 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3718 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3721 //=======================================================================
3722 // function : createPopupItem
3724 //=======================================================================
3725 void SMESHGUI::createPopupItem( const int id,
3726 const QString& clients,
3727 const QString& types,
3728 const QString& theRule,
3731 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3732 popupMgr()->insert( action( id ), pId, 0 );
3734 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3735 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3736 QString rule = "(%1) and (%2) and (%3)";
3737 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3738 if( clients.isEmpty() )
3739 rule = rule.arg( QString( "true" ) );
3741 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3742 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3745 bool cont = myRules.contains( id );
3747 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3749 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3750 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3753 //=======================================================================
3754 // function : initialize
3756 //=======================================================================
3757 void SMESHGUI::initialize( CAM_Application* app )
3759 SalomeApp_Module::initialize( app );
3761 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3763 /* Automatic Update flag */
3764 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3766 // ----- create actions --------------
3768 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3769 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3770 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3771 //createSMESHAction( 114, "NUM" );
3772 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3774 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3776 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3777 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3778 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3779 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3780 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3781 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3783 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3785 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3786 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3787 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3788 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3789 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3790 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3792 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3794 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3795 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3796 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3797 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3798 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3799 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3800 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3801 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3802 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3803 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3804 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3805 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3806 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3807 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3808 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3809 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3810 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3811 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3812 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3813 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3814 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3815 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3816 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3817 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3818 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3819 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3820 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3821 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3822 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3823 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3825 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3826 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3827 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3828 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3829 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3830 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3831 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3832 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3833 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3834 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3835 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3836 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3837 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3838 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3839 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3840 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3841 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3842 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3843 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3844 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3845 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3846 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3847 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3848 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3849 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3850 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3851 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3853 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3854 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3855 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3856 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3857 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3858 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3859 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3860 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3861 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3862 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3863 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3864 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3865 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3866 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3867 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3868 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3869 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3870 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3871 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3872 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3873 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3874 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3875 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3876 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3877 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3879 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3880 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3881 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3882 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3884 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3885 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3887 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3888 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3889 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3890 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3891 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3892 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3893 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3894 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3895 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3896 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3897 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3898 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3899 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3900 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3901 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3902 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3903 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3904 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3905 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3906 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3907 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3908 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3909 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3910 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3912 createSMESHAction( SMESHOp::OpReset, "RESET" );
3913 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3914 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
3915 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3916 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3917 #ifndef DISABLE_PLOT2DVIEWER
3918 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3920 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3921 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3922 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3923 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3924 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3925 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3926 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3927 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3928 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3929 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3930 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
3931 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
3932 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3934 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3935 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3937 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3938 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3939 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3940 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3941 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3942 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3943 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3944 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3945 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3947 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3948 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3949 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3950 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3951 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
3953 createSMESHAction( SMESHOp::OpHide, "HIDE" );
3954 createSMESHAction( SMESHOp::OpShow, "SHOW" );
3955 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
3957 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
3959 QList<int> aCtrlActions;
3960 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode // node controls
3961 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
3962 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
3963 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
3964 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
3965 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
3966 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
3967 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
3968 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
3969 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
3970 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
3971 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
3972 aCtrlGroup->setExclusive( true );
3973 for( int i = 0; i < aCtrlActions.size(); i++ )
3974 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
3976 // ----- create menu --------------
3977 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3978 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3979 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3980 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3981 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3982 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3983 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3984 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3986 createMenu( separator(), fileId );
3988 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
3989 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
3990 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3991 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3992 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
3993 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
3994 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
3995 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
3996 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3997 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3998 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3999 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4000 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4002 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4003 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4004 createMenu( SMESHOp::OpImportMED, importId, -1 );
4005 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4007 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4009 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4010 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4011 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4012 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4013 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4014 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4016 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4018 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4019 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4020 createMenu( separator(), fileId, 10 );
4022 createMenu( SMESHOp::OpDelete, editId, -1 );
4024 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4026 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4027 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4028 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4029 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4030 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4031 createMenu( separator(), meshId, -1 );
4032 createMenu( SMESHOp::OpCompute, meshId, -1 );
4033 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4034 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4035 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4036 createMenu( separator(), meshId, -1 );
4037 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4038 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4039 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4040 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4041 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4042 createMenu( separator(), meshId, -1 );
4043 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4044 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4045 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4046 createMenu( separator(), meshId, -1 );
4047 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4048 createMenu( separator(), meshId, -1 );
4049 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4050 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4051 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4052 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4053 createMenu( separator(), meshId, -1 );
4055 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4056 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4057 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4058 createMenu( SMESHOp::OpLength, edgeId, -1 );
4059 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4060 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4061 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4062 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4063 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4064 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4065 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4066 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4067 createMenu( SMESHOp::OpArea, faceId, -1 );
4068 createMenu( SMESHOp::OpTaper, faceId, -1 );
4069 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4070 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4071 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4072 createMenu( SMESHOp::OpSkew, faceId, -1 );
4073 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4074 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4075 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4076 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4077 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4078 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4079 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4080 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4081 createMenu( separator(), ctrlId, -1 );
4082 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4083 createMenu( separator(), ctrlId, -1 );
4084 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4086 createMenu( SMESHOp::OpNode, addId, -1 );
4087 createMenu( SMESHOp::OpElem0D, addId, -1 );
4088 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4089 createMenu( SMESHOp::OpBall, addId, -1 );
4090 createMenu( SMESHOp::OpEdge, addId, -1 );
4091 createMenu( SMESHOp::OpTriangle, addId, -1 );
4092 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4093 createMenu( SMESHOp::OpPolygon, addId, -1 );
4094 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4095 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4096 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4097 createMenu( SMESHOp::OpPyramid, addId, -1 );
4098 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4099 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4100 createMenu( separator(), addId, -1 );
4101 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4102 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4103 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4104 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4105 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4106 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4107 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4108 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4109 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4110 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4111 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4113 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4114 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4115 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4116 createMenu( separator(), removeId, -1 );
4117 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4118 createMenu( separator(), removeId, -1 );
4119 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4121 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4122 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4124 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4125 createMenu( SMESHOp::OpRotation, transfId, -1 );
4126 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4127 createMenu( SMESHOp::OpScale, transfId, -1 );
4128 createMenu( SMESHOp::OpSewing, transfId, -1 );
4129 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4130 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4131 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4133 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4134 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4135 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4136 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4137 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4138 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4139 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4140 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4141 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4142 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4143 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4144 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4145 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4146 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4147 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4148 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4150 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4151 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4152 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4153 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4154 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4155 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4157 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4158 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4159 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4160 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4162 // ----- create toolbars --------------
4163 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4164 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4165 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4166 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4167 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4168 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4169 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4170 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4171 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4172 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4173 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4174 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4175 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4176 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4177 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4179 createTool( SMESHOp::OpCreateMesh, meshTb );
4180 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4181 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4182 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4183 createTool( SMESHOp::OpCopyMesh, meshTb );
4184 createTool( separator(), meshTb );
4185 createTool( SMESHOp::OpCompute, meshTb );
4186 createTool( SMESHOp::OpPreCompute, meshTb );
4187 createTool( SMESHOp::OpEvaluate, meshTb );
4188 createTool( SMESHOp::OpMeshOrder, meshTb );
4190 createTool( SMESHOp::OpCreateGroup, groupTb );
4191 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4192 createTool( SMESHOp::OpConstructGroup, groupTb );
4193 createTool( SMESHOp::OpEditGroup, groupTb );
4195 createTool( SMESHOp::OpMeshInformation, info );
4196 //createTool( SMESHOp::OpStdInfo, meshTb );
4197 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4198 createTool( SMESHOp::OpFindElementByPoint, info );
4200 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4201 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4203 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4204 createTool( SMESHOp::OpLength, ctrl1dTb );
4205 createTool( SMESHOp::OpConnection, ctrl1dTb );
4206 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4208 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4209 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4210 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4211 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4212 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4213 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4214 createTool( SMESHOp::OpArea, ctrl2dTb );
4215 createTool( SMESHOp::OpTaper, ctrl2dTb );
4216 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4217 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4218 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4219 createTool( SMESHOp::OpSkew, ctrl2dTb );
4220 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4221 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4223 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4224 createTool( SMESHOp::OpVolume, ctrl3dTb );
4225 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4226 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4227 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4228 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4230 createTool( SMESHOp::OpNode, addElemTb );
4231 createTool( SMESHOp::OpElem0D, addElemTb );
4232 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4233 createTool( SMESHOp::OpBall, addElemTb );
4234 createTool( SMESHOp::OpEdge, addElemTb );
4235 createTool( SMESHOp::OpTriangle, addElemTb );
4236 createTool( SMESHOp::OpQuadrangle, addElemTb );
4237 createTool( SMESHOp::OpPolygon, addElemTb );
4238 createTool( SMESHOp::OpTetrahedron, addElemTb );
4239 createTool( SMESHOp::OpHexahedron, addElemTb );
4240 createTool( SMESHOp::OpPentahedron, addElemTb );
4241 createTool( SMESHOp::OpPyramid, addElemTb );
4242 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4243 createTool( SMESHOp::OpPolyhedron, addElemTb );
4245 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4246 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4247 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4248 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4249 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4250 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4251 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4252 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4253 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4254 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4255 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4257 createTool( SMESHOp::OpRemoveNodes, remTb );
4258 createTool( SMESHOp::OpRemoveElements, remTb );
4259 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4260 createTool( SMESHOp::OpClearMesh, remTb );
4262 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4263 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4265 createTool( SMESHOp::OpTranslation, transformTb );
4266 createTool( SMESHOp::OpRotation, transformTb );
4267 createTool( SMESHOp::OpSymmetry, transformTb );
4268 createTool( SMESHOp::OpScale, transformTb );
4269 createTool( SMESHOp::OpSewing, transformTb );
4270 createTool( SMESHOp::OpMergeNodes, transformTb );
4271 createTool( SMESHOp::OpMergeElements, transformTb );
4272 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4274 createTool( SMESHOp::OpMoveNode, modifyTb );
4275 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4276 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4277 createTool( SMESHOp::OpOrientation, modifyTb );
4278 createTool( SMESHOp::OpReorientFaces, modifyTb );
4279 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4280 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4281 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4282 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4283 createTool( SMESHOp::OpSmoothing, modifyTb );
4284 createTool( SMESHOp::OpExtrusion, modifyTb );
4285 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4286 createTool( SMESHOp::OpRevolution, modifyTb );
4287 createTool( SMESHOp::OpPatternMapping, modifyTb );
4288 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4289 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4291 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4293 createTool( SMESHOp::OpUpdate, dispModeTb );
4295 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4296 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4299 QString OB = "'ObjectBrowser'",
4300 View = "'" + SVTK_Viewer::Type() + "'",
4302 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4303 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4304 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4305 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4306 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4307 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4308 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4309 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4310 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4311 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4312 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4314 mesh_part = mesh + " " + subMesh + " " + group,
4315 mesh_group = mesh + " " + group,
4316 hyp_alg = hypo + " " + algo;
4318 // popup for object browser
4320 isInvisible("not( isVisible )"),
4321 isEmpty("numberOfNodes = 0"),
4322 isNotEmpty("numberOfNodes <> 0"),
4324 // has nodes, edges, etc in VISIBLE! actor
4325 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4326 hasElems("(count( elemTypes ) > 0)"),
4327 hasDifferentElems("(count( elemTypes ) > 1)"),
4328 hasBalls("({'BallElem'} in elemTypes)"),
4329 hasElems0d("({'Elem0d'} in elemTypes)"),
4330 hasEdges("({'Edge'} in elemTypes)"),
4331 hasFaces("({'Face'} in elemTypes)"),
4332 hasVolumes("({'Volume'} in elemTypes)"),
4333 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4335 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4336 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4337 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, mesh );
4338 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, subMesh, "&& hasGeomReference" );
4339 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4340 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4342 popupMgr()->insert( separator(), -1, 0 );
4343 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& isComputable" );
4344 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& isPreComputable" );
4345 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& isComputable" );
4346 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& isComputable && hasGeomReference" );
4347 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4348 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4349 createPopupItem( SMESHOp::OpFindElementByPoint, OB, mesh_group );
4350 createPopupItem( SMESHOp::OpOverallMeshQuality, OB, mesh_part );
4351 popupMgr()->insert( separator(), -1, 0 );
4352 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh );
4353 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& hasGeomReference" );
4354 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4355 popupMgr()->insert( separator(), -1, 0 );
4356 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo);
4357 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4358 popupMgr()->insert( separator(), -1, 0 );
4359 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh + " " + subMesh ); // convert to quadratic
4360 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh + " " + group, // create 2D mesh from 3D
4362 popupMgr()->insert( separator(), -1, 0 );
4363 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4364 popupMgr()->insert( separator(), -1, 0 );
4366 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4367 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4368 QString only_one_2D = only_one_non_empty + " && dim>1";
4370 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4371 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4372 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4373 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4375 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4377 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4378 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4379 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4380 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4381 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4382 popupMgr()->insert( separator(), -1, 0 );
4385 createPopupItem( SMESHOp::OpEditGroup, View, group );
4386 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4387 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4389 popupMgr()->insert( separator(), -1, 0 );
4390 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4391 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4392 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4393 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4394 popupMgr()->insert( separator(), -1, 0 );
4396 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4397 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4398 popupMgr()->insert( separator(), -1, 0 );
4400 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4401 QString aType = QString( "%1type in {%2}" ).arg( lc );
4402 aType = aType.arg( mesh_part );
4403 QString aMeshInVTK = aClient + "&&" + aType;
4405 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4406 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4407 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4409 //-------------------------------------------------
4411 //-------------------------------------------------
4412 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4414 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4415 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4416 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4418 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4419 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4420 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4422 popupMgr()->insert( separator(), -1, -1 );
4424 //-------------------------------------------------
4426 //-------------------------------------------------
4427 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4429 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4430 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4431 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4433 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4434 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4435 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4437 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4438 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4439 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4441 popupMgr()->insert( separator(), anId, -1 );
4443 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4444 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4445 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4447 //-------------------------------------------------
4449 //-------------------------------------------------
4450 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4452 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4454 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4455 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4456 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4458 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4459 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4460 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4462 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4463 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4464 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4466 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4467 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4468 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4470 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4471 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4472 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4474 popupMgr()->insert( separator(), anId, -1 );
4476 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4477 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4479 popupMgr()->insert( separator(), anId, -1 );
4481 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4482 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4485 //-------------------------------------------------
4486 // Representation of the 2D Quadratic elements
4487 //-------------------------------------------------
4488 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4489 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4490 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4491 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4493 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4494 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4495 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4497 //-------------------------------------------------
4498 // Orientation of faces
4499 //-------------------------------------------------
4500 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4501 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4502 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4504 //-------------------------------------------------
4506 //-------------------------------------------------
4507 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4508 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4510 //-------------------------------------------------
4512 //-------------------------------------------------
4513 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4514 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4516 //-------------------------------------------------
4518 //-------------------------------------------------
4520 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4521 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4522 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4523 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4525 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4527 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4528 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4530 popupMgr()->insert( separator(), anId, -1 );
4532 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4534 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4535 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4536 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4538 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4539 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4540 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4542 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4544 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4545 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4546 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4548 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4549 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4550 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4552 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4553 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4554 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4555 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4556 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4557 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4559 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4561 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4562 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4563 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4565 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4566 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4567 QtxPopupMgr::VisibleRule );
4568 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4570 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4571 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4572 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4574 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4575 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4576 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4578 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4579 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4580 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4582 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4583 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4584 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4586 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4587 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4588 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4590 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4591 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4592 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4594 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4595 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4596 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4598 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4599 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4600 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4602 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4603 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4604 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4606 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4607 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4608 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4610 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4611 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4612 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4613 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4614 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4615 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4617 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4619 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4620 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4621 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4623 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4624 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4625 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4627 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4628 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4629 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4631 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4632 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4633 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4635 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4636 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4637 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4639 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4640 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4641 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4643 popupMgr()->insert( separator(), anId, -1 );
4645 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4646 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4647 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4648 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4649 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4651 popupMgr()->insert( separator(), anId, -1 );
4653 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4655 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4656 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4658 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4659 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4660 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4662 #ifndef DISABLE_PLOT2DVIEWER
4663 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4664 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4667 //-------------------------------------------------
4669 //-------------------------------------------------
4670 popupMgr()->insert( separator(), -1, -1 );
4671 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4672 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4673 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4674 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4676 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4677 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4679 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4680 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4682 popupMgr()->insert( separator(), -1, -1 );
4684 //-------------------------------------------------
4686 //-------------------------------------------------
4687 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4688 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4690 popupMgr()->insert( separator(), -1, -1 );
4692 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4693 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4694 popupMgr()->insert( separator(), -1, -1 );
4696 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4697 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4699 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4700 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4703 //================================================================================
4705 * \brief Return true if SMESH or GEOM objects are selected.
4706 * Is called form LightApp_Module::activateModule() which clear selection if
4707 * not isSelectionCompatible()
4709 //================================================================================
4711 bool SMESHGUI::isSelectionCompatible()
4713 bool isCompatible = true;
4714 SALOME_ListIO selected;
4715 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4716 Sel->selectedObjects( selected );
4718 SALOME_ListIteratorOfListIO It( selected );
4719 for ( ; isCompatible && It.More(); It.Next())
4721 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4722 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4724 return isCompatible;
4728 bool SMESHGUI::reusableOperation( const int id )
4730 // compute, evaluate and precompute are not reusable operations
4731 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4734 bool SMESHGUI::activateModule( SUIT_Study* study )
4736 bool res = SalomeApp_Module::activateModule( study );
4738 setMenuShown( true );
4739 setToolShown( true );
4741 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4742 PyGILState_STATE gstate = PyGILState_Ensure();
4743 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4744 if ( !pluginsmanager ) {
4748 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4753 PyGILState_Release(gstate);
4754 // end of SMESH plugins loading
4756 // Reset actions accelerator keys
4757 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4759 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4760 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4761 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4762 if ( _PTR(Study) aStudy = s->studyDS() )
4763 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4766 // get all view currently opened in the study and connect their signals to
4767 // the corresponding slots of the class.
4768 SUIT_Desktop* aDesk = study->application()->desktop();
4770 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4771 SUIT_ViewWindow* wnd;
4772 foreach ( wnd, wndList )
4776 Py_XDECREF(pluginsmanager);
4780 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4782 setMenuShown( false );
4783 setToolShown( false );
4785 EmitSignalCloseAllDialogs();
4787 // Unset actions accelerator keys
4788 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4790 return SalomeApp_Module::deactivateModule( study );
4793 void SMESHGUI::studyClosed( SUIT_Study* s )
4797 SMESH::RemoveVisuData( s->id() );
4798 SalomeApp_Module::studyClosed( s );
4801 void SMESHGUI::OnGUIEvent()
4803 const QObject* obj = sender();
4804 if ( !obj || !obj->inherits( "QAction" ) )
4806 int id = actionId((QAction*)obj);
4811 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4813 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4814 if ( CORBA::is_nil( myComponentSMESH ) )
4816 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4818 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4819 return aGUI.myComponentSMESH;
4822 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4823 return myComponentSMESH;
4826 QString SMESHGUI::engineIOR() const
4828 CORBA::ORB_var anORB = getApp()->orb();
4829 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4830 return QString( anIOR.in() );
4833 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4835 SalomeApp_Module::contextMenuPopup( client, menu, title );
4837 selectionMgr()->selectedObjects( lst );
4838 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4839 Handle(SALOME_InteractiveObject) io = lst.First();
4840 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4841 _PTR(Study) study = appStudy->studyDS();
4842 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4844 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4845 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4846 aName.remove( (aName.length() - 1), 1 );
4852 LightApp_Selection* SMESHGUI::createSelection() const
4854 return new SMESHGUI_Selection();
4857 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4859 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4860 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4861 #ifndef DISABLE_PYCONSOLE
4862 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4866 void SMESHGUI::viewManagers( QStringList& list ) const
4868 list.append( SVTK_Viewer::Type() );
4871 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4873 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4874 SMESH::UpdateSelectionProp( this );
4876 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4877 for(int i = 0; i < aViews.count() ; i++){
4878 SUIT_ViewWindow *sf = aViews[i];
4881 EmitSignalActivatedViewManager();
4885 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4887 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4888 myClippingPlaneInfoMap.erase( theViewManager );
4891 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4893 theActor->AddObserver( SMESH::DeleteActorEvent,
4894 myEventCallbackCommand.GetPointer(),
4898 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4899 unsigned long theEvent,
4900 void* theClientData,
4903 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4904 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4905 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4906 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4907 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4908 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4909 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4910 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4911 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4912 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4913 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4914 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4915 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4916 if( anActor == *anIter3 ) {
4917 anActorList.erase( anIter3 );
4928 void SMESHGUI::createPreferences()
4930 // General tab ------------------------------------------------------------------------
4931 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4933 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4934 setPreferenceProperty( autoUpdate, "columns", 2 );
4935 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4936 setPreferenceProperty( lim, "min", 0 );
4937 setPreferenceProperty( lim, "max", 100000000 );
4938 setPreferenceProperty( lim, "step", 1000 );
4939 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4940 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4942 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4943 setPreferenceProperty( qaGroup, "columns", 2 );
4944 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4945 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4946 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4947 setPreferenceProperty( prec, "min", 0 );
4948 setPreferenceProperty( prec, "max", 100 );
4949 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4950 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4951 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4952 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4953 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4955 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
4956 setPreferenceProperty( dispgroup, "columns", 2 );
4957 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4959 modes.append( tr("MEN_WIRE") );
4960 modes.append( tr("MEN_SHADE") );
4961 modes.append( tr("MEN_NODES") );
4962 modes.append( tr("MEN_SHRINK") );
4963 QList<QVariant> indices;
4964 indices.append( 0 );
4965 indices.append( 1 );
4966 indices.append( 2 );
4967 indices.append( 3 );
4968 setPreferenceProperty( dispmode, "strings", modes );
4969 setPreferenceProperty( dispmode, "indexes", indices );
4971 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
4972 setPreferenceProperty( arcgroup, "columns", 2 );
4973 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4974 QStringList quadraticModes;
4975 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4976 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4978 indices.append( 0 );
4979 indices.append( 1 );
4980 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4981 setPreferenceProperty( quadraticmode, "indexes", indices );
4983 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4984 "SMESH", "max_angle" );
4985 setPreferenceProperty( maxAngle, "min", 1 );
4986 setPreferenceProperty( maxAngle, "max", 90 );
4990 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4991 setPreferenceProperty( exportgroup, "columns", 2 );
4992 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4993 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4995 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4996 setPreferenceProperty( computeGroup, "columns", 2 );
4997 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4999 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5000 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5001 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5003 indices.append( 0 );
5004 indices.append( 1 );
5005 indices.append( 2 );
5006 setPreferenceProperty( notifyMode, "strings", modes );
5007 setPreferenceProperty( notifyMode, "indexes", indices );
5009 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5010 setPreferenceProperty( infoGroup, "columns", 2 );
5011 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5013 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5014 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5016 indices.append( 0 );
5017 indices.append( 1 );
5018 setPreferenceProperty( elemInfo, "strings", modes );
5019 setPreferenceProperty( elemInfo, "indexes", indices );
5020 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5021 setPreferenceProperty( nodesLim, "min", 0 );
5022 setPreferenceProperty( nodesLim, "max", 10000000 );
5023 setPreferenceProperty( nodesLim, "step", 10000 );
5024 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5025 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5026 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5027 setPreferenceProperty( ctrlLim, "min", 0 );
5028 setPreferenceProperty( ctrlLim, "max", 10000000 );
5029 setPreferenceProperty( ctrlLim, "step", 1000 );
5030 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5031 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5032 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5033 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5034 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5036 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5037 setPreferenceProperty( segGroup, "columns", 2 );
5038 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5039 "SMESH", "segmentation" );
5040 setPreferenceProperty( segLen, "min", 1 );
5041 setPreferenceProperty( segLen, "max", 10000000 );
5042 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5043 "SMESH", "nb_segments_per_edge" );
5044 setPreferenceProperty( nbSeg, "min", 1 );
5045 setPreferenceProperty( nbSeg, "max", 10000000 );
5047 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5048 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5049 "SMESH", "forget_mesh_on_hyp_modif" );
5052 // Quantities with individual precision settings
5053 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5054 setPreferenceProperty( precGroup, "columns", 2 );
5056 const int nbQuantities = 6;
5057 int precs[nbQuantities], ii = 0;
5058 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5059 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5060 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5061 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5062 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5063 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5064 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5065 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5066 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5067 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5068 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5069 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5071 // Set property for precision value for spinboxes
5072 for ( ii = 0; ii < nbQuantities; ii++ ){
5073 setPreferenceProperty( precs[ii], "min", -14 );
5074 setPreferenceProperty( precs[ii], "max", 14 );
5075 setPreferenceProperty( precs[ii], "precision", 2 );
5078 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5079 setPreferenceProperty( previewGroup, "columns", 2 );
5080 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5081 setPreferenceProperty( chunkSize, "min", 1 );
5082 setPreferenceProperty( chunkSize, "max", 1000 );
5083 setPreferenceProperty( chunkSize, "step", 50 );
5085 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5086 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5088 // Mesh tab ------------------------------------------------------------------------
5089 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5090 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5091 setPreferenceProperty( nodeGroup, "columns", 3 );
5093 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5095 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5097 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5098 QList<QVariant> aMarkerTypeIndicesList;
5099 QList<QVariant> aMarkerTypeIconsList;
5100 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5101 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5102 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5103 aMarkerTypeIndicesList << i;
5104 aMarkerTypeIconsList << pixmap;
5106 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5107 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5109 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5111 QList<QVariant> aMarkerScaleIndicesList;
5112 QStringList aMarkerScaleValuesList;
5113 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5114 aMarkerScaleIndicesList << i;
5115 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5117 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5118 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5120 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5121 //setPreferenceProperty( elemGroup, "columns", 2 );
5123 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5124 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5125 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5126 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5127 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5128 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5129 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5130 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5131 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5134 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5135 setPreferenceProperty( grpGroup, "columns", 2 );
5137 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5138 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5140 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5141 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5142 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5143 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5144 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5145 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5146 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5147 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5148 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5149 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5150 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5151 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5152 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5153 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5155 setPreferenceProperty( size0d, "min", 1 );
5156 setPreferenceProperty( size0d, "max", 10 );
5158 // setPreferenceProperty( ballSize, "min", 1 );
5159 // setPreferenceProperty( ballSize, "max", 10 );
5161 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5162 setPreferenceProperty( ballDiameter, "max", 1e9 );
5163 setPreferenceProperty( ballDiameter, "step", 0.1 );
5165 setPreferenceProperty( ballScale, "min", 1e-2 );
5166 setPreferenceProperty( ballScale, "max", 1e7 );
5167 setPreferenceProperty( ballScale, "step", 0.5 );
5169 setPreferenceProperty( elemW, "min", 1 );
5170 setPreferenceProperty( elemW, "max", 5 );
5172 setPreferenceProperty( outW, "min", 1 );
5173 setPreferenceProperty( outW, "max", 5 );
5175 setPreferenceProperty( shrink, "min", 0 );
5176 setPreferenceProperty( shrink, "max", 100 );
5178 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5179 setPreferenceProperty( numGroup, "columns", 2 );
5181 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5182 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5184 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5185 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5187 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5188 setPreferenceProperty( orientGroup, "columns", 1 );
5190 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5191 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5193 setPreferenceProperty( orientScale, "min", 0.05 );
5194 setPreferenceProperty( orientScale, "max", 0.5 );
5195 setPreferenceProperty( orientScale, "step", 0.05 );
5197 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5199 // Selection tab ------------------------------------------------------------------------
5200 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5202 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5203 setPreferenceProperty( selGroup, "columns", 2 );
5205 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5206 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5208 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5209 setPreferenceProperty( preGroup, "columns", 2 );
5211 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5213 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5214 setPreferenceProperty( precSelGroup, "columns", 2 );
5216 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5217 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5218 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5220 // Scalar Bar tab ------------------------------------------------------------------------
5221 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5222 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5223 setPreferenceProperty( fontGr, "columns", 2 );
5225 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5226 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5228 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5229 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5231 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5232 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5234 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5235 setPreferenceProperty( numcol, "min", 2 );
5236 setPreferenceProperty( numcol, "max", 256 );
5238 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5239 setPreferenceProperty( numlab, "min", 2 );
5240 setPreferenceProperty( numlab, "max", 65 );
5242 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5243 setPreferenceProperty( orientGr, "columns", 2 );
5244 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5245 QStringList orients;
5246 orients.append( tr( "SMESH_VERTICAL" ) );
5247 orients.append( tr( "SMESH_HORIZONTAL" ) );
5248 indices.clear(); indices.append( 0 ); indices.append( 1 );
5249 setPreferenceProperty( orient, "strings", orients );
5250 setPreferenceProperty( orient, "indexes", indices );
5252 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5253 setPreferenceProperty( posVSizeGr, "columns", 2 );
5254 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5255 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5256 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5257 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5258 setPreferenceProperty( xv, "step", 0.1 );
5259 setPreferenceProperty( xv, "min", 0.0 );
5260 setPreferenceProperty( xv, "max", 1.0 );
5261 setPreferenceProperty( yv, "step", 0.1 );
5262 setPreferenceProperty( yv, "min", 0.0 );
5263 setPreferenceProperty( yv, "max", 1.0 );
5264 setPreferenceProperty( wv, "step", 0.1 );
5265 setPreferenceProperty( wv, "min", 0.0 );
5266 setPreferenceProperty( wv, "max", 1.0 );
5267 setPreferenceProperty( hv, "min", 0.0 );
5268 setPreferenceProperty( hv, "max", 1.0 );
5269 setPreferenceProperty( hv, "step", 0.1 );
5271 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5272 setPreferenceProperty( posHSizeGr, "columns", 2 );
5273 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5274 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5275 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5276 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5277 setPreferenceProperty( xv, "min", 0.0 );
5278 setPreferenceProperty( xv, "max", 1.0 );
5279 setPreferenceProperty( xv, "step", 0.1 );
5280 setPreferenceProperty( xh, "min", 0.0 );
5281 setPreferenceProperty( xh, "max", 1.0 );
5282 setPreferenceProperty( xh, "step", 0.1 );
5283 setPreferenceProperty( yh, "min", 0.0 );
5284 setPreferenceProperty( yh, "max", 1.0 );
5285 setPreferenceProperty( yh, "step", 0.1 );
5286 setPreferenceProperty( wh, "min", 0.0 );
5287 setPreferenceProperty( wh, "max", 1.0 );
5288 setPreferenceProperty( wh, "step", 0.1 );
5289 setPreferenceProperty( hh, "min", 0.0 );
5290 setPreferenceProperty( hh, "max", 1.0 );
5291 setPreferenceProperty( hh, "step", 0.1 );
5293 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5294 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5295 setPreferenceProperty( distributionGr, "columns", 3 );
5297 types.append( tr( "SMESH_MONOCOLOR" ) );
5298 types.append( tr( "SMESH_MULTICOLOR" ) );
5299 indices.clear(); indices.append( 0 ); indices.append( 1 );
5300 setPreferenceProperty( coloringType, "strings", types );
5301 setPreferenceProperty( coloringType, "indexes", indices );
5302 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5306 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5308 if( sect=="SMESH" ) {
5309 float sbX1,sbY1,sbW,sbH;
5310 float aTol = 1.00000009999999;
5311 std::string aWarning;
5312 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5313 if( name=="selection_object_color" || name=="selection_element_color" ||
5314 name=="highlight_color" ||
5315 name=="selection_precision_node" || name=="selection_precision_element" ||
5316 name=="selection_precision_object")
5317 SMESH::UpdateSelectionProp( this );
5318 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5319 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5320 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5321 if(sbX1+sbW > aTol){
5322 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5325 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5326 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5329 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5330 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5331 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5332 if(sbY1+sbH > aTol){
5333 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5334 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5335 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5338 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5339 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5340 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5341 if(sbX1+sbW > aTol){
5342 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5345 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5346 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5349 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5350 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5351 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5352 if(sbY1+sbH > aTol){
5353 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5356 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5357 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5360 else if ( name == "segmentation" ) {
5361 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5362 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5364 else if ( name == "nb_segments_per_edge" ) {
5365 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5366 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5368 else if ( name == "historical_python_dump" ||
5369 name == "forget_mesh_on_hyp_modif") {
5370 QString val = aResourceMgr->stringValue( "SMESH", name );
5371 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5373 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5374 SMESH::UpdateFontProp( this );
5376 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5377 SMESH::UpdateFontProp( this );
5380 if(aWarning.size() != 0){
5381 aWarning += "The default values are applied instead.";
5382 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5383 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5384 QObject::tr(aWarning.c_str()));
5389 //================================================================================
5391 * \brief Update something in accordance with update flags
5392 * \param theFlags - update flags
5394 * Update viewer or/and object browser etc. in accordance with update flags ( see
5395 * LightApp_UpdateFlags enumeration ).
5397 //================================================================================
5398 void SMESHGUI::update( const int flags )
5400 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5401 SMESH::UpdateView();
5403 SalomeApp_Module::update( flags );
5406 //================================================================================
5408 * \brief Set default selection mode
5410 * SLOT called when operation commited. Sets default selection mode
5412 //================================================================================
5413 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5415 SVTK_ViewWindow* vtkWnd =
5416 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5418 vtkWnd->SetSelectionMode( ActorSelection );
5421 //================================================================================
5423 * \brief Set default selection mode
5425 * SLOT called when operation aborted. Sets default selection mode
5427 //================================================================================
5428 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5430 SVTK_ViewWindow* vtkWnd =
5431 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5433 vtkWnd->SetSelectionMode( ActorSelection );
5436 //================================================================================
5438 * \brief Creates operation with given identifier
5439 * \param id - identifier of operation to be started
5440 * \return Pointer on created operation or NULL if operation is not created
5442 * Virtual method redefined from the base class creates operation with given id.
5443 * It is called called automatically from startOperation method of base class.
5445 //================================================================================
5446 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5448 LightApp_Operation* op = 0;
5449 // to do : create operation here
5452 case SMESHOp::OpSplitBiQuadratic:
5453 op = new SMESHGUI_SplitBiQuadOp();
5455 case SMESHOp::OpConvertMeshToQuadratic:
5456 op = new SMESHGUI_ConvToQuadOp();
5458 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5459 op = new SMESHGUI_Make2DFrom3DOp();
5461 case SMESHOp::OpReorientFaces:
5462 op = new SMESHGUI_ReorientFacesOp();
5464 case SMESHOp::OpCreateMesh:
5465 op = new SMESHGUI_MeshOp( true, true );
5467 case SMESHOp::OpCreateSubMesh:
5468 op = new SMESHGUI_MeshOp( true, false );
5470 case SMESHOp::OpEditMeshOrSubMesh:
5471 op = new SMESHGUI_MeshOp( false );
5473 case SMESHOp::OpCompute:
5474 op = new SMESHGUI_ComputeOp();
5476 case SMESHOp::OpPreCompute:
5477 op = new SMESHGUI_PrecomputeOp();
5479 case SMESHOp::OpEvaluate:
5480 op = new SMESHGUI_EvaluateOp();
5482 case SMESHOp::OpMeshOrder:
5483 op = new SMESHGUI_MeshOrderOp();
5485 case SMESHOp::OpCreateGeometryGroup:
5486 op = new SMESHGUI_GroupOnShapeOp();
5488 case SMESHOp::OpFindElementByPoint:
5489 op = new SMESHGUI_FindElemByPointOp();
5491 case SMESHOp::OpMoveNode: // Make mesh pass through point
5492 op = new SMESHGUI_MakeNodeAtPointOp();
5494 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5495 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5502 op = SalomeApp_Module::createOperation( id );
5506 //================================================================================
5508 * \brief Stops current operations and starts a given one
5509 * \param id - The id of the operation to start
5511 //================================================================================
5513 void SMESHGUI::switchToOperation(int id)
5515 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5516 activeStudy()->abortAllOperations();
5517 startOperation( id );
5520 LightApp_Displayer* SMESHGUI::displayer()
5523 myDisplayer = new SMESHGUI_Displayer( getApp() );
5527 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5530 int aTolerance = 64;
5531 int anIterations = 0;
5537 if( anIterations % aPeriod == 0 )
5540 if( aTolerance < 1 )
5544 aHue = (int)( 360.0 * rand() / RAND_MAX );
5547 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5548 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5549 for( ; it != itEnd; ++it )
5551 SALOMEDS::Color anAutoColor = *it;
5552 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5555 aQColor.getHsv( &h, &s, &v );
5556 if( abs( h - aHue ) < aTolerance )
5568 aColor.setHsv( aHue, 255, 255 );
5570 SALOMEDS::Color aSColor;
5571 aSColor.R = aColor.redF();
5572 aSColor.G = aColor.greenF();
5573 aSColor.B = aColor.blueF();
5578 const char* gSeparator = "_"; // character used to separate parameter names
5579 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5580 const char* gPathSep = "|"; // character used to separate paths
5583 * \brief Store visual parameters
5585 * This method is called just before the study document is saved.
5586 * Store visual parameters in AttributeParameter attribue(s)
5588 void SMESHGUI::storeVisualParameters (int savePoint)
5591 Kernel_Utils::Localizer loc;
5593 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5594 if (!appStudy || !appStudy->studyDS())
5596 _PTR(Study) studyDS = appStudy->studyDS();
5598 // componentName is used for encoding of entries when storing them in IParameters
5599 std::string componentName = myComponentSMESH->ComponentDataType();
5600 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5601 //if (!aSComponent) return;
5604 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5605 componentName.c_str(),
5607 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5609 // store map of custom markers
5610 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5611 if( !aMarkerMap.empty() )
5613 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5614 for( ; anIter != aMarkerMap.end(); anIter++ )
5616 int anId = anIter->first;
5617 VTK::MarkerData aMarkerData = anIter->second;
5618 std::string aMarkerFileName = aMarkerData.first;
5619 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5620 if( aMarkerTexture.size() < 3 )
5621 continue; // should contain at least width, height and the first value
5623 QString aPropertyName( "texture" );
5624 aPropertyName += gSeparator;
5625 aPropertyName += QString::number( anId );
5627 QString aPropertyValue = aMarkerFileName.c_str();
5628 aPropertyValue += gPathSep;
5630 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5631 ushort aWidth = *aTextureIter++;
5632 ushort aHeight = *aTextureIter++;
5633 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5634 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5635 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5636 aPropertyValue += QString::number( *aTextureIter );
5638 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5642 // viewers counters are used for storing view_numbers in IParameters
5645 // main cycle to store parameters of displayed objects
5646 QList<SUIT_ViewManager*> lst;
5647 QList<SUIT_ViewManager*>::Iterator it;
5648 getApp()->viewManagers(lst);
5649 for (it = lst.begin(); it != lst.end(); it++)
5651 SUIT_ViewManager* vman = *it;
5652 QString vType = vman->getType();
5654 // saving VTK actors properties
5655 if (vType == SVTK_Viewer::Type())
5657 // store the clipping planes attached to the view manager
5658 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5659 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5660 if( anIter != myClippingPlaneInfoMap.end() )
5661 aClippingPlaneInfoList = anIter->second;
5663 if( !aClippingPlaneInfoList.empty() ) {
5664 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5665 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5667 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5668 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5670 QString aPropertyName( "ClippingPlane" );
5671 aPropertyName += gSeparator;
5672 aPropertyName += QString::number( vtkViewers );
5673 aPropertyName += gSeparator;
5674 aPropertyName += QString::number( anId );
5676 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5677 aPropertyValue += gDigitsSep;
5678 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5679 aPropertyValue += gDigitsSep;
5680 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5681 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5682 aPropertyValue += gDigitsSep;
5683 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5684 aPropertyValue += gDigitsSep;
5685 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5686 aPropertyValue += gDigitsSep;
5687 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5688 aPropertyValue += gDigitsSep;
5689 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5690 aPropertyValue += gDigitsSep;
5691 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5692 aPropertyValue += gDigitsSep;
5693 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5695 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5696 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5697 aPropertyValue += gDigitsSep;
5698 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5699 aPropertyValue += gDigitsSep;
5700 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5701 aPropertyValue += gDigitsSep;
5702 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5705 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5709 QVector<SUIT_ViewWindow*> views = vman->getViews();
5710 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5712 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5714 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5715 vtkActorCollection* allActors = aCopy.GetActors();
5716 allActors->InitTraversal();
5717 while (vtkActor* actor = allActors->GetNextActor())
5719 if (actor->GetVisibility()) // store only visible actors
5721 SMESH_Actor* aSmeshActor = 0;
5722 if (actor->IsA("SMESH_Actor"))
5723 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5724 if (aSmeshActor && aSmeshActor->hasIO())
5726 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5729 // entry is "encoded" = it does NOT contain component adress,
5730 // since it is a subject to change on next component loading
5731 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5733 std::string param, vtkParam = vType.toLatin1().data();
5734 vtkParam += gSeparator;
5735 vtkParam += QString::number(vtkViewers).toLatin1().data();
5736 vtkParam += gSeparator;
5739 param = vtkParam + "Visibility";
5740 ip->setParameter(entry, param, "On");
5743 param = vtkParam + "Representation";
5744 ip->setParameter(entry, param, QString::number
5745 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5748 param = vtkParam + "IsShrunk";
5749 ip->setParameter(entry, param, QString::number
5750 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5752 // Displayed entities
5753 unsigned int aMode = aSmeshActor->GetEntityMode();
5754 bool isE = aMode & SMESH_Actor::eEdges;
5755 bool isF = aMode & SMESH_Actor::eFaces;
5756 bool isV = aMode & SMESH_Actor::eVolumes;
5757 bool is0d = aMode & SMESH_Actor::e0DElements;
5758 bool isB = aMode & SMESH_Actor::eBallElem;
5760 QString modeStr ("e");
5761 modeStr += gDigitsSep; modeStr += QString::number(isE);
5762 modeStr += gDigitsSep; modeStr += "f";
5763 modeStr += gDigitsSep; modeStr += QString::number(isF);
5764 modeStr += gDigitsSep; modeStr += "v";
5765 modeStr += gDigitsSep; modeStr += QString::number(isV);
5766 modeStr += gDigitsSep; modeStr += "0d";
5767 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5768 modeStr += gDigitsSep; modeStr += "b";
5769 modeStr += gDigitsSep; modeStr += QString::number(isB);
5771 param = vtkParam + "Entities";
5772 ip->setParameter(entry, param, modeStr.toLatin1().data());
5778 aSmeshActor->GetSufaceColor(r, g, b, delta);
5779 QStringList colorStr;
5780 colorStr << "surface";
5781 colorStr << QString::number(r);
5782 colorStr << QString::number(g);
5783 colorStr << QString::number(b);
5785 colorStr << "backsurface";
5786 colorStr << QString::number(delta);
5788 aSmeshActor->GetVolumeColor(r, g, b, delta);
5789 colorStr << "volume";
5790 colorStr << QString::number(r);
5791 colorStr << QString::number(g);
5792 colorStr << QString::number(b);
5793 colorStr << QString::number(delta);
5795 aSmeshActor->GetEdgeColor(r, g, b);
5797 colorStr << QString::number(r);
5798 colorStr << QString::number(g);
5799 colorStr << QString::number(b);
5801 aSmeshActor->GetNodeColor(r, g, b);
5803 colorStr << QString::number(r);
5804 colorStr << QString::number(g);
5805 colorStr << QString::number(b);
5807 aSmeshActor->GetOutlineColor(r, g, b);
5808 colorStr << "outline";
5809 colorStr << QString::number(r);
5810 colorStr << QString::number(g);
5811 colorStr << QString::number(b);
5813 aSmeshActor->Get0DColor(r, g, b);
5814 colorStr << "elem0d";
5815 colorStr << QString::number(r);
5816 colorStr << QString::number(g);
5817 colorStr << QString::number(b);
5819 aSmeshActor->GetBallColor(r, g, b);
5821 colorStr << QString::number(r);
5822 colorStr << QString::number(g);
5823 colorStr << QString::number(b);
5825 aSmeshActor->GetFacesOrientationColor(r, g, b);
5826 colorStr << "orientation";
5827 colorStr << QString::number(r);
5828 colorStr << QString::number(g);
5829 colorStr << QString::number(b);
5831 param = vtkParam + "Colors";
5832 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5835 QStringList sizeStr;
5837 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5838 sizeStr << "outline";
5839 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5840 sizeStr << "elem0d";
5841 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5843 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5844 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5845 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5846 sizeStr << "shrink";
5847 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5848 sizeStr << "orientation";
5849 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5850 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5852 param = vtkParam + "Sizes";
5853 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5858 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5859 if( aMarkerType == VTK::MT_USER ) {
5860 markerStr += "custom";
5861 markerStr += gDigitsSep;
5862 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5866 markerStr += gDigitsSep;
5867 markerStr += QString::number( (int)aMarkerType );
5868 markerStr += gDigitsSep;
5869 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5872 param = vtkParam + "PointMarker";
5873 ip->setParameter(entry, param, markerStr.toLatin1().data());
5876 param = vtkParam + "Opacity";
5877 ip->setParameter(entry, param,
5878 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5881 param = vtkParam + "ClippingPlane";
5883 if( !aClippingPlaneInfoList.empty() ) {
5884 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5885 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5887 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5888 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5889 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5890 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5891 if( aSmeshActor == *anIter2 ) {
5892 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5893 QString::number( anId ).toLatin1().constData() );
5900 ip->setParameter( entry, param, "Off" );
5901 } // if (io->hasEntry())
5902 } // SMESH_Actor && hasIO
5904 } // while.. actors traversal
5908 } // if (SVTK view model)
5909 } // for (viewManagers)
5912 // data structures for clipping planes processing
5916 bool isOpenGLClipping;
5917 vtkIdType RelativeOrientation;
5920 int AbsoluteOrientation;
5921 double X, Y, Z, Dx, Dy, Dz;
5923 typedef std::list<TPlaneData> TPlaneDataList;
5924 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5926 typedef std::list<vtkActor*> TActorList;
5929 TActorList ActorList;
5930 SUIT_ViewManager* ViewManager;
5932 typedef std::list<TPlaneInfo> TPlaneInfoList;
5933 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5936 * \brief Restore visual parameters
5938 * This method is called after the study document is opened.
5939 * Restore visual parameters from AttributeParameter attribue(s)
5941 void SMESHGUI::restoreVisualParameters (int savePoint)
5944 Kernel_Utils::Localizer loc;
5946 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5947 if (!appStudy || !appStudy->studyDS())
5949 _PTR(Study) studyDS = appStudy->studyDS();
5951 // componentName is used for encoding of entries when storing them in IParameters
5952 std::string componentName = myComponentSMESH->ComponentDataType();
5953 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5954 //if (!aSComponent) return;
5957 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5958 componentName.c_str(),
5960 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5962 // restore map of custom markers and map of clipping planes
5963 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5964 TPlaneDataMap aPlaneDataMap;
5966 std::vector<std::string> properties = ip->getProperties();
5967 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5969 std::string property = *propIt;
5970 QString aPropertyName( property.c_str() );
5971 QString aPropertyValue( ip->getProperty( property ).c_str() );
5973 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5974 if( aPropertyNameList.isEmpty() )
5977 QString aPropertyType = aPropertyNameList[0];
5978 if( aPropertyType == "texture" )
5980 if( aPropertyNameList.size() != 2 )
5984 int anId = aPropertyNameList[1].toInt( &ok );
5985 if( !ok || anId < 1 )
5988 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5989 if( aPropertyValueList.size() != 2 )
5992 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5993 QString aMarkerTextureString = aPropertyValueList[1];
5994 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5995 if( aMarkerTextureStringList.size() != 3 )
5999 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6004 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6008 VTK::MarkerTexture aMarkerTexture;
6009 aMarkerTexture.push_back( aWidth );
6010 aMarkerTexture.push_back( aHeight );
6012 QString aMarkerTextureData = aMarkerTextureStringList[2];
6013 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6015 QChar aChar = aMarkerTextureData.at( i );
6016 if( aChar.isDigit() )
6017 aMarkerTexture.push_back( aChar.digitValue() );
6020 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6022 else if( aPropertyType == "ClippingPlane" )
6024 if( aPropertyNameList.size() != 3 )
6028 int aViewId = aPropertyNameList[1].toInt( &ok );
6029 if( !ok || aViewId < 0 )
6033 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6034 if( !ok || aClippingPlaneId < 0 )
6037 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6038 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6041 TPlaneData aPlaneData;
6042 aPlaneData.Id = aClippingPlaneId;
6045 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6050 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6054 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6057 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6062 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6067 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6072 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6077 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6082 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6087 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6091 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6093 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6098 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6103 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6108 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6113 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6114 aPlaneDataList.push_back( aPlaneData );
6118 TPlaneInfoMap aPlaneInfoMap;
6120 std::vector<std::string> entries = ip->getEntries();
6122 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6124 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6125 QString entry (ip->decodeEntry(*entIt).c_str());
6127 // Check that the entry corresponds to a real object in the Study
6128 // as the object may be deleted or modified after the visual state is saved.
6129 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6130 if (!so) continue; //Skip the not existent entry
6132 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6133 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6135 std::vector<std::string>::iterator namesIt = paramNames.begin();
6136 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6138 // actors are stored in a map after displaying of them for
6139 // quicker access in the future: map < viewID to actor >
6140 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6142 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6144 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6145 // '_' is used as separator and should not be used in viewer type or parameter names.
6146 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6147 if (lst.size() != 3)
6150 QString viewerTypStr = lst[0];
6151 QString viewIndexStr = lst[1];
6152 QString paramNameStr = lst[2];
6155 int viewIndex = viewIndexStr.toUInt(&ok);
6156 if (!ok) // bad conversion of view index to integer
6160 if (viewerTypStr == SVTK_Viewer::Type())
6162 SMESH_Actor* aSmeshActor = 0;
6163 if (vtkActors.IsBound(viewIndex))
6164 aSmeshActor = vtkActors.Find(viewIndex);
6166 QList<SUIT_ViewManager*> lst;
6167 getApp()->viewManagers(viewerTypStr, lst);
6169 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6170 SUIT_ViewManager* vman = NULL;
6171 if (viewIndex >= 0 && viewIndex < lst.count())
6172 vman = lst.at(viewIndex);
6174 if (paramNameStr == "Visibility")
6176 if (!aSmeshActor && displayer() && vman)
6178 SUIT_ViewModel* vmodel = vman->getViewModel();
6179 // SVTK view model can be casted to SALOME_View
6180 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6182 // store displayed actor in a temporary map for quicker
6183 // access later when restoring other parameters
6184 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6185 vtkRenderer* Renderer = vtkView->getRenderer();
6186 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6187 vtkActorCollection* theActors = aCopy.GetActors();
6188 theActors->InitTraversal();
6189 bool isFound = false;
6190 vtkActor *ac = theActors->GetNextActor();
6191 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6192 if (ac->IsA("SMESH_Actor")) {
6193 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6194 if (aGeomAc->hasIO()) {
6195 Handle(SALOME_InteractiveObject) io =
6196 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6197 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6199 vtkActors.Bind(viewIndex, aGeomAc);
6205 } // if (paramNameStr == "Visibility")
6208 // the rest properties "work" with SMESH_Actor
6211 QString val ((*valuesIt).c_str());
6214 if (paramNameStr == "Representation") {
6215 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6218 else if (paramNameStr == "IsShrunk") {
6220 if (!aSmeshActor->IsShrunk())
6221 aSmeshActor->SetShrink();
6224 if (aSmeshActor->IsShrunk())
6225 aSmeshActor->UnShrink();
6228 // Displayed entities
6229 else if (paramNameStr == "Entities") {
6230 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6231 int aEntityMode = SMESH_Actor::eAllEntity;
6232 for ( int i = 0; i < mode.count(); i+=2 ) {
6233 if ( i < mode.count()-1 ) {
6234 QString type = mode[i];
6235 bool val = mode[i+1].toInt();
6236 if ( type == "e" && !val )
6237 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6238 else if ( type == "f" && !val )
6239 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6240 else if ( type == "v" && !val )
6241 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6242 else if ( type == "0d" && !val )
6243 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6244 else if ( type == "b" && !val )
6245 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6248 aSmeshActor->SetEntityMode( aEntityMode );
6251 else if (paramNameStr == "Colors") {
6252 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6259 QColor outlineColor;
6260 QColor orientationColor;
6266 // below lines are required to get default values for delta coefficients
6267 // of backface color for faces and color of reversed volumes
6268 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6269 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6270 for ( int i = 0; i < colors.count(); i++ ) {
6271 QString type = colors[i];
6272 if ( type == "surface" ) {
6273 // face color is set by 3 values r:g:b, where
6274 // - r,g,b - is rgb color components
6275 if ( i+1 >= colors.count() ) break; // format error
6276 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6277 if ( i+2 >= colors.count() ) break; // format error
6278 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6279 if ( i+3 >= colors.count() ) break; // format error
6280 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6281 faceColor.setRgbF( r, g, b );
6284 else if ( type == "backsurface" ) {
6285 // backface color can be defined in several ways
6286 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6287 // - in latest versions, it is set as delta coefficient
6288 bool rgbOk = false, deltaOk;
6289 if ( i+1 >= colors.count() ) break; // format error
6290 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6291 int delta = colors[i+1].toInt( &deltaOk );
6293 if ( i+1 < colors.count() ) // index is shifted to 1
6294 g = colors[i+1].toDouble( &rgbOk );
6295 if ( rgbOk ) i++; // shift index
6296 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6297 b = colors[i+1].toDouble( &rgbOk );
6299 // - as currently there's no way to set directly backsurface color as it was before,
6300 // we ignore old dump where r,g,b triple was set
6301 // - also we check that delta parameter is set properly
6302 if ( !rgbOk && deltaOk )
6305 else if ( type == "volume" ) {
6306 // volume color is set by 4 values r:g:b:delta, where
6307 // - r,g,b - is a normal volume rgb color components
6308 // - delta - is a reversed volume color delta coefficient
6309 if ( i+1 >= colors.count() ) break; // format error
6310 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6311 if ( i+2 >= colors.count() ) break; // format error
6312 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6313 if ( i+3 >= colors.count() ) break; // format error
6314 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6315 if ( i+4 >= colors.count() ) break; // format error
6316 int delta = colors[i+4].toInt( &bOk );
6317 if ( !bOk ) break; // format error
6318 volumeColor.setRgbF( r, g, b );
6322 else if ( type == "edge" ) {
6323 // edge color is set by 3 values r:g:b, where
6324 // - r,g,b - is rgb color components
6325 if ( i+1 >= colors.count() ) break; // format error
6326 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6327 if ( i+2 >= colors.count() ) break; // format error
6328 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6329 if ( i+3 >= colors.count() ) break; // format error
6330 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6331 edgeColor.setRgbF( r, g, b );
6334 else if ( type == "node" ) {
6335 // node color is set by 3 values r:g:b, where
6336 // - r,g,b - is rgb color components
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 nodeColor.setRgbF( r, g, b );
6346 else if ( type == "elem0d" ) {
6347 // 0d element color is set by 3 values r:g:b, where
6348 // - r,g,b - is rgb color components
6349 if ( i+1 >= colors.count() ) break; // format error
6350 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6351 if ( i+2 >= colors.count() ) break; // format error
6352 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6353 if ( i+3 >= colors.count() ) break; // format error
6354 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6355 elem0dColor.setRgbF( r, g, b );
6358 else if ( type == "ball" ) {
6359 // ball color is set by 3 values r:g:b, where
6360 // - r,g,b - is rgb color components
6361 if ( i+1 >= colors.count() ) break; // format error
6362 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6363 if ( i+2 >= colors.count() ) break; // format error
6364 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6365 if ( i+3 >= colors.count() ) break; // format error
6366 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6367 ballColor.setRgbF( r, g, b );
6370 else if ( type == "outline" ) {
6371 // outline color is set by 3 values r:g:b, where
6372 // - r,g,b - is rgb color components
6373 if ( i+1 >= colors.count() ) break; // format error
6374 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6375 if ( i+2 >= colors.count() ) break; // format error
6376 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6377 if ( i+3 >= colors.count() ) break; // format error
6378 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6379 outlineColor.setRgbF( r, g, b );
6382 else if ( type == "orientation" ) {
6383 // orientation color is set by 3 values r:g:b, where
6384 // - r,g,b - is rgb color components
6385 if ( i+1 >= colors.count() ) break; // format error
6386 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6387 if ( i+2 >= colors.count() ) break; // format error
6388 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6389 if ( i+3 >= colors.count() ) break; // format error
6390 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6391 orientationColor.setRgbF( r, g, b );
6396 if ( nodeColor.isValid() )
6397 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6399 if ( edgeColor.isValid() )
6400 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6402 if ( faceColor.isValid() )
6403 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6405 if ( volumeColor.isValid() )
6406 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6407 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6408 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6410 if ( elem0dColor.isValid() )
6411 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6413 if ( ballColor.isValid() )
6414 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6416 if ( outlineColor.isValid() )
6417 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6418 // orientation color
6419 if ( orientationColor.isValid() )
6420 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6423 else if (paramNameStr == "Sizes") {
6424 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6427 int outlineWidth = -1;
6428 int elem0dSize = -1;
6429 //int ballSize = -1;
6430 double ballDiameter = -1.0;
6431 double ballScale = -1.0;
6432 double shrinkSize = -1;
6433 double orientationSize = -1;
6434 bool orientation3d = false;
6435 for ( int i = 0; i < sizes.count(); i++ ) {
6436 QString type = sizes[i];
6437 if ( type == "line" ) {
6438 // line (wireframe) width is given as single integer value
6439 if ( i+1 >= sizes.count() ) break; // format error
6440 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6444 if ( type == "outline" ) {
6445 // outline width is given as single integer value
6446 if ( i+1 >= sizes.count() ) break; // format error
6447 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6451 else if ( type == "elem0d" ) {
6452 // 0d element size is given as single integer value
6453 if ( i+1 >= sizes.count() ) break; // format error
6454 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6458 else if ( type == "ball" ) {
6459 // balls are specified by two values: size:scale, where
6460 // - size - is a integer value specifying size
6461 // - scale - is a double value specifying scale factor
6462 if ( i+1 >= sizes.count() ) break; // format error
6463 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6464 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6465 if ( i+2 >= sizes.count() ) break; // format error
6466 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6472 else if ( type == "shrink" ) {
6473 // shrink factor is given as single floating point value
6474 if ( i+1 >= sizes.count() ) break; // format error
6475 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6479 else if ( type == "orientation" ) {
6480 // orientation vectors are specified by two values size:3d, where
6481 // - size - is a floating point value specifying scale factor
6482 // - 3d - is a boolean
6483 if ( i+1 >= sizes.count() ) break; // format error
6484 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6485 if ( i+2 >= sizes.count() ) break; // format error
6486 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6487 orientationSize = v1;
6488 orientation3d = (bool)v2;
6492 // line (wireframe) width
6493 if ( lineWidth > 0 )
6494 aSmeshActor->SetLineWidth( lineWidth );
6496 if ( outlineWidth > 0 )
6497 aSmeshActor->SetOutlineWidth( outlineWidth );
6498 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6499 aSmeshActor->SetOutlineWidth( lineWidth );
6501 if ( elem0dSize > 0 )
6502 aSmeshActor->Set0DSize( elem0dSize );
6504 /*if ( ballSize > 0 )
6505 aSmeshActor->SetBallSize( ballSize );*/
6507 if ( ballDiameter > 0 )
6508 aSmeshActor->SetBallSize( ballDiameter );
6510 if ( ballScale > 0.0 )
6511 aSmeshActor->SetBallScale( ballScale );
6513 if ( shrinkSize > 0 )
6514 aSmeshActor->SetShrinkFactor( shrinkSize );
6515 // orientation vectors
6516 if ( orientationSize > 0 ) {
6517 aSmeshActor->SetFacesOrientationScale( orientationSize );
6518 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6522 else if (paramNameStr == "PointMarker") {
6523 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6524 if( data.count() >= 2 ) {
6526 int aParam1 = data[1].toInt( &ok );
6528 if( data[0] == "std" && data.count() == 3 ) {
6529 int aParam2 = data[2].toInt( &ok );
6530 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6532 else if( data[0] == "custom" ) {
6533 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6534 if( markerIt != aMarkerMap.end() ) {
6535 VTK::MarkerData aMarkerData = markerIt->second;
6536 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6543 else if (paramNameStr == "Opacity") {
6544 aSmeshActor->SetOpacity(val.toFloat());
6547 else if (paramNameStr.startsWith("ClippingPlane")) {
6548 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6549 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6550 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6551 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6552 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6553 // new format - val looks like "Off" or "0" (plane id)
6554 // (note: in new format "Off" value is used only for consistency,
6555 // so it is processed together with values in old format)
6556 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6557 if( anIsOldFormat ) {
6558 if (paramNameStr == "ClippingPlane1" || val == "Off")
6559 aSmeshActor->RemoveAllClippingPlanes();
6561 QList<SUIT_ViewManager*> lst;
6562 getApp()->viewManagers(viewerTypStr, lst);
6563 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6564 if (viewIndex >= 0 && viewIndex < lst.count()) {
6565 SUIT_ViewManager* vman = lst.at(viewIndex);
6566 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6568 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6570 SMESH::TActorList anActorList;
6571 anActorList.push_back( aSmeshActor );
6572 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6573 aPlane->myViewWindow = vtkView;
6574 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6575 aPlane->PlaneMode = aMode;
6576 bool isOpenGLClipping = ( bool )vals[1].toInt();
6577 aPlane->IsOpenGLClipping = isOpenGLClipping;
6578 if ( aMode == SMESH::Absolute ) {
6579 aPlane->myAbsoluteOrientation = vals[2].toInt();
6580 aPlane->X = vals[3].toFloat();
6581 aPlane->Y = vals[4].toFloat();
6582 aPlane->Z = vals[5].toFloat();
6583 aPlane->Dx = vals[6].toFloat();
6584 aPlane->Dy = vals[7].toFloat();
6585 aPlane->Dz = vals[8].toFloat();
6587 else if ( aMode == SMESH::Relative ) {
6588 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6589 aPlane->myDistance = vals[3].toFloat();
6590 aPlane->myAngle[0] = vals[4].toFloat();
6591 aPlane->myAngle[1] = vals[5].toFloat();
6595 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6596 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6597 aClippingPlaneInfo.Plane = aPlane;
6598 aClippingPlaneInfo.ActorList = anActorList;
6599 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6607 int aPlaneId = val.toInt( &ok );
6608 if( ok && aPlaneId >= 0 ) {
6609 bool anIsDefinedPlane = false;
6610 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6611 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6612 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6613 TPlaneInfo& aPlaneInfo = *anIter;
6614 if( aPlaneInfo.PlaneId == aPlaneId ) {
6615 aPlaneInfo.ActorList.push_back( aSmeshActor );
6616 anIsDefinedPlane = true;
6620 if( !anIsDefinedPlane ) {
6621 TPlaneInfo aPlaneInfo;
6622 aPlaneInfo.PlaneId = aPlaneId;
6623 aPlaneInfo.ActorList.push_back( aSmeshActor );
6624 aPlaneInfo.ViewManager = vman;
6626 // to make the list sorted by plane id
6627 anIter = aPlaneInfoList.begin();
6628 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6629 const TPlaneInfo& aPlaneInfoRef = *anIter;
6630 if( aPlaneInfoRef.PlaneId > aPlaneId )
6633 aPlaneInfoList.insert( anIter, aPlaneInfo );
6638 } // if (aSmeshActor)
6639 } // other parameters than Visibility
6641 } // for names/parameters iterator
6642 } // for entries iterator
6644 // take into account planes with empty list of actors referred to them
6645 QList<SUIT_ViewManager*> aVMList;
6646 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6648 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6649 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6650 int aViewId = aPlaneDataIter->first;
6651 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6652 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6654 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6656 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6657 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6658 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6659 const TPlaneData& aPlaneData = *anIter2;
6660 int aPlaneId = aPlaneData.Id;
6662 bool anIsFound = false;
6663 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6664 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6665 const TPlaneInfo& aPlaneInfo = *anIter3;
6666 if( aPlaneInfo.PlaneId == aPlaneId ) {
6673 TPlaneInfo aPlaneInfo; // ActorList field is empty
6674 aPlaneInfo.PlaneId = aPlaneId;
6675 aPlaneInfo.ViewManager = aViewManager;
6677 // to make the list sorted by plane id
6678 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6679 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6680 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6681 if( aPlaneInfoRef.PlaneId > aPlaneId )
6684 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6690 // add clipping planes to actors according to the restored parameters
6691 // and update the clipping plane map
6692 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6693 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6694 int aViewId = anIter1->first;
6695 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6697 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6698 if( anIter2 == aPlaneDataMap.end() )
6700 const TPlaneDataList& aPlaneDataList = anIter2->second;
6702 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6703 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6704 const TPlaneInfo& aPlaneInfo = *anIter3;
6705 int aPlaneId = aPlaneInfo.PlaneId;
6706 const TActorList& anActorList = aPlaneInfo.ActorList;
6707 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6711 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6715 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6717 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6718 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6719 const TPlaneData& aPlaneData = *anIter4;
6720 if( aPlaneData.Id == aPlaneId ) {
6721 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6722 aPlane->myViewWindow = aViewWindow;
6723 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6724 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6725 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6726 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6727 aPlane->X = aPlaneData.X;
6728 aPlane->Y = aPlaneData.Y;
6729 aPlane->Z = aPlaneData.Z;
6730 aPlane->Dx = aPlaneData.Dx;
6731 aPlane->Dy = aPlaneData.Dy;
6732 aPlane->Dz = aPlaneData.Dz;
6734 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6735 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6736 aPlane->myDistance = aPlaneData.Distance;
6737 aPlane->myAngle[0] = aPlaneData.Angle[0];
6738 aPlane->myAngle[1] = aPlaneData.Angle[1];
6741 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6742 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6743 aClippingPlaneInfo.Plane = aPlane;
6744 aClippingPlaneInfo.ActorList = anActorList;
6745 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6756 // update all VTK views
6757 QList<SUIT_ViewManager*> lst;
6758 getApp()->viewManagers(lst);
6759 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6760 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6761 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6762 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6763 // set OpenGL clipping planes
6764 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6765 vtkActorCollection* anAllActors = aCopy.GetActors();
6766 anAllActors->InitTraversal();
6767 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6768 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6769 anActor->SetOpenGLClippingPlane();
6771 vtkView->getRenderer()->ResetCameraClippingRange();
6778 \brief Adds preferences for dfont of VTK viewer
6780 \param pIf group identifier
6781 \param param parameter
6782 \return identifier of preferences
6784 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6786 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6788 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6791 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6792 fam.append( tr( "SMESH_FONT_COURIER" ) );
6793 fam.append( tr( "SMESH_FONT_TIMES" ) );
6795 setPreferenceProperty( tfont, "fonts", fam );
6797 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6798 if ( needSize ) f = f | QtxFontEdit::Size;
6799 setPreferenceProperty( tfont, "features", f );
6805 \brief Actions after hypothesis edition
6806 Updates object browser after hypothesis edition
6808 void SMESHGUI::onHypothesisEdit( int result )
6811 SMESHGUI::Modified();
6812 updateObjBrowser( true );
6816 \brief Actions after choosing menu of control modes
6817 Updates control mode actions according to current selection
6819 void SMESHGUI::onUpdateControlActions()
6821 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
6822 SALOME_ListIO selected;
6824 aSel->selectedObjects( selected );
6826 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6827 if ( selected.Extent() ) {
6828 if ( selected.First()->hasEntry() ) {
6829 aControl = SMESH::FindActorByEntry( selected.First()->getEntry() )->GetControlMode();
6830 SALOME_ListIteratorOfListIO it(selected);
6831 for ( ; it.More(); it.Next() ) {
6832 Handle(SALOME_InteractiveObject) anIO = it.Value();
6833 if ( anIO->hasEntry() ) {
6834 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6835 if ( aControl != anActor->GetControlMode() ) {
6836 aControl = SMESH_Actor::eNone;
6845 int anAction = ActionToControl( aControl, true );
6847 action( anAction )->setChecked( true );
6849 QMenu* send = (QMenu*)sender();
6850 QList<QAction*> actions = send->actions();
6851 for ( int i = 0; i < actions.size(); i++ )
6852 actions[i]->setChecked( false );
6858 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6859 \param pview view being closed
6861 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6862 #ifndef DISABLE_PLOT2DVIEWER
6863 //Crear all Plot2d Viewers if need.
6864 SMESH::ClearPlot2Viewers(pview);
6866 EmitSignalCloseView();
6869 void SMESHGUI::message( const QString& msg )
6872 QStringList data = msg.split("/");
6873 if ( data.count() > 0 ) {
6874 if ( data.first() == "mesh_loading" ) {
6876 QString entry = data.count() > 1 ? data[1] : QString();
6877 if ( entry.isEmpty() )
6880 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6882 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6885 name = SMESH::fromUtf8(obj->GetName());
6886 if ( name.isEmpty() )
6889 if ( data.last() == "stop" )
6890 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6892 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6893 QApplication::processEvents();
6899 \brief Connects or disconnects signals about activating and cloning view on the module slots
6900 \param pview view which is connected/disconnected
6902 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6906 SUIT_ViewManager* viewMgr = pview->getViewManager();
6908 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6909 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6911 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6912 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6917 \brief Return \c true if object can be renamed
6919 bool SMESHGUI::renameAllowed( const QString& entry) const {
6920 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6924 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6928 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6933 if(appStudy->isComponent(entry) || obj->isReference())
6936 // check type to prevent renaming of inappropriate objects
6937 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6938 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6939 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6940 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6941 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6942 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6949 Rename object by entry.
6950 \param entry entry of the object
6951 \param name new name of the object
6952 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6954 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6956 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6960 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6965 _PTR(Study) aStudy = appStudy->studyDS();
6970 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6972 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6977 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6978 _PTR(GenericAttribute) anAttr;
6979 _PTR(AttributeName) aName;
6981 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6983 // check type to prevent renaming of inappropriate objects
6984 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6985 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6986 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6987 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6988 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6989 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6990 if ( !name.isEmpty() ) {
6991 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6993 // update name of group object and its actor
6994 Handle(SALOME_InteractiveObject) IObject =
6995 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6997 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6998 if( !aGroupObject->_is_nil() ) {
6999 aGroupObject->SetName( qPrintable(name) );
7000 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7001 anActor->setName( qPrintable(name) );
7011 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7013 static QList<QColor> colors;
7015 if ( colors.isEmpty() ) {
7017 for (int s = 0; s < 2 ; s++)
7019 for (int v = 100; v >= 40; v = v - 20)
7021 for (int h = 0; h < 359 ; h = h + 60)
7023 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7028 static int currentColor = randomize( colors.size() );
7030 SALOMEDS::Color color;
7031 color.R = (double)colors[currentColor].red() / 255.0;
7032 color.G = (double)colors[currentColor].green() / 255.0;
7033 color.B = (double)colors[currentColor].blue() / 255.0;
7035 currentColor = (currentColor+1) % colors.count();