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)
2622 MESSAGE("anAction = SMESH::eDisplayOnly");
2623 anAction = SMESH::eDisplay;
2629 // PAL13338 + PAL15161 -->
2630 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2631 MESSAGE("anAction = SMESH::eDisplayOnly");
2632 SMESH::UpdateView();
2633 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2635 // PAL13338 + PAL15161 <--
2637 catch (...) { // PAL16774 (Crash after display of many groups)
2638 SMESH::OnVisuException();
2641 if (anAction == SMESH::eErase) {
2642 MESSAGE("anAction == SMESH::eErase");
2644 aSel->setSelectedObjects( l1 );
2647 aSel->setSelectedObjects( to_process );
2652 case SMESHOp::OpNode:
2654 if(checkLock(aStudy)) break;
2657 EmitSignalDeactivateDialog();
2659 ( new SMESHGUI_NodesDlg( this ) )->show();
2662 SUIT_MessageBox::warning(desktop(),
2663 tr("SMESH_WRN_WARNING"),
2664 tr("SMESH_WRN_VIEWER_VTK"));
2669 case SMESHOp::OpCreateMesh:
2670 case SMESHOp::OpCreateSubMesh:
2671 case SMESHOp::OpEditMeshOrSubMesh:
2672 case SMESHOp::OpCompute:
2673 case SMESHOp::OpPreCompute:
2674 case SMESHOp::OpEvaluate:
2675 case SMESHOp::OpMeshOrder:
2676 startOperation( theCommandID );
2678 case SMESHOp::OpCopyMesh:
2680 if (checkLock(aStudy)) break;
2681 EmitSignalDeactivateDialog();
2682 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2685 case SMESHOp::OpBuildCompoundMesh:
2687 if (checkLock(aStudy)) break;
2688 EmitSignalDeactivateDialog();
2689 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2693 case SMESHOp::OpDiagonalInversion:
2694 case SMESHOp::OpUnionOfTwoTriangle:
2698 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2699 tr( "NOT_A_VTK_VIEWER" ) );
2703 if ( checkLock( aStudy ) )
2706 /*Standard_Boolean aRes;
2707 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2708 if ( aMesh->_is_nil() )
2710 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2711 tr( "SMESH_BAD_SELECTION" ) );
2715 EmitSignalDeactivateDialog();
2716 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2717 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2719 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2722 case SMESHOp::OpOrientation:
2723 case SMESHOp::OpUnionOfTriangles:
2724 case SMESHOp::OpCuttingOfQuadrangles:
2725 case SMESHOp::OpSplitVolumes:
2729 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2730 tr( "NOT_A_VTK_VIEWER" ) );
2734 if ( checkLock( aStudy ) )
2737 EmitSignalDeactivateDialog();
2738 SMESHGUI_MultiEditDlg* aDlg = NULL;
2739 if ( theCommandID == SMESHOp::OpOrientation )
2740 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2741 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2742 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2743 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2744 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2746 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2751 case SMESHOp::OpSmoothing:
2753 if(checkLock(aStudy)) break;
2755 EmitSignalDeactivateDialog();
2756 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2759 SUIT_MessageBox::warning(desktop(),
2760 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2764 case SMESHOp::OpExtrusion:
2766 if (checkLock(aStudy)) break;
2768 EmitSignalDeactivateDialog();
2769 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2771 SUIT_MessageBox::warning(desktop(),
2772 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2776 case SMESHOp::OpExtrusionAlongAPath:
2778 if (checkLock(aStudy)) break;
2780 EmitSignalDeactivateDialog();
2781 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2783 SUIT_MessageBox::warning(desktop(),
2784 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2788 case SMESHOp::OpRevolution:
2790 if(checkLock(aStudy)) break;
2792 EmitSignalDeactivateDialog();
2793 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2796 SUIT_MessageBox::warning(desktop(),
2797 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2801 case SMESHOp::OpPatternMapping:
2803 if ( checkLock( aStudy ) )
2807 EmitSignalDeactivateDialog();
2808 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2811 SUIT_MessageBox::warning(desktop(),
2812 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2816 case SMESHOp::OpSplitBiQuadratic:
2817 case SMESHOp::OpConvertMeshToQuadratic:
2818 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2819 case SMESHOp::OpReorientFaces:
2820 case SMESHOp::OpCreateGeometryGroup:
2822 startOperation( theCommandID );
2825 case SMESHOp::OpCreateGroup:
2829 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2830 tr( "NOT_A_VTK_VIEWER" ) );
2834 if(checkLock(aStudy)) break;
2835 EmitSignalDeactivateDialog();
2836 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2838 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2839 SALOME_ListIO selected;
2841 aSel->selectedObjects( selected );
2843 int nbSel = selected.Extent();
2845 // check if mesh is selected
2846 aMesh = SMESH::GetMeshByIO( selected.First() );
2848 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2853 case SMESHOp::OpConstructGroup:
2857 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2858 tr( "NOT_A_VTK_VIEWER" ) );
2862 if(checkLock(aStudy)) break;
2863 EmitSignalDeactivateDialog();
2865 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2866 SALOME_ListIO selected;
2868 aSel->selectedObjects( selected );
2870 int nbSel = selected.Extent();
2872 // check if submesh is selected
2873 Handle(SALOME_InteractiveObject) IObject = selected.First();
2874 if (IObject->hasEntry()) {
2875 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2877 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2878 if (!aSubMesh->_is_nil()) {
2880 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2881 // get submesh elements list by types
2882 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2883 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2884 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2885 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2886 // create group for each type o elements
2887 QString aName = IObject->getName();
2888 QStringList anEntryList;
2889 if (aNodes->length() > 0) {
2890 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2891 aGroup->Add(aNodes.inout());
2892 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2893 anEntryList.append( aSObject->GetID().c_str() );
2895 if (aEdges->length() > 0) {
2896 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2897 aGroup->Add(aEdges.inout());
2898 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2899 anEntryList.append( aSObject->GetID().c_str() );
2901 if (aFaces->length() > 0) {
2902 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2903 aGroup->Add(aFaces.inout());
2904 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2905 anEntryList.append( aSObject->GetID().c_str() );
2907 if (aVolumes->length() > 0) {
2908 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2909 aGroup->Add(aVolumes.inout());
2910 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2911 anEntryList.append( aSObject->GetID().c_str() );
2914 anApp->browseObjects( anEntryList );
2916 catch(const SALOME::SALOME_Exception & S_ex){
2917 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2924 SUIT_MessageBox::warning(desktop(),
2925 tr("SMESH_WRN_WARNING"),
2926 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2931 case SMESHOp::OpEditGroup:
2935 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2936 tr( "NOT_A_VTK_VIEWER" ) );
2940 if(checkLock(aStudy)) break;
2941 EmitSignalDeactivateDialog();
2943 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2944 SALOME_ListIO selected;
2946 aSel->selectedObjects( selected );
2948 SALOME_ListIteratorOfListIO It (selected);
2949 int nbSelectedGroups = 0;
2950 for ( ; It.More(); It.Next() )
2952 SMESH::SMESH_GroupBase_var aGroup =
2953 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2954 if (!aGroup->_is_nil()) {
2956 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2960 if (nbSelectedGroups == 0)
2962 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2968 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
2970 if(checkLock(aStudy)) break;
2971 if (myState == 800) {
2972 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2973 if (aDlg) aDlg->onAdd();
2978 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
2980 if(checkLock(aStudy)) break;
2981 if (myState == 800) {
2982 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2983 if (aDlg) aDlg->onRemove();
2988 case SMESHOp::OpEditGeomGroupAsGroup:
2992 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2993 tr( "NOT_A_VTK_VIEWER" ) );
2997 if(checkLock(aStudy)) break;
2998 EmitSignalDeactivateDialog();
3000 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3001 SALOME_ListIO selected;
3003 aSel->selectedObjects( selected );
3005 SALOME_ListIteratorOfListIO It (selected);
3006 for ( ; It.More(); It.Next() )
3008 SMESH::SMESH_GroupOnGeom_var aGroup =
3009 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3010 if (!aGroup->_is_nil()) {
3011 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3016 SMESH::SMESH_GroupOnFilter_var aGroup =
3017 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3018 if (!aGroup->_is_nil()) {
3019 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3027 case SMESHOp::OpUnionGroups:
3028 case SMESHOp::OpIntersectGroups:
3029 case SMESHOp::OpCutGroups:
3033 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3034 tr( "NOT_A_VTK_VIEWER" ) );
3038 if ( checkLock( aStudy ) )
3041 EmitSignalDeactivateDialog();
3043 SMESHGUI_GroupOpDlg* aDlg = 0;
3044 if ( theCommandID == SMESHOp::OpUnionGroups )
3045 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3046 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3047 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3049 aDlg = new SMESHGUI_CutGroupsDlg( this );
3056 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3058 if ( checkLock( aStudy ) )
3061 EmitSignalDeactivateDialog();
3062 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3068 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3072 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3073 tr( "NOT_A_VTK_VIEWER" ) );
3077 if ( checkLock( aStudy ) )
3080 EmitSignalDeactivateDialog();
3082 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3086 case SMESHOp::OpMeshInformation:
3087 case SMESHOp::OpWhatIs:
3089 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3090 EmitSignalDeactivateDialog();
3091 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3092 SALOME_ListIO selected;
3094 aSel->selectedObjects( selected );
3096 if ( selected.Extent() > 1 ) { // a dlg for each IO
3097 SALOME_ListIteratorOfListIO It( selected );
3098 for ( ; It.More(); It.Next() ) {
3099 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3100 dlg->showInfo( It.Value() );
3105 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3111 case SMESHOp::OpFindElementByPoint:
3113 startOperation( theCommandID );
3117 case SMESHOp::OpEditHypothesis:
3119 if(checkLock(aStudy)) break;
3121 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3122 SALOME_ListIO selected;
3124 aSel->selectedObjects( selected );
3126 int nbSel = selected.Extent();
3129 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3130 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3132 if ( !aHypothesis->_is_nil() )
3134 SMESHGUI_GenericHypothesisCreator* aCreator =
3135 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3138 // set geometry of mesh and sub-mesh to aCreator
3139 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3140 if ( selected.Extent() == 1 )
3142 QString subGeomID, meshGeomID;
3143 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3144 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3146 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3147 aCreator->setShapeEntry( subGeomID );
3148 aCreator->setMainShapeEntry( meshGeomID );
3152 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3162 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3164 if(checkLock(aStudy)) break;
3165 SUIT_OverrideCursor wc;
3167 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3168 SALOME_ListIO selected;
3170 aSel->selectedObjects( selected, QString::null, false );
3172 SALOME_ListIteratorOfListIO It(selected);
3173 for (int i = 0; It.More(); It.Next(), i++) {
3174 Handle(SALOME_InteractiveObject) IObject = It.Value();
3175 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3178 aSel->setSelectedObjects( l1 );
3183 case SMESHOp::OpElem0D:
3184 case SMESHOp::OpBall:
3185 case SMESHOp::OpEdge:
3186 case SMESHOp::OpTriangle:
3187 case SMESHOp::OpQuadrangle:
3188 case SMESHOp::OpPolygon:
3189 case SMESHOp::OpTetrahedron:
3190 case SMESHOp::OpHexahedron:
3191 case SMESHOp::OpPentahedron:
3192 case SMESHOp::OpPyramid:
3193 case SMESHOp::OpHexagonalPrism:
3195 if(checkLock(aStudy)) break;
3197 EmitSignalDeactivateDialog();
3198 SMDSAbs_EntityType type = SMDSEntity_Edge;
3199 switch (theCommandID) {
3200 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3201 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3202 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3203 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3204 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3205 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3206 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3207 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3208 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3209 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3212 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3215 SUIT_MessageBox::warning(desktop(),
3216 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3220 case SMESHOp::OpPolyhedron:
3222 if(checkLock(aStudy)) break;
3224 EmitSignalDeactivateDialog();
3225 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3228 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3229 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3233 case SMESHOp::OpQuadraticEdge:
3234 case SMESHOp::OpQuadraticTriangle:
3235 case SMESHOp::OpBiQuadraticTriangle:
3236 case SMESHOp::OpQuadraticQuadrangle:
3237 case SMESHOp::OpBiQuadraticQuadrangle:
3238 case SMESHOp::OpQuadraticPolygon:
3239 case SMESHOp::OpQuadraticTetrahedron:
3240 case SMESHOp::OpQuadraticPyramid:
3241 case SMESHOp::OpQuadraticPentahedron:
3242 case SMESHOp::OpQuadraticHexahedron:
3243 case SMESHOp::OpTriQuadraticHexahedron:
3245 if(checkLock(aStudy)) break;
3247 EmitSignalDeactivateDialog();
3248 SMDSAbs_EntityType type = SMDSEntity_Last;
3250 switch (theCommandID) {
3251 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3252 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3253 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3254 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3255 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3256 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3257 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3258 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3259 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3260 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3261 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3264 if ( type != SMDSEntity_Last )
3265 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3268 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3269 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3273 case SMESHOp::OpRemoveNodes:
3275 if(checkLock(aStudy)) break;
3277 EmitSignalDeactivateDialog();
3278 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3281 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3282 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3286 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3288 if(checkLock(aStudy)) break;
3290 EmitSignalDeactivateDialog();
3291 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3295 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3296 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3300 case SMESHOp::OpClearMesh: {
3302 if(checkLock(aStudy)) break;
3304 SALOME_ListIO selected;
3305 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3306 aSel->selectedObjects( selected );
3308 SUIT_OverrideCursor wc;
3309 SALOME_ListIteratorOfListIO It (selected);
3310 for ( ; It.More(); It.Next() )
3312 Handle(SALOME_InteractiveObject) IOS = It.Value();
3313 SMESH::SMESH_Mesh_var aMesh =
3314 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3315 if ( aMesh->_is_nil()) continue;
3317 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3319 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3320 SMESH::ModifiedMesh( aMeshSObj, false, true);
3321 // hide groups and submeshes
3322 _PTR(ChildIterator) anIter =
3323 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3324 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3326 _PTR(SObject) so = anIter->Value();
3327 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3330 catch (const SALOME::SALOME_Exception& S_ex){
3332 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3336 SMESH::UpdateView();
3340 case SMESHOp::OpRemoveOrphanNodes:
3342 if(checkLock(aStudy)) break;
3343 SALOME_ListIO selected;
3344 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3345 aSel->selectedObjects( selected );
3346 if ( selected.Extent() == 1 ) {
3347 Handle(SALOME_InteractiveObject) anIO = selected.First();
3348 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3349 if ( !aMesh->_is_nil() ) {
3350 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3351 tr( "SMESH_WARNING" ),
3352 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3353 SUIT_MessageBox::Yes |
3354 SUIT_MessageBox::No,
3355 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3358 SUIT_OverrideCursor wc;
3359 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3360 int removed = aMeshEditor->RemoveOrphanNodes();
3361 SUIT_MessageBox::information(SMESHGUI::desktop(),
3362 tr("SMESH_INFORMATION"),
3363 tr("NB_NODES_REMOVED").arg(removed));
3364 if ( removed > 0 ) {
3365 SMESH::UpdateView();
3366 SMESHGUI::Modified();
3369 catch (const SALOME::SALOME_Exception& S_ex) {
3370 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3379 case SMESHOp::OpRenumberingNodes:
3381 if(checkLock(aStudy)) break;
3383 EmitSignalDeactivateDialog();
3384 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3388 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3389 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3393 case SMESHOp::OpRenumberingElements:
3395 if(checkLock(aStudy)) break;
3397 EmitSignalDeactivateDialog();
3398 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3402 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3403 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3407 case SMESHOp::OpTranslation:
3409 if(checkLock(aStudy)) break;
3411 EmitSignalDeactivateDialog();
3412 ( new SMESHGUI_TranslationDlg( this ) )->show();
3415 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3416 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3420 case SMESHOp::OpRotation:
3422 if(checkLock(aStudy)) break;
3424 EmitSignalDeactivateDialog();
3425 ( new SMESHGUI_RotationDlg( this ) )->show();
3428 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3429 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3433 case SMESHOp::OpSymmetry:
3435 if(checkLock(aStudy)) break;
3437 EmitSignalDeactivateDialog();
3438 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3441 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3442 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3446 case SMESHOp::OpScale:
3448 if(checkLock(aStudy)) break;
3450 EmitSignalDeactivateDialog();
3451 ( new SMESHGUI_ScaleDlg( this ) )->show();
3454 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3455 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3460 case SMESHOp::OpSewing:
3462 if(checkLock(aStudy)) break;
3464 EmitSignalDeactivateDialog();
3465 ( new SMESHGUI_SewingDlg( this ) )->show();
3468 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3469 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3473 case SMESHOp::OpMergeNodes:
3475 if(checkLock(aStudy)) break;
3477 EmitSignalDeactivateDialog();
3478 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3481 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3482 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3486 case SMESHOp::OpMergeElements:
3488 if (checkLock(aStudy)) break;
3490 EmitSignalDeactivateDialog();
3491 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3493 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3494 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3499 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3500 startOperation( SMESHOp::OpMoveNode );
3503 case SMESHOp::OpDuplicateNodes:
3505 if(checkLock(aStudy)) break;
3507 EmitSignalDeactivateDialog();
3508 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3511 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3512 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3517 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3518 startOperation( SMESHOp::OpElem0DOnElemNodes );
3521 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3523 static QList<int> aTypes;
3524 if ( aTypes.isEmpty() )
3526 aTypes.append( SMESH::NODE );
3527 aTypes.append( SMESH::EDGE );
3528 aTypes.append( SMESH::FACE );
3529 aTypes.append( SMESH::VOLUME );
3531 if (!myFilterLibraryDlg)
3532 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3533 else if (myFilterLibraryDlg->isHidden())
3534 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3535 myFilterLibraryDlg->raise();
3539 case SMESHOp::OpFreeNode:
3540 case SMESHOp::OpEqualNode:
3541 case SMESHOp::OpFreeEdge:
3542 case SMESHOp::OpFreeBorder:
3543 case SMESHOp::OpLength:
3544 case SMESHOp::OpConnection:
3545 case SMESHOp::OpEqualEdge:
3546 case SMESHOp::OpFreeFace:
3547 case SMESHOp::OpBareBorderFace:
3548 case SMESHOp::OpOverConstrainedFace:
3549 case SMESHOp::OpLength2D:
3550 case SMESHOp::OpConnection2D:
3551 case SMESHOp::OpArea:
3552 case SMESHOp::OpTaper:
3553 case SMESHOp::OpAspectRatio:
3554 case SMESHOp::OpMinimumAngle:
3555 case SMESHOp::OpWarpingAngle:
3556 case SMESHOp::OpSkew:
3557 case SMESHOp::OpMaxElementLength2D:
3558 case SMESHOp::OpEqualFace:
3559 case SMESHOp::OpAspectRatio3D:
3560 case SMESHOp::OpVolume:
3561 case SMESHOp::OpMaxElementLength3D:
3562 case SMESHOp::OpBareBorderVolume:
3563 case SMESHOp::OpOverConstrainedVolume:
3564 case SMESHOp::OpEqualVolume:
3567 LightApp_SelectionMgr* mgr = selectionMgr();
3568 SALOME_ListIO selected; mgr->selectedObjects( selected );
3570 if( !selected.IsEmpty() ) {
3571 SUIT_OverrideCursor wc;
3572 ::Control( theCommandID );
3575 SUIT_MessageBox::warning(desktop(),
3576 tr( "SMESH_WRN_WARNING" ),
3577 tr( "SMESH_BAD_SELECTION" ) );
3581 SUIT_MessageBox::warning(desktop(),
3582 tr( "SMESH_WRN_WARNING" ),
3583 tr( "NOT_A_VTK_VIEWER" ) );
3586 case SMESHOp::OpOverallMeshQuality:
3587 OverallMeshQuality();
3589 case SMESHOp::OpNumberingNodes:
3591 SUIT_OverrideCursor wc;
3592 LightApp_SelectionMgr* mgr = selectionMgr();
3593 SALOME_ListIO selected; mgr->selectedObjects( selected );
3595 SALOME_ListIteratorOfListIO it(selected);
3596 for( ; it.More(); it.Next()) {
3597 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3598 if(anIObject->hasEntry()) {
3599 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3600 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3606 case SMESHOp::OpNumberingElements:
3608 SUIT_OverrideCursor wc;
3609 LightApp_SelectionMgr* mgr = selectionMgr();
3610 SALOME_ListIO selected; mgr->selectedObjects( selected );
3612 SALOME_ListIteratorOfListIO it(selected);
3613 for( ; it.More(); it.Next()) {
3614 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3615 if(anIObject->hasEntry())
3616 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3617 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3622 case SMESHOp::OpPropertiesLength:
3623 case SMESHOp::OpPropertiesArea:
3624 case SMESHOp::OpPropertiesVolume:
3625 case SMESHOp::OpMinimumDistance:
3626 case SMESHOp::OpBoundingBox:
3628 int page = SMESHGUI_MeasureDlg::MinDistance;
3629 if ( theCommandID == SMESHOp::OpBoundingBox )
3630 page = SMESHGUI_MeasureDlg::BoundingBox;
3631 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3632 page = SMESHGUI_MeasureDlg::Length;
3633 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3634 page = SMESHGUI_MeasureDlg::Area;
3635 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3636 page = SMESHGUI_MeasureDlg::Volume;
3638 EmitSignalDeactivateDialog();
3639 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3643 case SMESHOp::OpSortChild:
3649 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3650 //updateObjBrowser();
3654 //=============================================================================
3658 //=============================================================================
3659 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3664 //=============================================================================
3668 //=============================================================================
3669 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3674 //=============================================================================
3678 //=============================================================================
3679 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3684 //=============================================================================
3685 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3686 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3688 //=============================================================================
3689 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3690 SUIT_ViewWindow* wnd )
3692 if(theIO->hasEntry()){
3693 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3694 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3698 //=======================================================================
3699 // function : createSMESHAction
3701 //=======================================================================
3702 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3703 const int key, const bool toggle, const QString& shortcutAction )
3706 QWidget* parent = application()->desktop();
3707 SUIT_ResourceMgr* resMgr = resourceMgr();
3709 if ( !icon_id.isEmpty() )
3710 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3712 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3713 if ( !pix.isNull() )
3714 icon = QIcon( pix );
3716 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3717 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3718 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3720 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3721 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3724 //=======================================================================
3725 // function : createPopupItem
3727 //=======================================================================
3728 void SMESHGUI::createPopupItem( const int id,
3729 const QString& clients,
3730 const QString& types,
3731 const QString& theRule,
3734 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3735 popupMgr()->insert( action( id ), pId, 0 );
3737 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3738 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3739 QString rule = "(%1) and (%2) and (%3)";
3740 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3741 if( clients.isEmpty() )
3742 rule = rule.arg( QString( "true" ) );
3744 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3745 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3748 bool cont = myRules.contains( id );
3750 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3752 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3753 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3756 //=======================================================================
3757 // function : initialize
3759 //=======================================================================
3760 void SMESHGUI::initialize( CAM_Application* app )
3762 SalomeApp_Module::initialize( app );
3764 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3766 /* Automatic Update flag */
3767 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3769 // ----- create actions --------------
3771 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3772 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3773 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3774 //createSMESHAction( 114, "NUM" );
3775 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3777 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3779 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3780 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3781 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3782 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3783 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3784 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3786 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3788 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3789 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3790 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3791 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3792 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3793 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3795 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3797 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3798 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3799 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3800 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3801 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3802 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3803 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3804 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3805 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3806 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3807 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3808 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3809 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3810 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3811 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3812 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3813 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3814 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3815 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3816 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3817 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3818 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3819 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3820 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3821 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3822 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3823 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3824 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3825 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3826 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3828 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3829 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3830 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3831 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3832 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3833 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3834 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3835 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3836 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3837 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3838 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3839 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3840 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3841 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3842 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3843 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3844 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3845 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3846 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3847 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3848 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3849 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3850 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3851 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3852 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3853 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3854 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3856 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3857 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3858 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3859 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3860 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3861 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3862 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3863 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3864 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3865 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3866 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3867 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3868 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3869 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3870 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3871 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3872 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3873 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3874 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3875 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3876 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3877 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3878 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3879 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3880 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3882 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3883 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3884 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3885 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3887 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3888 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3890 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3891 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3892 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3893 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3894 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3895 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3896 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3897 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3898 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3899 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3900 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3901 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3902 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3903 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3904 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3905 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3906 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3907 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3908 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3909 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3910 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3911 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3912 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3913 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3915 createSMESHAction( SMESHOp::OpReset, "RESET" );
3916 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3917 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
3918 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3919 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3920 #ifndef DISABLE_PLOT2DVIEWER
3921 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3923 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3924 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3925 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3926 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3927 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3928 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3929 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3930 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3931 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3932 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3933 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
3934 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
3935 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3937 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3938 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3940 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3941 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3942 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3943 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3944 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3945 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3946 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3947 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3948 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3950 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3951 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3952 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3953 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3954 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
3956 createSMESHAction( SMESHOp::OpHide, "HIDE" );
3957 createSMESHAction( SMESHOp::OpShow, "SHOW" );
3958 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
3960 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
3962 QList<int> aCtrlActions;
3963 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode // node controls
3964 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
3965 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
3966 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
3967 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
3968 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
3969 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
3970 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
3971 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
3972 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
3973 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
3974 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
3975 aCtrlGroup->setExclusive( true );
3976 for( int i = 0; i < aCtrlActions.size(); i++ )
3977 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
3979 // ----- create menu --------------
3980 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3981 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3982 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3983 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3984 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3985 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3986 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3987 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3989 createMenu( separator(), fileId );
3991 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
3992 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
3993 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3994 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3995 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
3996 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
3997 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
3998 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
3999 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4000 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4001 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4002 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4003 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4005 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4006 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4007 createMenu( SMESHOp::OpImportMED, importId, -1 );
4008 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4010 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4012 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4013 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4014 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4015 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4016 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4017 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4019 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4021 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4022 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4023 createMenu( separator(), fileId, 10 );
4025 createMenu( SMESHOp::OpDelete, editId, -1 );
4027 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4029 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4030 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4031 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4032 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4033 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4034 createMenu( separator(), meshId, -1 );
4035 createMenu( SMESHOp::OpCompute, meshId, -1 );
4036 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4037 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4038 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4039 createMenu( separator(), meshId, -1 );
4040 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4041 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4042 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4043 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4044 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4045 createMenu( separator(), meshId, -1 );
4046 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4047 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4048 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4049 createMenu( separator(), meshId, -1 );
4050 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4051 createMenu( separator(), meshId, -1 );
4052 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4053 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4054 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4055 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4056 createMenu( separator(), meshId, -1 );
4058 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4059 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4060 createMenu( SMESHOp::OpFreeEdge, edgeId, -1 );
4061 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4062 createMenu( SMESHOp::OpLength, edgeId, -1 );
4063 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4064 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4065 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4066 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4067 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4068 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4069 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4070 createMenu( SMESHOp::OpArea, faceId, -1 );
4071 createMenu( SMESHOp::OpTaper, faceId, -1 );
4072 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4073 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4074 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4075 createMenu( SMESHOp::OpSkew, faceId, -1 );
4076 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4077 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4078 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4079 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4080 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4081 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4082 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4083 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4084 createMenu( separator(), ctrlId, -1 );
4085 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4086 createMenu( separator(), ctrlId, -1 );
4087 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4089 createMenu( SMESHOp::OpNode, addId, -1 );
4090 createMenu( SMESHOp::OpElem0D, addId, -1 );
4091 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4092 createMenu( SMESHOp::OpBall, addId, -1 );
4093 createMenu( SMESHOp::OpEdge, addId, -1 );
4094 createMenu( SMESHOp::OpTriangle, addId, -1 );
4095 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4096 createMenu( SMESHOp::OpPolygon, addId, -1 );
4097 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4098 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4099 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4100 createMenu( SMESHOp::OpPyramid, addId, -1 );
4101 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4102 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4103 createMenu( separator(), addId, -1 );
4104 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4105 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4106 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4107 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4108 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4109 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4110 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4111 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4112 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4113 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4114 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4116 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4117 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4118 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4119 createMenu( separator(), removeId, -1 );
4120 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4121 createMenu( separator(), removeId, -1 );
4122 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4124 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4125 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4127 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4128 createMenu( SMESHOp::OpRotation, transfId, -1 );
4129 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4130 createMenu( SMESHOp::OpScale, transfId, -1 );
4131 createMenu( SMESHOp::OpSewing, transfId, -1 );
4132 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4133 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4134 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4136 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4137 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4138 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4139 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4140 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4141 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4142 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4143 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4144 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4145 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4146 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4147 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4148 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4149 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4150 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4151 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4153 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4154 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4155 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4156 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4157 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4158 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4160 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4161 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4162 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4163 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4165 // ----- create toolbars --------------
4166 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4167 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4168 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4169 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4170 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4171 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4172 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4173 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4174 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4175 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4176 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4177 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4178 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4179 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4180 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4182 createTool( SMESHOp::OpCreateMesh, meshTb );
4183 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4184 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4185 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4186 createTool( SMESHOp::OpCopyMesh, meshTb );
4187 createTool( separator(), meshTb );
4188 createTool( SMESHOp::OpCompute, meshTb );
4189 createTool( SMESHOp::OpPreCompute, meshTb );
4190 createTool( SMESHOp::OpEvaluate, meshTb );
4191 createTool( SMESHOp::OpMeshOrder, meshTb );
4193 createTool( SMESHOp::OpCreateGroup, groupTb );
4194 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4195 createTool( SMESHOp::OpConstructGroup, groupTb );
4196 createTool( SMESHOp::OpEditGroup, groupTb );
4198 createTool( SMESHOp::OpMeshInformation, info );
4199 //createTool( SMESHOp::OpStdInfo, meshTb );
4200 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4201 createTool( SMESHOp::OpFindElementByPoint, info );
4203 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4204 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4206 createTool( SMESHOp::OpFreeEdge, ctrl1dTb );
4207 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4208 createTool( SMESHOp::OpLength, ctrl1dTb );
4209 createTool( SMESHOp::OpConnection, ctrl1dTb );
4210 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4212 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4213 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4214 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4215 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4216 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4217 createTool( SMESHOp::OpArea, ctrl2dTb );
4218 createTool( SMESHOp::OpTaper, ctrl2dTb );
4219 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4220 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4221 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4222 createTool( SMESHOp::OpSkew, ctrl2dTb );
4223 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4224 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4226 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4227 createTool( SMESHOp::OpVolume, ctrl3dTb );
4228 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4229 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4230 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4231 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4233 createTool( SMESHOp::OpNode, addElemTb );
4234 createTool( SMESHOp::OpElem0D, addElemTb );
4235 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4236 createTool( SMESHOp::OpBall, addElemTb );
4237 createTool( SMESHOp::OpEdge, addElemTb );
4238 createTool( SMESHOp::OpTriangle, addElemTb );
4239 createTool( SMESHOp::OpQuadrangle, addElemTb );
4240 createTool( SMESHOp::OpPolygon, addElemTb );
4241 createTool( SMESHOp::OpTetrahedron, addElemTb );
4242 createTool( SMESHOp::OpHexahedron, addElemTb );
4243 createTool( SMESHOp::OpPentahedron, addElemTb );
4244 createTool( SMESHOp::OpPyramid, addElemTb );
4245 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4246 createTool( SMESHOp::OpPolyhedron, addElemTb );
4248 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4249 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4250 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4251 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4252 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4253 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4254 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4255 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4256 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4257 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4258 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4260 createTool( SMESHOp::OpRemoveNodes, remTb );
4261 createTool( SMESHOp::OpRemoveElements, remTb );
4262 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4263 createTool( SMESHOp::OpClearMesh, remTb );
4265 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4266 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4268 createTool( SMESHOp::OpTranslation, transformTb );
4269 createTool( SMESHOp::OpRotation, transformTb );
4270 createTool( SMESHOp::OpSymmetry, transformTb );
4271 createTool( SMESHOp::OpScale, transformTb );
4272 createTool( SMESHOp::OpSewing, transformTb );
4273 createTool( SMESHOp::OpMergeNodes, transformTb );
4274 createTool( SMESHOp::OpMergeElements, transformTb );
4275 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4277 createTool( SMESHOp::OpMoveNode, modifyTb );
4278 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4279 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4280 createTool( SMESHOp::OpOrientation, modifyTb );
4281 createTool( SMESHOp::OpReorientFaces, modifyTb );
4282 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4283 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4284 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4285 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4286 createTool( SMESHOp::OpSmoothing, modifyTb );
4287 createTool( SMESHOp::OpExtrusion, modifyTb );
4288 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4289 createTool( SMESHOp::OpRevolution, modifyTb );
4290 createTool( SMESHOp::OpPatternMapping, modifyTb );
4291 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4292 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4294 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4296 createTool( SMESHOp::OpUpdate, dispModeTb );
4298 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4299 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4302 QString OB = "'ObjectBrowser'",
4303 View = "'" + SVTK_Viewer::Type() + "'",
4305 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4306 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4307 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4308 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4309 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4310 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4311 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4312 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4313 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4314 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4315 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4317 mesh_part = mesh + " " + subMesh + " " + group,
4318 mesh_group = mesh + " " + group,
4319 hyp_alg = hypo + " " + algo;
4321 // popup for object browser
4323 isInvisible("not( isVisible )"),
4324 isEmpty("numberOfNodes = 0"),
4325 isNotEmpty("numberOfNodes <> 0"),
4327 // has nodes, edges, etc in VISIBLE! actor
4328 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4329 hasElems("(count( elemTypes ) > 0)"),
4330 hasDifferentElems("(count( elemTypes ) > 1)"),
4331 hasBalls("({'BallElem'} in elemTypes)"),
4332 hasElems0d("({'Elem0d'} in elemTypes)"),
4333 hasEdges("({'Edge'} in elemTypes)"),
4334 hasFaces("({'Face'} in elemTypes)"),
4335 hasVolumes("({'Volume'} in elemTypes)"),
4336 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4338 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4339 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& isComputable");
4340 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, mesh, "&& isComputable");
4341 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, subMesh, "&& isComputable" );
4342 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4343 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4345 popupMgr()->insert( separator(), -1, 0 );
4346 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& isComputable" );
4347 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& isComputable && isPreComputable" );
4348 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& isComputable" );
4349 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& isComputable" );
4350 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4351 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4352 createPopupItem( SMESHOp::OpFindElementByPoint, OB, mesh_group );
4353 createPopupItem( SMESHOp::OpOverallMeshQuality, OB, mesh_part );
4354 popupMgr()->insert( separator(), -1, 0 );
4355 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh );
4356 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh );
4357 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4358 popupMgr()->insert( separator(), -1, 0 );
4359 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo);
4360 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4361 popupMgr()->insert( separator(), -1, 0 );
4362 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4363 popupMgr()->insert( separator(), -1, 0 );
4364 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh + " " + subMesh ); // convert to quadratic
4365 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh + " " + group, // create 2D mesh from 3D
4367 popupMgr()->insert( separator(), -1, 0 );
4369 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4370 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4371 QString only_one_2D = only_one_non_empty + " && dim>1";
4373 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4374 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4375 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4376 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4378 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4380 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4381 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4382 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4383 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4384 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4385 popupMgr()->insert( separator(), -1, 0 );
4388 createPopupItem( SMESHOp::OpEditGroup, View, group );
4389 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4390 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4392 popupMgr()->insert( separator(), -1, 0 );
4393 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4394 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4395 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4396 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4397 popupMgr()->insert( separator(), -1, 0 );
4399 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4400 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4401 popupMgr()->insert( separator(), -1, 0 );
4403 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4404 QString aType = QString( "%1type in {%2}" ).arg( lc );
4405 aType = aType.arg( mesh_part );
4406 QString aMeshInVTK = aClient + "&&" + aType;
4408 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4409 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4410 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4412 //-------------------------------------------------
4414 //-------------------------------------------------
4415 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4417 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4418 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4419 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4421 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4422 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4423 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4425 popupMgr()->insert( separator(), -1, -1 );
4427 //-------------------------------------------------
4429 //-------------------------------------------------
4430 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4432 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4433 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4434 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4436 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4437 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4438 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4440 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4441 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4442 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4444 popupMgr()->insert( separator(), anId, -1 );
4446 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4447 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4448 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4450 //-------------------------------------------------
4452 //-------------------------------------------------
4453 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4455 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4457 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4458 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4459 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4461 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4462 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4463 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4465 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4466 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4467 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4469 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4470 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4471 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4473 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4474 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4475 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4477 popupMgr()->insert( separator(), anId, -1 );
4479 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4480 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4482 popupMgr()->insert( separator(), anId, -1 );
4484 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4485 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4488 //-------------------------------------------------
4489 // Representation of the 2D Quadratic elements
4490 //-------------------------------------------------
4491 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4492 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4493 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4494 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4496 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4497 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4498 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4500 //-------------------------------------------------
4501 // Orientation of faces
4502 //-------------------------------------------------
4503 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4504 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4505 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4507 //-------------------------------------------------
4509 //-------------------------------------------------
4510 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4511 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4513 //-------------------------------------------------
4515 //-------------------------------------------------
4516 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4517 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4519 //-------------------------------------------------
4521 //-------------------------------------------------
4523 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4524 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4525 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4526 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4528 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4530 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4531 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4533 popupMgr()->insert( separator(), anId, -1 );
4535 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4537 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4538 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4539 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4541 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4542 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4543 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4545 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4547 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4548 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4549 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4551 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4552 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4553 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4555 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4556 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4557 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4558 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4559 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4560 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4562 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4564 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4565 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4566 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4568 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4569 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4570 QtxPopupMgr::VisibleRule );
4571 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4573 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4574 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4575 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4577 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4578 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4579 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4581 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4582 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4583 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4585 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4586 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4587 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4589 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4590 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4591 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4593 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4594 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4595 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4597 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4598 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4599 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4601 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4602 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4603 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4605 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4606 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4607 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4609 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4610 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4611 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4613 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4614 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4615 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4616 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4617 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4618 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4620 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4622 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4623 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4624 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4626 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4627 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4628 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4630 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4631 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4632 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4634 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4635 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4636 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4638 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4639 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4640 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4642 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4643 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4644 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4646 popupMgr()->insert( separator(), anId, -1 );
4648 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4649 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4650 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4651 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4652 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4654 popupMgr()->insert( separator(), anId, -1 );
4656 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4658 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4659 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4661 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4662 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4663 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4665 #ifndef DISABLE_PLOT2DVIEWER
4666 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4667 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4670 //-------------------------------------------------
4672 //-------------------------------------------------
4673 popupMgr()->insert( separator(), -1, -1 );
4674 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4675 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4676 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4677 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4679 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4680 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4682 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4683 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4685 popupMgr()->insert( separator(), -1, -1 );
4687 //-------------------------------------------------
4689 //-------------------------------------------------
4690 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4691 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4693 popupMgr()->insert( separator(), -1, -1 );
4695 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4696 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4697 popupMgr()->insert( separator(), -1, -1 );
4699 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4700 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4702 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4703 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4706 //================================================================================
4708 * \brief Return true if SMESH or GEOM objects are selected.
4709 * Is called form LightApp_Module::activateModule() which clear selection if
4710 * not isSelectionCompatible()
4712 //================================================================================
4714 bool SMESHGUI::isSelectionCompatible()
4716 bool isCompatible = true;
4717 SALOME_ListIO selected;
4718 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4719 Sel->selectedObjects( selected );
4721 SALOME_ListIteratorOfListIO It( selected );
4722 for ( ; isCompatible && It.More(); It.Next())
4724 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4725 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4727 return isCompatible;
4731 bool SMESHGUI::reusableOperation( const int id )
4733 // compute, evaluate and precompute are not reusable operations
4734 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4737 bool SMESHGUI::activateModule( SUIT_Study* study )
4739 bool res = SalomeApp_Module::activateModule( study );
4741 setMenuShown( true );
4742 setToolShown( true );
4744 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4745 PyGILState_STATE gstate = PyGILState_Ensure();
4746 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4747 if ( !pluginsmanager ) {
4751 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4756 PyGILState_Release(gstate);
4757 // end of SMESH plugins loading
4759 // Reset actions accelerator keys
4760 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4762 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4763 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4764 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4765 if ( _PTR(Study) aStudy = s->studyDS() )
4766 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4769 // get all view currently opened in the study and connect their signals to
4770 // the corresponding slots of the class.
4771 SUIT_Desktop* aDesk = study->application()->desktop();
4773 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4774 SUIT_ViewWindow* wnd;
4775 foreach ( wnd, wndList )
4779 Py_XDECREF(pluginsmanager);
4783 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4785 setMenuShown( false );
4786 setToolShown( false );
4788 EmitSignalCloseAllDialogs();
4790 // Unset actions accelerator keys
4791 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4793 return SalomeApp_Module::deactivateModule( study );
4796 void SMESHGUI::studyClosed( SUIT_Study* s )
4800 SMESH::RemoveVisuData( s->id() );
4801 SalomeApp_Module::studyClosed( s );
4804 void SMESHGUI::OnGUIEvent()
4806 const QObject* obj = sender();
4807 if ( !obj || !obj->inherits( "QAction" ) )
4809 int id = actionId((QAction*)obj);
4814 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4816 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4817 if ( CORBA::is_nil( myComponentSMESH ) )
4819 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4821 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4822 return aGUI.myComponentSMESH;
4825 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4826 return myComponentSMESH;
4829 QString SMESHGUI::engineIOR() const
4831 CORBA::ORB_var anORB = getApp()->orb();
4832 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4833 return QString( anIOR.in() );
4836 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4838 SalomeApp_Module::contextMenuPopup( client, menu, title );
4840 selectionMgr()->selectedObjects( lst );
4841 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4842 Handle(SALOME_InteractiveObject) io = lst.First();
4843 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4844 _PTR(Study) study = appStudy->studyDS();
4845 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4847 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4848 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4849 aName.remove( (aName.length() - 1), 1 );
4855 LightApp_Selection* SMESHGUI::createSelection() const
4857 return new SMESHGUI_Selection();
4860 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4862 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4863 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4864 #ifndef DISABLE_PYCONSOLE
4865 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4869 void SMESHGUI::viewManagers( QStringList& list ) const
4871 list.append( SVTK_Viewer::Type() );
4874 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4876 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4877 SMESH::UpdateSelectionProp( this );
4879 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4880 for(int i = 0; i < aViews.count() ; i++){
4881 SUIT_ViewWindow *sf = aViews[i];
4884 EmitSignalActivatedViewManager();
4888 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4890 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4891 myClippingPlaneInfoMap.erase( theViewManager );
4894 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4896 theActor->AddObserver( SMESH::DeleteActorEvent,
4897 myEventCallbackCommand.GetPointer(),
4901 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4902 unsigned long theEvent,
4903 void* theClientData,
4906 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4907 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4908 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4909 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4910 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4911 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4912 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4913 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4914 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4915 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4916 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4917 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4918 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4919 if( anActor == *anIter3 ) {
4920 anActorList.erase( anIter3 );
4931 void SMESHGUI::createPreferences()
4933 // General tab ------------------------------------------------------------------------
4934 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4936 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4937 setPreferenceProperty( autoUpdate, "columns", 2 );
4938 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4939 setPreferenceProperty( lim, "min", 0 );
4940 setPreferenceProperty( lim, "max", 100000000 );
4941 setPreferenceProperty( lim, "step", 1000 );
4942 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4943 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4945 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4946 setPreferenceProperty( qaGroup, "columns", 2 );
4947 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4948 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4949 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4950 setPreferenceProperty( prec, "min", 0 );
4951 setPreferenceProperty( prec, "max", 100 );
4952 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4953 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4954 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4955 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4956 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4958 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
4959 setPreferenceProperty( dispgroup, "columns", 2 );
4960 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4962 modes.append( tr("MEN_WIRE") );
4963 modes.append( tr("MEN_SHADE") );
4964 modes.append( tr("MEN_NODES") );
4965 modes.append( tr("MEN_SHRINK") );
4966 QList<QVariant> indices;
4967 indices.append( 0 );
4968 indices.append( 1 );
4969 indices.append( 2 );
4970 indices.append( 3 );
4971 setPreferenceProperty( dispmode, "strings", modes );
4972 setPreferenceProperty( dispmode, "indexes", indices );
4974 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
4975 setPreferenceProperty( arcgroup, "columns", 2 );
4976 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4977 QStringList quadraticModes;
4978 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4979 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4981 indices.append( 0 );
4982 indices.append( 1 );
4983 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4984 setPreferenceProperty( quadraticmode, "indexes", indices );
4986 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4987 "SMESH", "max_angle" );
4988 setPreferenceProperty( maxAngle, "min", 1 );
4989 setPreferenceProperty( maxAngle, "max", 90 );
4993 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4994 setPreferenceProperty( exportgroup, "columns", 2 );
4995 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4996 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4998 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4999 setPreferenceProperty( computeGroup, "columns", 2 );
5000 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5002 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5003 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5004 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5006 indices.append( 0 );
5007 indices.append( 1 );
5008 indices.append( 2 );
5009 setPreferenceProperty( notifyMode, "strings", modes );
5010 setPreferenceProperty( notifyMode, "indexes", indices );
5012 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5013 setPreferenceProperty( infoGroup, "columns", 2 );
5014 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5016 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5017 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5019 indices.append( 0 );
5020 indices.append( 1 );
5021 setPreferenceProperty( elemInfo, "strings", modes );
5022 setPreferenceProperty( elemInfo, "indexes", indices );
5023 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5024 setPreferenceProperty( nodesLim, "min", 0 );
5025 setPreferenceProperty( nodesLim, "max", 10000000 );
5026 setPreferenceProperty( nodesLim, "step", 10000 );
5027 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5028 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5029 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5030 setPreferenceProperty( ctrlLim, "min", 0 );
5031 setPreferenceProperty( ctrlLim, "max", 10000000 );
5032 setPreferenceProperty( ctrlLim, "step", 1000 );
5033 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5034 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5035 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5036 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5037 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5039 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5040 setPreferenceProperty( segGroup, "columns", 2 );
5041 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5042 "SMESH", "segmentation" );
5043 setPreferenceProperty( segLen, "min", 1 );
5044 setPreferenceProperty( segLen, "max", 10000000 );
5045 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5046 "SMESH", "nb_segments_per_edge" );
5047 setPreferenceProperty( nbSeg, "min", 1 );
5048 setPreferenceProperty( nbSeg, "max", 10000000 );
5050 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5051 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5052 "SMESH", "forget_mesh_on_hyp_modif" );
5055 // Quantities with individual precision settings
5056 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5057 setPreferenceProperty( precGroup, "columns", 2 );
5059 const int nbQuantities = 6;
5060 int precs[nbQuantities], ii = 0;
5061 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5062 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5063 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5064 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5065 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5066 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5067 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5068 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5069 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5070 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5071 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5072 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5074 // Set property for precision value for spinboxes
5075 for ( ii = 0; ii < nbQuantities; ii++ ){
5076 setPreferenceProperty( precs[ii], "min", -14 );
5077 setPreferenceProperty( precs[ii], "max", 14 );
5078 setPreferenceProperty( precs[ii], "precision", 2 );
5081 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5082 setPreferenceProperty( previewGroup, "columns", 2 );
5083 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5084 setPreferenceProperty( chunkSize, "min", 1 );
5085 setPreferenceProperty( chunkSize, "max", 1000 );
5086 setPreferenceProperty( chunkSize, "step", 50 );
5088 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5089 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5091 // Mesh tab ------------------------------------------------------------------------
5092 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5093 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5094 setPreferenceProperty( nodeGroup, "columns", 3 );
5096 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5098 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5100 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5101 QList<QVariant> aMarkerTypeIndicesList;
5102 QList<QVariant> aMarkerTypeIconsList;
5103 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5104 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5105 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5106 aMarkerTypeIndicesList << i;
5107 aMarkerTypeIconsList << pixmap;
5109 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5110 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5112 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5114 QList<QVariant> aMarkerScaleIndicesList;
5115 QStringList aMarkerScaleValuesList;
5116 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5117 aMarkerScaleIndicesList << i;
5118 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5120 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5121 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5123 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5124 //setPreferenceProperty( elemGroup, "columns", 2 );
5126 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5127 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5128 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5129 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5130 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5131 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5132 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5133 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5134 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5137 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5138 setPreferenceProperty( grpGroup, "columns", 2 );
5140 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5141 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5143 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5144 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5145 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5146 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5147 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5148 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5149 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5150 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5151 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5152 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5153 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5154 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5155 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5156 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5158 setPreferenceProperty( size0d, "min", 1 );
5159 setPreferenceProperty( size0d, "max", 10 );
5161 // setPreferenceProperty( ballSize, "min", 1 );
5162 // setPreferenceProperty( ballSize, "max", 10 );
5164 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5165 setPreferenceProperty( ballDiameter, "max", 1e9 );
5166 setPreferenceProperty( ballDiameter, "step", 0.1 );
5168 setPreferenceProperty( ballScale, "min", 1e-2 );
5169 setPreferenceProperty( ballScale, "max", 1e7 );
5170 setPreferenceProperty( ballScale, "step", 0.5 );
5172 setPreferenceProperty( elemW, "min", 1 );
5173 setPreferenceProperty( elemW, "max", 5 );
5175 setPreferenceProperty( outW, "min", 1 );
5176 setPreferenceProperty( outW, "max", 5 );
5178 setPreferenceProperty( shrink, "min", 0 );
5179 setPreferenceProperty( shrink, "max", 100 );
5181 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5182 setPreferenceProperty( numGroup, "columns", 2 );
5184 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5185 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5187 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5188 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5190 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5191 setPreferenceProperty( orientGroup, "columns", 1 );
5193 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5194 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5196 setPreferenceProperty( orientScale, "min", 0.05 );
5197 setPreferenceProperty( orientScale, "max", 0.5 );
5198 setPreferenceProperty( orientScale, "step", 0.05 );
5200 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5202 // Selection tab ------------------------------------------------------------------------
5203 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5205 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5206 setPreferenceProperty( selGroup, "columns", 2 );
5208 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5209 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5211 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5212 setPreferenceProperty( preGroup, "columns", 2 );
5214 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5216 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5217 setPreferenceProperty( precSelGroup, "columns", 2 );
5219 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5220 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5221 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5223 // Scalar Bar tab ------------------------------------------------------------------------
5224 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5225 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5226 setPreferenceProperty( fontGr, "columns", 2 );
5228 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5229 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5231 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5232 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5234 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5235 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5237 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5238 setPreferenceProperty( numcol, "min", 2 );
5239 setPreferenceProperty( numcol, "max", 256 );
5241 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5242 setPreferenceProperty( numlab, "min", 2 );
5243 setPreferenceProperty( numlab, "max", 65 );
5245 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5246 setPreferenceProperty( orientGr, "columns", 2 );
5247 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5248 QStringList orients;
5249 orients.append( tr( "SMESH_VERTICAL" ) );
5250 orients.append( tr( "SMESH_HORIZONTAL" ) );
5251 indices.clear(); indices.append( 0 ); indices.append( 1 );
5252 setPreferenceProperty( orient, "strings", orients );
5253 setPreferenceProperty( orient, "indexes", indices );
5255 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5256 setPreferenceProperty( posVSizeGr, "columns", 2 );
5257 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5258 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5259 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5260 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5261 setPreferenceProperty( xv, "step", 0.1 );
5262 setPreferenceProperty( xv, "min", 0.0 );
5263 setPreferenceProperty( xv, "max", 1.0 );
5264 setPreferenceProperty( yv, "step", 0.1 );
5265 setPreferenceProperty( yv, "min", 0.0 );
5266 setPreferenceProperty( yv, "max", 1.0 );
5267 setPreferenceProperty( wv, "step", 0.1 );
5268 setPreferenceProperty( wv, "min", 0.0 );
5269 setPreferenceProperty( wv, "max", 1.0 );
5270 setPreferenceProperty( hv, "min", 0.0 );
5271 setPreferenceProperty( hv, "max", 1.0 );
5272 setPreferenceProperty( hv, "step", 0.1 );
5274 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5275 setPreferenceProperty( posHSizeGr, "columns", 2 );
5276 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5277 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5278 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5279 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5280 setPreferenceProperty( xv, "min", 0.0 );
5281 setPreferenceProperty( xv, "max", 1.0 );
5282 setPreferenceProperty( xv, "step", 0.1 );
5283 setPreferenceProperty( xh, "min", 0.0 );
5284 setPreferenceProperty( xh, "max", 1.0 );
5285 setPreferenceProperty( xh, "step", 0.1 );
5286 setPreferenceProperty( yh, "min", 0.0 );
5287 setPreferenceProperty( yh, "max", 1.0 );
5288 setPreferenceProperty( yh, "step", 0.1 );
5289 setPreferenceProperty( wh, "min", 0.0 );
5290 setPreferenceProperty( wh, "max", 1.0 );
5291 setPreferenceProperty( wh, "step", 0.1 );
5292 setPreferenceProperty( hh, "min", 0.0 );
5293 setPreferenceProperty( hh, "max", 1.0 );
5294 setPreferenceProperty( hh, "step", 0.1 );
5296 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5297 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5298 setPreferenceProperty( distributionGr, "columns", 3 );
5300 types.append( tr( "SMESH_MONOCOLOR" ) );
5301 types.append( tr( "SMESH_MULTICOLOR" ) );
5302 indices.clear(); indices.append( 0 ); indices.append( 1 );
5303 setPreferenceProperty( coloringType, "strings", types );
5304 setPreferenceProperty( coloringType, "indexes", indices );
5305 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5309 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5311 if( sect=="SMESH" ) {
5312 float sbX1,sbY1,sbW,sbH;
5313 float aTol = 1.00000009999999;
5314 std::string aWarning;
5315 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5316 if( name=="selection_object_color" || name=="selection_element_color" ||
5317 name=="highlight_color" ||
5318 name=="selection_precision_node" || name=="selection_precision_element" ||
5319 name=="selection_precision_object")
5320 SMESH::UpdateSelectionProp( this );
5321 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5322 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5323 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5324 if(sbX1+sbW > aTol){
5325 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5328 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5329 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5332 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5333 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5334 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5335 if(sbY1+sbH > aTol){
5336 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5337 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5338 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5341 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5342 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5343 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5344 if(sbX1+sbW > aTol){
5345 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5348 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5349 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5352 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5353 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5354 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5355 if(sbY1+sbH > aTol){
5356 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5359 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5360 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5363 else if ( name == "segmentation" ) {
5364 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5365 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5367 else if ( name == "nb_segments_per_edge" ) {
5368 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5369 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5371 else if ( name == "historical_python_dump" ||
5372 name == "forget_mesh_on_hyp_modif") {
5373 QString val = aResourceMgr->stringValue( "SMESH", name );
5374 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5376 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5377 SMESH::UpdateFontProp( this );
5379 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5380 SMESH::UpdateFontProp( this );
5383 if(aWarning.size() != 0){
5384 aWarning += "The default values are applied instead.";
5385 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5386 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5387 QObject::tr(aWarning.c_str()));
5392 //================================================================================
5394 * \brief Update something in accordance with update flags
5395 * \param theFlags - update flags
5397 * Update viewer or/and object browser etc. in accordance with update flags ( see
5398 * LightApp_UpdateFlags enumeration ).
5400 //================================================================================
5401 void SMESHGUI::update( const int flags )
5403 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5404 SMESH::UpdateView();
5406 SalomeApp_Module::update( flags );
5409 //================================================================================
5411 * \brief Set default selection mode
5413 * SLOT called when operation commited. Sets default selection mode
5415 //================================================================================
5416 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5418 SVTK_ViewWindow* vtkWnd =
5419 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5421 vtkWnd->SetSelectionMode( ActorSelection );
5424 //================================================================================
5426 * \brief Set default selection mode
5428 * SLOT called when operation aborted. Sets default selection mode
5430 //================================================================================
5431 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5433 SVTK_ViewWindow* vtkWnd =
5434 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5436 vtkWnd->SetSelectionMode( ActorSelection );
5439 //================================================================================
5441 * \brief Creates operation with given identifier
5442 * \param id - identifier of operation to be started
5443 * \return Pointer on created operation or NULL if operation is not created
5445 * Virtual method redefined from the base class creates operation with given id.
5446 * It is called called automatically from startOperation method of base class.
5448 //================================================================================
5449 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5451 LightApp_Operation* op = 0;
5452 // to do : create operation here
5455 case SMESHOp::OpSplitBiQuadratic:
5456 op = new SMESHGUI_SplitBiQuadOp();
5458 case SMESHOp::OpConvertMeshToQuadratic:
5459 op = new SMESHGUI_ConvToQuadOp();
5461 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5462 op = new SMESHGUI_Make2DFrom3DOp();
5464 case SMESHOp::OpReorientFaces:
5465 op = new SMESHGUI_ReorientFacesOp();
5467 case SMESHOp::OpCreateMesh:
5468 op = new SMESHGUI_MeshOp( true, true );
5470 case SMESHOp::OpCreateSubMesh:
5471 op = new SMESHGUI_MeshOp( true, false );
5473 case SMESHOp::OpEditMeshOrSubMesh:
5474 op = new SMESHGUI_MeshOp( false );
5476 case SMESHOp::OpCompute:
5477 op = new SMESHGUI_ComputeOp();
5479 case SMESHOp::OpPreCompute:
5480 op = new SMESHGUI_PrecomputeOp();
5482 case SMESHOp::OpEvaluate:
5483 op = new SMESHGUI_EvaluateOp();
5485 case SMESHOp::OpMeshOrder:
5486 op = new SMESHGUI_MeshOrderOp();
5488 case SMESHOp::OpCreateGeometryGroup:
5489 op = new SMESHGUI_GroupOnShapeOp();
5491 case SMESHOp::OpFindElementByPoint:
5492 op = new SMESHGUI_FindElemByPointOp();
5494 case SMESHOp::OpMoveNode: // Make mesh pass through point
5495 op = new SMESHGUI_MakeNodeAtPointOp();
5497 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5498 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5505 op = SalomeApp_Module::createOperation( id );
5509 //================================================================================
5511 * \brief Stops current operations and starts a given one
5512 * \param id - The id of the operation to start
5514 //================================================================================
5516 void SMESHGUI::switchToOperation(int id)
5518 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5519 activeStudy()->abortAllOperations();
5520 startOperation( id );
5523 LightApp_Displayer* SMESHGUI::displayer()
5526 myDisplayer = new SMESHGUI_Displayer( getApp() );
5530 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5533 int aTolerance = 64;
5534 int anIterations = 0;
5540 if( anIterations % aPeriod == 0 )
5543 if( aTolerance < 1 )
5547 aHue = (int)( 360.0 * rand() / RAND_MAX );
5550 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5551 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5552 for( ; it != itEnd; ++it )
5554 SALOMEDS::Color anAutoColor = *it;
5555 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5558 aQColor.getHsv( &h, &s, &v );
5559 if( abs( h - aHue ) < aTolerance )
5571 aColor.setHsv( aHue, 255, 255 );
5573 SALOMEDS::Color aSColor;
5574 aSColor.R = aColor.redF();
5575 aSColor.G = aColor.greenF();
5576 aSColor.B = aColor.blueF();
5581 const char* gSeparator = "_"; // character used to separate parameter names
5582 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5583 const char* gPathSep = "|"; // character used to separate paths
5586 * \brief Store visual parameters
5588 * This method is called just before the study document is saved.
5589 * Store visual parameters in AttributeParameter attribue(s)
5591 void SMESHGUI::storeVisualParameters (int savePoint)
5594 Kernel_Utils::Localizer loc;
5596 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5597 if (!appStudy || !appStudy->studyDS())
5599 _PTR(Study) studyDS = appStudy->studyDS();
5601 // componentName is used for encoding of entries when storing them in IParameters
5602 std::string componentName = myComponentSMESH->ComponentDataType();
5603 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5604 //if (!aSComponent) return;
5607 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5608 componentName.c_str(),
5610 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5612 // store map of custom markers
5613 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5614 if( !aMarkerMap.empty() )
5616 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5617 for( ; anIter != aMarkerMap.end(); anIter++ )
5619 int anId = anIter->first;
5620 VTK::MarkerData aMarkerData = anIter->second;
5621 std::string aMarkerFileName = aMarkerData.first;
5622 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5623 if( aMarkerTexture.size() < 3 )
5624 continue; // should contain at least width, height and the first value
5626 QString aPropertyName( "texture" );
5627 aPropertyName += gSeparator;
5628 aPropertyName += QString::number( anId );
5630 QString aPropertyValue = aMarkerFileName.c_str();
5631 aPropertyValue += gPathSep;
5633 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5634 ushort aWidth = *aTextureIter++;
5635 ushort aHeight = *aTextureIter++;
5636 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5637 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5638 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5639 aPropertyValue += QString::number( *aTextureIter );
5641 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5645 // viewers counters are used for storing view_numbers in IParameters
5648 // main cycle to store parameters of displayed objects
5649 QList<SUIT_ViewManager*> lst;
5650 QList<SUIT_ViewManager*>::Iterator it;
5651 getApp()->viewManagers(lst);
5652 for (it = lst.begin(); it != lst.end(); it++)
5654 SUIT_ViewManager* vman = *it;
5655 QString vType = vman->getType();
5657 // saving VTK actors properties
5658 if (vType == SVTK_Viewer::Type())
5660 // store the clipping planes attached to the view manager
5661 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5662 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5663 if( anIter != myClippingPlaneInfoMap.end() )
5664 aClippingPlaneInfoList = anIter->second;
5666 if( !aClippingPlaneInfoList.empty() ) {
5667 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5668 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5670 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5671 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5673 QString aPropertyName( "ClippingPlane" );
5674 aPropertyName += gSeparator;
5675 aPropertyName += QString::number( vtkViewers );
5676 aPropertyName += gSeparator;
5677 aPropertyName += QString::number( anId );
5679 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5680 aPropertyValue += gDigitsSep;
5681 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5682 aPropertyValue += gDigitsSep;
5683 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5684 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5685 aPropertyValue += gDigitsSep;
5686 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5687 aPropertyValue += gDigitsSep;
5688 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5689 aPropertyValue += gDigitsSep;
5690 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5691 aPropertyValue += gDigitsSep;
5692 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5693 aPropertyValue += gDigitsSep;
5694 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5695 aPropertyValue += gDigitsSep;
5696 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5698 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5699 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5700 aPropertyValue += gDigitsSep;
5701 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5702 aPropertyValue += gDigitsSep;
5703 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5704 aPropertyValue += gDigitsSep;
5705 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5708 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5712 QVector<SUIT_ViewWindow*> views = vman->getViews();
5713 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5715 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5717 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5718 vtkActorCollection* allActors = aCopy.GetActors();
5719 allActors->InitTraversal();
5720 while (vtkActor* actor = allActors->GetNextActor())
5722 if (actor->GetVisibility()) // store only visible actors
5724 SMESH_Actor* aSmeshActor = 0;
5725 if (actor->IsA("SMESH_Actor"))
5726 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5727 if (aSmeshActor && aSmeshActor->hasIO())
5729 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5732 // entry is "encoded" = it does NOT contain component adress,
5733 // since it is a subject to change on next component loading
5734 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5736 std::string param, vtkParam = vType.toLatin1().data();
5737 vtkParam += gSeparator;
5738 vtkParam += QString::number(vtkViewers).toLatin1().data();
5739 vtkParam += gSeparator;
5742 param = vtkParam + "Visibility";
5743 ip->setParameter(entry, param, "On");
5746 param = vtkParam + "Representation";
5747 ip->setParameter(entry, param, QString::number
5748 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5751 param = vtkParam + "IsShrunk";
5752 ip->setParameter(entry, param, QString::number
5753 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5755 // Displayed entities
5756 unsigned int aMode = aSmeshActor->GetEntityMode();
5757 bool isE = aMode & SMESH_Actor::eEdges;
5758 bool isF = aMode & SMESH_Actor::eFaces;
5759 bool isV = aMode & SMESH_Actor::eVolumes;
5760 bool is0d = aMode & SMESH_Actor::e0DElements;
5761 bool isB = aMode & SMESH_Actor::eBallElem;
5763 QString modeStr ("e");
5764 modeStr += gDigitsSep; modeStr += QString::number(isE);
5765 modeStr += gDigitsSep; modeStr += "f";
5766 modeStr += gDigitsSep; modeStr += QString::number(isF);
5767 modeStr += gDigitsSep; modeStr += "v";
5768 modeStr += gDigitsSep; modeStr += QString::number(isV);
5769 modeStr += gDigitsSep; modeStr += "0d";
5770 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5771 modeStr += gDigitsSep; modeStr += "b";
5772 modeStr += gDigitsSep; modeStr += QString::number(isB);
5774 param = vtkParam + "Entities";
5775 ip->setParameter(entry, param, modeStr.toLatin1().data());
5781 aSmeshActor->GetSufaceColor(r, g, b, delta);
5782 QStringList colorStr;
5783 colorStr << "surface";
5784 colorStr << QString::number(r);
5785 colorStr << QString::number(g);
5786 colorStr << QString::number(b);
5788 colorStr << "backsurface";
5789 colorStr << QString::number(delta);
5791 aSmeshActor->GetVolumeColor(r, g, b, delta);
5792 colorStr << "volume";
5793 colorStr << QString::number(r);
5794 colorStr << QString::number(g);
5795 colorStr << QString::number(b);
5796 colorStr << QString::number(delta);
5798 aSmeshActor->GetEdgeColor(r, g, b);
5800 colorStr << QString::number(r);
5801 colorStr << QString::number(g);
5802 colorStr << QString::number(b);
5804 aSmeshActor->GetNodeColor(r, g, b);
5806 colorStr << QString::number(r);
5807 colorStr << QString::number(g);
5808 colorStr << QString::number(b);
5810 aSmeshActor->GetOutlineColor(r, g, b);
5811 colorStr << "outline";
5812 colorStr << QString::number(r);
5813 colorStr << QString::number(g);
5814 colorStr << QString::number(b);
5816 aSmeshActor->Get0DColor(r, g, b);
5817 colorStr << "elem0d";
5818 colorStr << QString::number(r);
5819 colorStr << QString::number(g);
5820 colorStr << QString::number(b);
5822 aSmeshActor->GetBallColor(r, g, b);
5824 colorStr << QString::number(r);
5825 colorStr << QString::number(g);
5826 colorStr << QString::number(b);
5828 aSmeshActor->GetFacesOrientationColor(r, g, b);
5829 colorStr << "orientation";
5830 colorStr << QString::number(r);
5831 colorStr << QString::number(g);
5832 colorStr << QString::number(b);
5834 param = vtkParam + "Colors";
5835 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5838 QStringList sizeStr;
5840 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5841 sizeStr << "outline";
5842 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5843 sizeStr << "elem0d";
5844 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5846 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5847 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5848 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5849 sizeStr << "shrink";
5850 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5851 sizeStr << "orientation";
5852 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5853 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5855 param = vtkParam + "Sizes";
5856 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5861 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5862 if( aMarkerType == VTK::MT_USER ) {
5863 markerStr += "custom";
5864 markerStr += gDigitsSep;
5865 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5869 markerStr += gDigitsSep;
5870 markerStr += QString::number( (int)aMarkerType );
5871 markerStr += gDigitsSep;
5872 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5875 param = vtkParam + "PointMarker";
5876 ip->setParameter(entry, param, markerStr.toLatin1().data());
5879 param = vtkParam + "Opacity";
5880 ip->setParameter(entry, param,
5881 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5884 param = vtkParam + "ClippingPlane";
5886 if( !aClippingPlaneInfoList.empty() ) {
5887 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5888 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5890 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5891 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5892 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5893 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5894 if( aSmeshActor == *anIter2 ) {
5895 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5896 QString::number( anId ).toLatin1().constData() );
5903 ip->setParameter( entry, param, "Off" );
5904 } // if (io->hasEntry())
5905 } // SMESH_Actor && hasIO
5907 } // while.. actors traversal
5911 } // if (SVTK view model)
5912 } // for (viewManagers)
5915 // data structures for clipping planes processing
5919 bool isOpenGLClipping;
5920 vtkIdType RelativeOrientation;
5923 int AbsoluteOrientation;
5924 double X, Y, Z, Dx, Dy, Dz;
5926 typedef std::list<TPlaneData> TPlaneDataList;
5927 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5929 typedef std::list<vtkActor*> TActorList;
5932 TActorList ActorList;
5933 SUIT_ViewManager* ViewManager;
5935 typedef std::list<TPlaneInfo> TPlaneInfoList;
5936 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5939 * \brief Restore visual parameters
5941 * This method is called after the study document is opened.
5942 * Restore visual parameters from AttributeParameter attribue(s)
5944 void SMESHGUI::restoreVisualParameters (int savePoint)
5947 Kernel_Utils::Localizer loc;
5949 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5950 if (!appStudy || !appStudy->studyDS())
5952 _PTR(Study) studyDS = appStudy->studyDS();
5954 // componentName is used for encoding of entries when storing them in IParameters
5955 std::string componentName = myComponentSMESH->ComponentDataType();
5956 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5957 //if (!aSComponent) return;
5960 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5961 componentName.c_str(),
5963 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5965 // restore map of custom markers and map of clipping planes
5966 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5967 TPlaneDataMap aPlaneDataMap;
5969 std::vector<std::string> properties = ip->getProperties();
5970 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5972 std::string property = *propIt;
5973 QString aPropertyName( property.c_str() );
5974 QString aPropertyValue( ip->getProperty( property ).c_str() );
5976 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5977 if( aPropertyNameList.isEmpty() )
5980 QString aPropertyType = aPropertyNameList[0];
5981 if( aPropertyType == "texture" )
5983 if( aPropertyNameList.size() != 2 )
5987 int anId = aPropertyNameList[1].toInt( &ok );
5988 if( !ok || anId < 1 )
5991 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5992 if( aPropertyValueList.size() != 2 )
5995 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5996 QString aMarkerTextureString = aPropertyValueList[1];
5997 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5998 if( aMarkerTextureStringList.size() != 3 )
6002 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6007 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6011 VTK::MarkerTexture aMarkerTexture;
6012 aMarkerTexture.push_back( aWidth );
6013 aMarkerTexture.push_back( aHeight );
6015 QString aMarkerTextureData = aMarkerTextureStringList[2];
6016 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6018 QChar aChar = aMarkerTextureData.at( i );
6019 if( aChar.isDigit() )
6020 aMarkerTexture.push_back( aChar.digitValue() );
6023 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6025 else if( aPropertyType == "ClippingPlane" )
6027 if( aPropertyNameList.size() != 3 )
6031 int aViewId = aPropertyNameList[1].toInt( &ok );
6032 if( !ok || aViewId < 0 )
6036 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6037 if( !ok || aClippingPlaneId < 0 )
6040 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6041 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6044 TPlaneData aPlaneData;
6045 aPlaneData.Id = aClippingPlaneId;
6048 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6053 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6057 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6060 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6065 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6070 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6075 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6080 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6085 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6090 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6094 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6096 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6101 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6106 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6111 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6116 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6117 aPlaneDataList.push_back( aPlaneData );
6121 TPlaneInfoMap aPlaneInfoMap;
6123 std::vector<std::string> entries = ip->getEntries();
6125 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6127 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6128 QString entry (ip->decodeEntry(*entIt).c_str());
6130 // Check that the entry corresponds to a real object in the Study
6131 // as the object may be deleted or modified after the visual state is saved.
6132 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6133 if (!so) continue; //Skip the not existent entry
6135 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6136 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6138 std::vector<std::string>::iterator namesIt = paramNames.begin();
6139 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6141 // actors are stored in a map after displaying of them for
6142 // quicker access in the future: map < viewID to actor >
6143 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6145 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6147 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6148 // '_' is used as separator and should not be used in viewer type or parameter names.
6149 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6150 if (lst.size() != 3)
6153 QString viewerTypStr = lst[0];
6154 QString viewIndexStr = lst[1];
6155 QString paramNameStr = lst[2];
6158 int viewIndex = viewIndexStr.toUInt(&ok);
6159 if (!ok) // bad conversion of view index to integer
6163 if (viewerTypStr == SVTK_Viewer::Type())
6165 SMESH_Actor* aSmeshActor = 0;
6166 if (vtkActors.IsBound(viewIndex))
6167 aSmeshActor = vtkActors.Find(viewIndex);
6169 QList<SUIT_ViewManager*> lst;
6170 getApp()->viewManagers(viewerTypStr, lst);
6172 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6173 SUIT_ViewManager* vman = NULL;
6174 if (viewIndex >= 0 && viewIndex < lst.count())
6175 vman = lst.at(viewIndex);
6177 if (paramNameStr == "Visibility")
6179 if (!aSmeshActor && displayer() && vman)
6181 SUIT_ViewModel* vmodel = vman->getViewModel();
6182 // SVTK view model can be casted to SALOME_View
6183 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6185 // store displayed actor in a temporary map for quicker
6186 // access later when restoring other parameters
6187 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6188 vtkRenderer* Renderer = vtkView->getRenderer();
6189 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6190 vtkActorCollection* theActors = aCopy.GetActors();
6191 theActors->InitTraversal();
6192 bool isFound = false;
6193 vtkActor *ac = theActors->GetNextActor();
6194 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6195 if (ac->IsA("SMESH_Actor")) {
6196 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6197 if (aGeomAc->hasIO()) {
6198 Handle(SALOME_InteractiveObject) io =
6199 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6200 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6202 vtkActors.Bind(viewIndex, aGeomAc);
6208 } // if (paramNameStr == "Visibility")
6211 // the rest properties "work" with SMESH_Actor
6214 QString val ((*valuesIt).c_str());
6217 if (paramNameStr == "Representation") {
6218 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6221 else if (paramNameStr == "IsShrunk") {
6223 if (!aSmeshActor->IsShrunk())
6224 aSmeshActor->SetShrink();
6227 if (aSmeshActor->IsShrunk())
6228 aSmeshActor->UnShrink();
6231 // Displayed entities
6232 else if (paramNameStr == "Entities") {
6233 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6234 int aEntityMode = SMESH_Actor::eAllEntity;
6235 for ( int i = 0; i < mode.count(); i+=2 ) {
6236 if ( i < mode.count()-1 ) {
6237 QString type = mode[i];
6238 bool val = mode[i+1].toInt();
6239 if ( type == "e" && !val )
6240 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6241 else if ( type == "f" && !val )
6242 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6243 else if ( type == "v" && !val )
6244 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6245 else if ( type == "0d" && !val )
6246 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6247 else if ( type == "b" && !val )
6248 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6251 aSmeshActor->SetEntityMode( aEntityMode );
6254 else if (paramNameStr == "Colors") {
6255 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6262 QColor outlineColor;
6263 QColor orientationColor;
6269 // below lines are required to get default values for delta coefficients
6270 // of backface color for faces and color of reversed volumes
6271 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6272 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6273 for ( int i = 0; i < colors.count(); i++ ) {
6274 QString type = colors[i];
6275 if ( type == "surface" ) {
6276 // face color is set by 3 values r:g:b, where
6277 // - r,g,b - is rgb color components
6278 if ( i+1 >= colors.count() ) break; // format error
6279 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6280 if ( i+2 >= colors.count() ) break; // format error
6281 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6282 if ( i+3 >= colors.count() ) break; // format error
6283 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6284 faceColor.setRgbF( r, g, b );
6287 else if ( type == "backsurface" ) {
6288 // backface color can be defined in several ways
6289 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6290 // - in latest versions, it is set as delta coefficient
6291 bool rgbOk = false, deltaOk;
6292 if ( i+1 >= colors.count() ) break; // format error
6293 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6294 int delta = colors[i+1].toInt( &deltaOk );
6296 if ( i+1 < colors.count() ) // index is shifted to 1
6297 g = colors[i+1].toDouble( &rgbOk );
6298 if ( rgbOk ) i++; // shift index
6299 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6300 b = colors[i+1].toDouble( &rgbOk );
6302 // - as currently there's no way to set directly backsurface color as it was before,
6303 // we ignore old dump where r,g,b triple was set
6304 // - also we check that delta parameter is set properly
6305 if ( !rgbOk && deltaOk )
6308 else if ( type == "volume" ) {
6309 // volume color is set by 4 values r:g:b:delta, where
6310 // - r,g,b - is a normal volume rgb color components
6311 // - delta - is a reversed volume color delta coefficient
6312 if ( i+1 >= colors.count() ) break; // format error
6313 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6314 if ( i+2 >= colors.count() ) break; // format error
6315 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6316 if ( i+3 >= colors.count() ) break; // format error
6317 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6318 if ( i+4 >= colors.count() ) break; // format error
6319 int delta = colors[i+4].toInt( &bOk );
6320 if ( !bOk ) break; // format error
6321 volumeColor.setRgbF( r, g, b );
6325 else if ( type == "edge" ) {
6326 // edge color is set by 3 values r:g:b, where
6327 // - r,g,b - is rgb color components
6328 if ( i+1 >= colors.count() ) break; // format error
6329 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6330 if ( i+2 >= colors.count() ) break; // format error
6331 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6332 if ( i+3 >= colors.count() ) break; // format error
6333 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6334 edgeColor.setRgbF( r, g, b );
6337 else if ( type == "node" ) {
6338 // node color is set by 3 values r:g:b, where
6339 // - r,g,b - is rgb color components
6340 if ( i+1 >= colors.count() ) break; // format error
6341 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6342 if ( i+2 >= colors.count() ) break; // format error
6343 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6344 if ( i+3 >= colors.count() ) break; // format error
6345 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6346 nodeColor.setRgbF( r, g, b );
6349 else if ( type == "elem0d" ) {
6350 // 0d element color is set by 3 values r:g:b, where
6351 // - r,g,b - is rgb color components
6352 if ( i+1 >= colors.count() ) break; // format error
6353 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6354 if ( i+2 >= colors.count() ) break; // format error
6355 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6356 if ( i+3 >= colors.count() ) break; // format error
6357 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6358 elem0dColor.setRgbF( r, g, b );
6361 else if ( type == "ball" ) {
6362 // ball color is set by 3 values r:g:b, where
6363 // - r,g,b - is rgb color components
6364 if ( i+1 >= colors.count() ) break; // format error
6365 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6366 if ( i+2 >= colors.count() ) break; // format error
6367 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6368 if ( i+3 >= colors.count() ) break; // format error
6369 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6370 ballColor.setRgbF( r, g, b );
6373 else if ( type == "outline" ) {
6374 // outline color is set by 3 values r:g:b, where
6375 // - r,g,b - is rgb color components
6376 if ( i+1 >= colors.count() ) break; // format error
6377 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6378 if ( i+2 >= colors.count() ) break; // format error
6379 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6380 if ( i+3 >= colors.count() ) break; // format error
6381 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6382 outlineColor.setRgbF( r, g, b );
6385 else if ( type == "orientation" ) {
6386 // orientation color is set by 3 values r:g:b, where
6387 // - r,g,b - is rgb color components
6388 if ( i+1 >= colors.count() ) break; // format error
6389 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6390 if ( i+2 >= colors.count() ) break; // format error
6391 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6392 if ( i+3 >= colors.count() ) break; // format error
6393 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6394 orientationColor.setRgbF( r, g, b );
6399 if ( nodeColor.isValid() )
6400 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6402 if ( edgeColor.isValid() )
6403 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6405 if ( faceColor.isValid() )
6406 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6408 if ( volumeColor.isValid() )
6409 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6410 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6411 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6413 if ( elem0dColor.isValid() )
6414 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6416 if ( ballColor.isValid() )
6417 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6419 if ( outlineColor.isValid() )
6420 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6421 // orientation color
6422 if ( orientationColor.isValid() )
6423 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6426 else if (paramNameStr == "Sizes") {
6427 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6430 int outlineWidth = -1;
6431 int elem0dSize = -1;
6432 //int ballSize = -1;
6433 double ballDiameter = -1.0;
6434 double ballScale = -1.0;
6435 double shrinkSize = -1;
6436 double orientationSize = -1;
6437 bool orientation3d = false;
6438 for ( int i = 0; i < sizes.count(); i++ ) {
6439 QString type = sizes[i];
6440 if ( type == "line" ) {
6441 // line (wireframe) width is given as single integer value
6442 if ( i+1 >= sizes.count() ) break; // format error
6443 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6447 if ( type == "outline" ) {
6448 // outline width is given as single integer value
6449 if ( i+1 >= sizes.count() ) break; // format error
6450 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6454 else if ( type == "elem0d" ) {
6455 // 0d element size is given as single integer value
6456 if ( i+1 >= sizes.count() ) break; // format error
6457 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6461 else if ( type == "ball" ) {
6462 // balls are specified by two values: size:scale, where
6463 // - size - is a integer value specifying size
6464 // - scale - is a double value specifying scale factor
6465 if ( i+1 >= sizes.count() ) break; // format error
6466 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6467 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6468 if ( i+2 >= sizes.count() ) break; // format error
6469 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6475 else if ( type == "shrink" ) {
6476 // shrink factor is given as single floating point value
6477 if ( i+1 >= sizes.count() ) break; // format error
6478 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6482 else if ( type == "orientation" ) {
6483 // orientation vectors are specified by two values size:3d, where
6484 // - size - is a floating point value specifying scale factor
6485 // - 3d - is a boolean
6486 if ( i+1 >= sizes.count() ) break; // format error
6487 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6488 if ( i+2 >= sizes.count() ) break; // format error
6489 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6490 orientationSize = v1;
6491 orientation3d = (bool)v2;
6495 // line (wireframe) width
6496 if ( lineWidth > 0 )
6497 aSmeshActor->SetLineWidth( lineWidth );
6499 if ( outlineWidth > 0 )
6500 aSmeshActor->SetOutlineWidth( outlineWidth );
6501 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6502 aSmeshActor->SetOutlineWidth( lineWidth );
6504 if ( elem0dSize > 0 )
6505 aSmeshActor->Set0DSize( elem0dSize );
6507 /*if ( ballSize > 0 )
6508 aSmeshActor->SetBallSize( ballSize );*/
6510 if ( ballDiameter > 0 )
6511 aSmeshActor->SetBallSize( ballDiameter );
6513 if ( ballScale > 0.0 )
6514 aSmeshActor->SetBallScale( ballScale );
6516 if ( shrinkSize > 0 )
6517 aSmeshActor->SetShrinkFactor( shrinkSize );
6518 // orientation vectors
6519 if ( orientationSize > 0 ) {
6520 aSmeshActor->SetFacesOrientationScale( orientationSize );
6521 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6525 else if (paramNameStr == "PointMarker") {
6526 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6527 if( data.count() >= 2 ) {
6529 int aParam1 = data[1].toInt( &ok );
6531 if( data[0] == "std" && data.count() == 3 ) {
6532 int aParam2 = data[2].toInt( &ok );
6533 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6535 else if( data[0] == "custom" ) {
6536 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6537 if( markerIt != aMarkerMap.end() ) {
6538 VTK::MarkerData aMarkerData = markerIt->second;
6539 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6546 else if (paramNameStr == "Opacity") {
6547 aSmeshActor->SetOpacity(val.toFloat());
6550 else if (paramNameStr.startsWith("ClippingPlane")) {
6551 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6552 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6553 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6554 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6555 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6556 // new format - val looks like "Off" or "0" (plane id)
6557 // (note: in new format "Off" value is used only for consistency,
6558 // so it is processed together with values in old format)
6559 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6560 if( anIsOldFormat ) {
6561 if (paramNameStr == "ClippingPlane1" || val == "Off")
6562 aSmeshActor->RemoveAllClippingPlanes();
6564 QList<SUIT_ViewManager*> lst;
6565 getApp()->viewManagers(viewerTypStr, lst);
6566 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6567 if (viewIndex >= 0 && viewIndex < lst.count()) {
6568 SUIT_ViewManager* vman = lst.at(viewIndex);
6569 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6571 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6573 SMESH::TActorList anActorList;
6574 anActorList.push_back( aSmeshActor );
6575 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6576 aPlane->myViewWindow = vtkView;
6577 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6578 aPlane->PlaneMode = aMode;
6579 bool isOpenGLClipping = ( bool )vals[1].toInt();
6580 aPlane->IsOpenGLClipping = isOpenGLClipping;
6581 if ( aMode == SMESH::Absolute ) {
6582 aPlane->myAbsoluteOrientation = vals[2].toInt();
6583 aPlane->X = vals[3].toFloat();
6584 aPlane->Y = vals[4].toFloat();
6585 aPlane->Z = vals[5].toFloat();
6586 aPlane->Dx = vals[6].toFloat();
6587 aPlane->Dy = vals[7].toFloat();
6588 aPlane->Dz = vals[8].toFloat();
6590 else if ( aMode == SMESH::Relative ) {
6591 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6592 aPlane->myDistance = vals[3].toFloat();
6593 aPlane->myAngle[0] = vals[4].toFloat();
6594 aPlane->myAngle[1] = vals[5].toFloat();
6598 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6599 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6600 aClippingPlaneInfo.Plane = aPlane;
6601 aClippingPlaneInfo.ActorList = anActorList;
6602 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6610 int aPlaneId = val.toInt( &ok );
6611 if( ok && aPlaneId >= 0 ) {
6612 bool anIsDefinedPlane = false;
6613 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6614 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6615 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6616 TPlaneInfo& aPlaneInfo = *anIter;
6617 if( aPlaneInfo.PlaneId == aPlaneId ) {
6618 aPlaneInfo.ActorList.push_back( aSmeshActor );
6619 anIsDefinedPlane = true;
6623 if( !anIsDefinedPlane ) {
6624 TPlaneInfo aPlaneInfo;
6625 aPlaneInfo.PlaneId = aPlaneId;
6626 aPlaneInfo.ActorList.push_back( aSmeshActor );
6627 aPlaneInfo.ViewManager = vman;
6629 // to make the list sorted by plane id
6630 anIter = aPlaneInfoList.begin();
6631 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6632 const TPlaneInfo& aPlaneInfoRef = *anIter;
6633 if( aPlaneInfoRef.PlaneId > aPlaneId )
6636 aPlaneInfoList.insert( anIter, aPlaneInfo );
6641 } // if (aSmeshActor)
6642 } // other parameters than Visibility
6644 } // for names/parameters iterator
6645 } // for entries iterator
6647 // take into account planes with empty list of actors referred to them
6648 QList<SUIT_ViewManager*> aVMList;
6649 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6651 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6652 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6653 int aViewId = aPlaneDataIter->first;
6654 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6655 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6657 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6659 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6660 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6661 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6662 const TPlaneData& aPlaneData = *anIter2;
6663 int aPlaneId = aPlaneData.Id;
6665 bool anIsFound = false;
6666 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6667 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6668 const TPlaneInfo& aPlaneInfo = *anIter3;
6669 if( aPlaneInfo.PlaneId == aPlaneId ) {
6676 TPlaneInfo aPlaneInfo; // ActorList field is empty
6677 aPlaneInfo.PlaneId = aPlaneId;
6678 aPlaneInfo.ViewManager = aViewManager;
6680 // to make the list sorted by plane id
6681 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6682 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6683 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6684 if( aPlaneInfoRef.PlaneId > aPlaneId )
6687 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6693 // add clipping planes to actors according to the restored parameters
6694 // and update the clipping plane map
6695 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6696 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6697 int aViewId = anIter1->first;
6698 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6700 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6701 if( anIter2 == aPlaneDataMap.end() )
6703 const TPlaneDataList& aPlaneDataList = anIter2->second;
6705 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6706 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6707 const TPlaneInfo& aPlaneInfo = *anIter3;
6708 int aPlaneId = aPlaneInfo.PlaneId;
6709 const TActorList& anActorList = aPlaneInfo.ActorList;
6710 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6714 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6718 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6720 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6721 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6722 const TPlaneData& aPlaneData = *anIter4;
6723 if( aPlaneData.Id == aPlaneId ) {
6724 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6725 aPlane->myViewWindow = aViewWindow;
6726 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6727 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6728 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6729 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6730 aPlane->X = aPlaneData.X;
6731 aPlane->Y = aPlaneData.Y;
6732 aPlane->Z = aPlaneData.Z;
6733 aPlane->Dx = aPlaneData.Dx;
6734 aPlane->Dy = aPlaneData.Dy;
6735 aPlane->Dz = aPlaneData.Dz;
6737 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6738 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6739 aPlane->myDistance = aPlaneData.Distance;
6740 aPlane->myAngle[0] = aPlaneData.Angle[0];
6741 aPlane->myAngle[1] = aPlaneData.Angle[1];
6744 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6745 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6746 aClippingPlaneInfo.Plane = aPlane;
6747 aClippingPlaneInfo.ActorList = anActorList;
6748 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6759 // update all VTK views
6760 QList<SUIT_ViewManager*> lst;
6761 getApp()->viewManagers(lst);
6762 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6763 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6764 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6765 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6766 // set OpenGL clipping planes
6767 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6768 vtkActorCollection* anAllActors = aCopy.GetActors();
6769 anAllActors->InitTraversal();
6770 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6771 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6772 anActor->SetOpenGLClippingPlane();
6774 vtkView->getRenderer()->ResetCameraClippingRange();
6781 \brief Adds preferences for dfont of VTK viewer
6783 \param pIf group identifier
6784 \param param parameter
6785 \return identifier of preferences
6787 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6789 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6791 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6794 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6795 fam.append( tr( "SMESH_FONT_COURIER" ) );
6796 fam.append( tr( "SMESH_FONT_TIMES" ) );
6798 setPreferenceProperty( tfont, "fonts", fam );
6800 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6801 if ( needSize ) f = f | QtxFontEdit::Size;
6802 setPreferenceProperty( tfont, "features", f );
6808 \brief Actions after hypothesis edition
6809 Updates object browser after hypothesis edition
6811 void SMESHGUI::onHypothesisEdit( int result )
6814 SMESHGUI::Modified();
6815 updateObjBrowser( true );
6819 \brief Actions after choosing menu of control modes
6820 Updates control mode actions according to current selection
6822 void SMESHGUI::onUpdateControlActions()
6824 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
6825 SALOME_ListIO selected;
6827 aSel->selectedObjects( selected );
6829 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6830 if ( selected.Extent() ) {
6831 if ( selected.First()->hasEntry() ) {
6832 aControl = SMESH::FindActorByEntry( selected.First()->getEntry() )->GetControlMode();
6833 SALOME_ListIteratorOfListIO it(selected);
6834 for ( ; it.More(); it.Next() ) {
6835 Handle(SALOME_InteractiveObject) anIO = it.Value();
6836 if ( anIO->hasEntry() ) {
6837 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6838 if ( aControl != anActor->GetControlMode() ) {
6839 aControl = SMESH_Actor::eNone;
6848 int anAction = ActionToControl( aControl, true );
6850 action( anAction )->setChecked( true );
6852 QMenu* send = (QMenu*)sender();
6853 QList<QAction*> actions = send->actions();
6854 for ( int i = 0; i < actions.size(); i++ )
6855 actions[i]->setChecked( false );
6861 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6862 \param pview view being closed
6864 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6865 #ifndef DISABLE_PLOT2DVIEWER
6866 //Crear all Plot2d Viewers if need.
6867 SMESH::ClearPlot2Viewers(pview);
6869 EmitSignalCloseView();
6872 void SMESHGUI::message( const QString& msg )
6875 QStringList data = msg.split("/");
6876 if ( data.count() > 0 ) {
6877 if ( data.first() == "mesh_loading" ) {
6879 QString entry = data.count() > 1 ? data[1] : QString();
6880 if ( entry.isEmpty() )
6883 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6885 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6888 name = SMESH::fromUtf8(obj->GetName());
6889 if ( name.isEmpty() )
6892 if ( data.last() == "stop" )
6893 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6895 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6896 QApplication::processEvents();
6902 \brief Connects or disconnects signals about activating and cloning view on the module slots
6903 \param pview view which is connected/disconnected
6905 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6909 SUIT_ViewManager* viewMgr = pview->getViewManager();
6911 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6912 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6914 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6915 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6920 \brief Return \c true if object can be renamed
6922 bool SMESHGUI::renameAllowed( const QString& entry) const {
6923 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6927 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6931 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6936 if(appStudy->isComponent(entry) || obj->isReference())
6939 // check type to prevent renaming of inappropriate objects
6940 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6941 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6942 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6943 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6944 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6945 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6952 Rename object by entry.
6953 \param entry entry of the object
6954 \param name new name of the object
6955 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6957 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6959 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6963 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6968 _PTR(Study) aStudy = appStudy->studyDS();
6973 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6975 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6980 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6981 _PTR(GenericAttribute) anAttr;
6982 _PTR(AttributeName) aName;
6984 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6986 // check type to prevent renaming of inappropriate objects
6987 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6988 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6989 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6990 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6991 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6992 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6993 if ( !name.isEmpty() ) {
6994 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6996 // update name of group object and its actor
6997 Handle(SALOME_InteractiveObject) IObject =
6998 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7000 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7001 if( !aGroupObject->_is_nil() ) {
7002 aGroupObject->SetName( qPrintable(name) );
7003 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7004 anActor->setName( qPrintable(name) );
7014 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7016 static QList<QColor> colors;
7018 if ( colors.isEmpty() ) {
7020 for (int s = 0; s < 2 ; s++)
7022 for (int v = 100; v >= 40; v = v - 20)
7024 for (int h = 0; h < 359 ; h = h + 60)
7026 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7031 static int currentColor = randomize( colors.size() );
7033 SALOMEDS::Color color;
7034 color.R = (double)colors[currentColor].red() / 255.0;
7035 color.G = (double)colors[currentColor].green() / 255.0;
7036 color.B = (double)colors[currentColor].blue() / 255.0;
7038 currentColor = (currentColor+1) % colors.count();