1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FieldSelectorWdg.h"
48 #include "SMESHGUI_FileInfoDlg.h"
49 #include "SMESHGUI_FileValidator.h"
50 #include "SMESHGUI_FilterDlg.h"
51 #include "SMESHGUI_FilterLibraryDlg.h"
52 #include "SMESHGUI_FindElemByPointDlg.h"
53 #include "SMESHGUI_GroupDlg.h"
54 #include "SMESHGUI_GroupOnShapeDlg.h"
55 #include "SMESHGUI_GroupOpDlg.h"
56 #include "SMESHGUI_Hypotheses.h"
57 #include "SMESHGUI_Make2DFrom3DOp.h"
58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
59 #include "SMESHGUI_Measurements.h"
60 #include "SMESHGUI_MergeDlg.h"
61 #include "SMESHGUI_MeshInfo.h"
62 #include "SMESHGUI_MeshOp.h"
63 #include "SMESHGUI_MeshOrderOp.h"
64 #include "SMESHGUI_MeshPatternDlg.h"
65 #include "SMESHGUI_MultiEditDlg.h"
66 #include "SMESHGUI_NodesDlg.h"
67 #include "SMESHGUI_Operations.h"
68 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
69 #include "SMESHGUI_PropertiesDlg.h"
70 #include "SMESHGUI_RemoveElementsDlg.h"
71 #include "SMESHGUI_RemoveNodesDlg.h"
72 #include "SMESHGUI_RenumberingDlg.h"
73 #include "SMESHGUI_ReorientFacesDlg.h"
74 #include "SMESHGUI_RevolutionDlg.h"
75 #include "SMESHGUI_RotationDlg.h"
76 #include "SMESHGUI_ScaleDlg.h"
77 #include "SMESHGUI_Selection.h"
78 #include "SMESHGUI_SewingDlg.h"
79 #include "SMESHGUI_SingleEditDlg.h"
80 #include "SMESHGUI_SmoothingDlg.h"
81 #include "SMESHGUI_SymmetryDlg.h"
82 #include "SMESHGUI_TranslationDlg.h"
83 #include "SMESHGUI_TransparencyDlg.h"
84 #include "SMESHGUI_DisplayEntitiesDlg.h"
85 #include "SMESHGUI_SplitBiQuad.h"
87 #include "SMESHGUI_FilterUtils.h"
88 #include "SMESHGUI_GEOMGenUtils.h"
89 #include "SMESHGUI_GroupUtils.h"
90 #include "SMESHGUI_HypothesesUtils.h"
91 #include "SMESHGUI_MeshUtils.h"
92 #include "SMESHGUI_PatternUtils.h"
93 #include "SMESHGUI_Utils.h"
94 #include "SMESHGUI_VTKUtils.h"
96 #include "SMESH_version.h"
98 #include "SMESH_ControlsDef.hxx"
99 #include "SMESH_Actor.h"
100 #include "SMESH_ActorUtils.h"
101 #include "SMESH_Client.hxx"
102 #include "SMESH_ScalarBarActor.h"
103 #include "SMESH_TypeFilter.hxx"
105 // SALOME GUI includes
106 #include <SalomeApp_Application.h>
107 #include <SalomeApp_CheckFileDlg.h>
108 #include <SalomeApp_DataObject.h>
109 #include <SalomeApp_Study.h>
110 #include <SalomeApp_Tools.h>
112 #include <LightApp_DataOwner.h>
113 #include <LightApp_NameDlg.h>
114 #include <LightApp_Preferences.h>
115 #include <LightApp_SelectionMgr.h>
116 #include <LightApp_UpdateFlags.h>
118 #include <SVTK_ViewManager.h>
119 #include <SVTK_ViewModel.h>
120 #include <SVTK_ViewWindow.h>
122 #include <VTKViewer_Algorithm.h>
124 #include <SUIT_Desktop.h>
125 #include <SUIT_FileDlg.h>
126 #include <SUIT_MessageBox.h>
127 #include <SUIT_OverrideCursor.h>
128 #include <SUIT_ResourceMgr.h>
129 #include <SUIT_Session.h>
131 #include <QtxPopupMgr.h>
132 #include <QtxFontEdit.h>
134 #include <SALOME_ListIO.hxx>
136 #ifndef DISABLE_PLOT2DVIEWER
137 #include <SPlot2d_ViewModel.h>
138 #include <SPlot2d_Histogram.h>
142 #include <SALOMEconfig.h>
143 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
144 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
145 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
148 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
149 #include <QApplication>
151 #include <QTextStream>
156 #include <boost/shared_ptr.hpp>
159 #include <vtkCallbackCommand.h>
160 #include <vtkCamera.h>
161 #include <vtkLookupTable.h>
162 #include <vtkPlane.h>
163 #include <vtkRenderer.h>
165 // SALOME KERNEL includes
166 #include <SALOMEDSClient_ClientFactory.hxx>
167 #include <SALOMEDSClient_IParameters.hxx>
168 #include <SALOMEDSClient_SComponent.hxx>
169 #include <SALOMEDSClient_StudyBuilder.hxx>
170 #include <SALOMEDS_Study.hxx>
171 #include <SALOMEDS_SObject.hxx>
172 #include "utilities.h"
175 #include <Standard_ErrorHandler.hxx>
176 #include <NCollection_DataMap.hxx>
177 #include <NCollection_DoubleMap.hxx>
179 #include <Basics_Utils.hxx>
181 // Below macro, when uncommented, switches on simplified (more performant) algorithm
182 // of auto-color picking up
183 #define SIMPLE_AUTOCOLOR
188 //=============================================================
189 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
192 void ExportMeshToFile(int theCommandID);
194 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
196 void SetDisplayEntity(int theCommandID);
198 int ActionToControl( int theID, bool theReversed = false );
200 void Control( int theCommandID );
203 //================================================================================
205 * \brief Reads meshes from file
207 //================================================================================
209 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
213 std::string myExtension;
215 if ( theCommandID == SMESHOp::OpImportMED ) {
216 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
217 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
219 else if ( theCommandID == SMESHOp::OpImportUNV ) {
220 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
222 else if ( theCommandID == SMESHOp::OpImportDAT ) {
223 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
225 else if ( theCommandID == SMESHOp::OpImportSTL ) {
226 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
229 else if ( theCommandID == SMESHOp::OpImportCGNS ) {
230 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
233 else if ( theCommandID == SMESHOp::OpImportSAUV ) {
234 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
235 filter.append( QObject::tr( "All files (*)" ) );
237 else if ( theCommandID == SMESHOp::OpImportGMF ) {
238 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
239 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
242 QString anInitialPath = "";
243 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
244 anInitialPath = QDir::currentPath();
246 QStringList filenames;
247 bool toCreateGroups = true;
249 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
250 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
251 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
252 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
253 // fd->setNameFilters( filter );
254 // fd->SetChecked( true );
256 // filenames << fd->selectedFile();
257 // toCreateGroups = fd->IsChecked();
263 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
266 QObject::tr( "SMESH_IMPORT_MESH" ) );
268 if ( filenames.count() > 0 ) {
269 SUIT_OverrideCursor wc;
270 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
273 QStringList anEntryList;
274 bool isEmpty = false;
275 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
276 QString filename = *it;
277 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
279 switch ( theCommandID ) {
280 case SMESHOp::OpImportDAT:
282 // DAT format (currently unsupported)
283 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
284 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
287 case SMESHOp::OpImportUNV:
290 aMeshes->length( 1 );
291 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
292 if ( aMeshes[0]->_is_nil() )
293 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
294 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
297 case SMESHOp::OpImportMED:
300 SMESH::DriverMED_ReadStatus res;
301 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
302 if ( res != SMESH::DRS_OK ) {
303 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
304 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
308 case SMESHOp::OpImportSTL:
311 aMeshes->length( 1 );
312 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
313 if ( aMeshes[0]->_is_nil() ) {
314 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
315 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
320 case SMESHOp::OpImportCGNS:
323 SMESH::DriverMED_ReadStatus res;
324 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
325 if ( res != SMESH::DRS_OK ) {
326 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
327 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
332 case SMESHOp::OpImportSAUV:
335 SMESH::DriverMED_ReadStatus res;
336 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
337 if ( res != SMESH::DRS_OK ) {
338 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
339 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
343 case SMESHOp::OpImportGMF:
346 SMESH::ComputeError_var res;
347 aMeshes->length( 1 );
348 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
351 if ( res->code != SMESH::DRS_OK ) {
352 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
353 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
354 if ( strlen( res->comment.in() ) > 0 ) {
355 errors.back() += ": ";
356 errors.back() += res->comment.in();
363 catch ( const SALOME::SALOME_Exception& S_ex ) {
364 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
365 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
368 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
369 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
371 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
372 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
373 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
374 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
375 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
377 anEntryList.append( aMeshSO->GetID().c_str() );
385 // update Object browser
386 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
388 // browse to the published meshes
389 if( LightApp_Application* anApp =
390 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
391 anApp->browseObjects( anEntryList );
393 // show Error message box if there were errors
394 if ( errors.count() > 0 ) {
395 SUIT_MessageBox::critical( SMESHGUI::desktop(),
396 QObject::tr( "SMESH_ERROR" ),
397 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
400 // show warning message box, if some imported mesh is empty
402 SUIT_MessageBox::warning( SMESHGUI::desktop(),
403 QObject::tr( "SMESH_WRN_WARNING" ),
404 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
409 //================================================================================
411 * \brief Export selected meshes or groups into a file
413 //================================================================================
415 void ExportMeshToFile( int theCommandID )
417 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
418 SALOME_ListIO selected;
420 aSel->selectedObjects( selected );
422 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
423 theCommandID == SMESHOp::OpPopupExportDAT );
424 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
425 theCommandID == SMESHOp::OpPopupExportMED );
426 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
427 theCommandID == SMESHOp::OpPopupExportUNV );
428 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
429 theCommandID == SMESHOp::OpPopupExportSTL );
431 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
432 theCommandID == SMESHOp::OpPopupExportCGNS );
434 const bool isCGNS= false;
436 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
437 theCommandID == SMESHOp::OpPopupExportSAUV );
438 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
439 theCommandID == SMESHOp::OpPopupExportGMF );
441 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
442 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
445 // get mesh object from selection and check duplication of their names
446 bool hasDuplicatedMeshNames = false;
447 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
448 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
449 SALOME_ListIteratorOfListIO It( selected );
450 for( ; It.More(); It.Next() )
452 Handle(SALOME_InteractiveObject) anIObject = It.Value();
453 SMESH::SMESH_IDSource_var aMeshItem =
454 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
455 if ( aMeshItem->_is_nil() ) {
456 SUIT_MessageBox::warning( SMESHGUI::desktop(),
457 QObject::tr( "SMESH_WRN_WARNING" ),
458 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
462 QString aMeshName = anIObject->getName();
464 // check for name duplications
465 if ( !hasDuplicatedMeshNames )
466 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
467 if( aMeshName == (*aMeshIter).second ) {
468 hasDuplicatedMeshNames = true;
473 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
476 if( hasDuplicatedMeshNames && isMED ) {
477 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
478 QObject::tr("SMESH_WRN_WARNING"),
479 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
480 QObject::tr("SMESH_BUT_YES"),
481 QObject::tr("SMESH_BUT_NO"), 0, 1);
486 aMeshIter = aMeshList.begin();
487 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
488 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
489 QString aMeshName = (*aMeshIter).second;
491 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
493 // check for equal group names within each mesh
494 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
495 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
496 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
497 int aRet = SUIT_MessageBox::warning
498 (SMESHGUI::desktop(),
499 QObject::tr("SMESH_WRN_WARNING"),
500 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
501 QObject::tr("SMESH_BUT_YES"),
502 QObject::tr("SMESH_BUT_NO"), 0, 1);
509 // Warn the user about presence of not supported elements
511 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
515 notSupportedElemTypes.push_back( SMESH::Entity_0D );
516 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
521 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
522 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
523 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
524 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
525 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
526 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
527 notSupportedElemTypes.push_back( SMESH::Entity_0D );
528 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
533 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
534 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
535 notSupportedElemTypes.push_back( SMESH::Entity_0D );
536 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
541 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
546 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
547 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
548 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
549 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
550 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
551 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
552 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
553 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
558 notSupportedElemTypes.push_back( SMESH::Entity_0D );
559 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
560 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
561 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
562 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
563 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
564 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
565 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
566 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
568 if ( ! notSupportedElemTypes.empty() )
570 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
571 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
572 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
573 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
575 if ( !presentNotSupported.empty() )
578 const char* typeMsg[] = {
579 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
580 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
581 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
582 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
583 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
584 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
585 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
586 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
588 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
589 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
590 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1];
592 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
593 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
594 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
595 if ( iType != presentNotSupported.size() - 1 )
596 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
598 int aRet = SUIT_MessageBox::warning
599 (SMESHGUI::desktop(),
600 QObject::tr("SMESH_WRN_WARNING"),
601 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
602 QObject::tr("SMESH_BUT_YES"),
603 QObject::tr("SMESH_BUT_NO"), 0, 1);
608 // Get parameters of export operation
611 SMESH::MED_VERSION aFormat = SMESH::MED_V2_2;
612 // Init the parameters with the default values
613 bool aIsASCII_STL = true;
614 bool toCreateGroups = false;
615 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
617 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
618 bool toOverwrite = true;
619 bool toFindOutDim = true;
621 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
622 QString anInitialPath = "";
623 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
624 anInitialPath = QDir::currentPath();
626 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
628 // Get a file name to write in and additional otions
629 if ( isUNV || isDAT || isGMF ) // Export w/o options
632 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
634 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
636 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
637 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
638 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
639 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
640 anInitialPath + QString("/") + aMeshName,
641 aFilter, aTitle, false);
643 else if ( isCGNS )// Export to CGNS
645 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
646 fd->setWindowTitle( aTitle );
647 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
648 if ( !anInitialPath.isEmpty() )
649 fd->setDirectory( anInitialPath );
650 fd->selectFile(aMeshName);
651 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
652 fd->setValidator( fv );
655 aFilename = fd->selectedFile();
656 toOverwrite = fv->isOverwrite();
660 else if ( isSTL ) // Export to STL
662 QMap<QString, int> aFilterMap;
663 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
664 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
667 QMap<QString, int>::const_iterator it = aFilterMap.begin();
668 for ( ; it != aFilterMap.end(); ++it )
669 filters.push_back( it.key() );
671 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
672 fd->setWindowTitle( aTitle );
673 fd->setNameFilters( filters );
674 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
675 if ( !anInitialPath.isEmpty() )
676 fd->setDirectory( anInitialPath );
677 fd->selectFile(aMeshName);
681 aFilename = fd->selectedFile();
682 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
687 else if ( isMED || isSAUV ) // Export to MED or SAUV
689 QMap<QString, SMESH::MED_VERSION> aFilterMap;
690 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
692 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
693 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
694 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
697 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
698 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
699 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
703 QString aDefaultFilter;
704 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
705 for ( ; it != aFilterMap.end(); ++it ) {
706 filters.push_back( it.key() );
707 if (it.value() == SMESH::MED_V2_2)
708 aDefaultFilter = it.key();
710 QStringList checkBoxes;
711 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
713 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
714 QList< QWidget* > wdgList;
715 if ( fieldSelWdg->GetAllFeilds( aMeshList, aFieldList ))
716 wdgList.append( fieldSelWdg );
718 SalomeApp_CheckFileDlg* fd =
719 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
720 fd->setWindowTitle( aTitle );
721 fd->setNameFilters( filters );
722 fd->selectNameFilter( aDefaultFilter );
723 fd->SetChecked( toCreateGroups, 0 );
724 fd->SetChecked( toFindOutDim, 1 );
725 if ( !anInitialPath.isEmpty() )
726 fd->setDirectory( anInitialPath );
727 fd->selectFile(aMeshName);
730 QListView *lview = fd->findChild<QListView*>("listView");
732 lview->setMinimumHeight(200);
734 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
736 tview->setMinimumHeight(200);
739 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
740 fd->setValidator( fv );
745 aFilename = fd->selectedFile();
747 aFilename = QString::null;
750 aFormat = aFilterMap[fd->selectedNameFilter()];
751 toOverwrite = fv->isOverwrite();
753 if ( !aFilename.isEmpty() ) {
754 // med-2.1 does not support poly elements
755 if ( aFormat==SMESH::MED_V2_1 )
756 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
757 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
758 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
759 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
760 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
762 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
763 QObject::tr("SMESH_WRN_WARNING"),
764 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
765 QObject::tr("SMESH_BUT_YES"),
766 QObject::tr("SMESH_BUT_NO"), 0, 1);
774 // can't append to an existing using other format
775 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
776 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
777 if( !isVersionOk || aVersion != aFormat ) {
778 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
779 QObject::tr("SMESH_WRN_WARNING"),
780 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
781 QObject::tr("SMESH_BUT_YES"),
782 QObject::tr("SMESH_BUT_NO"), 0, 1);
789 QStringList aMeshNamesCollisionList;
790 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
791 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
792 QString anExistingMeshName( aMeshNames[ i ] );
793 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
794 QString anExportMeshName = (*aMeshIter).second;
795 if( anExportMeshName == anExistingMeshName ) {
796 aMeshNamesCollisionList.append( anExportMeshName );
801 if( !aMeshNamesCollisionList.isEmpty() ) {
802 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
803 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
804 QObject::tr("SMESH_WRN_WARNING"),
805 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
806 QObject::tr("SMESH_BUT_YES"),
807 QObject::tr("SMESH_BUT_NO"),
808 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
817 toCreateGroups = fd->IsChecked(0);
818 toFindOutDim = fd->IsChecked(1);
819 fieldSelWdg->GetSelectedFeilds();
820 if ( !fieldSelWdg->parent() )
831 if ( !aFilename.isEmpty() ) {
832 // Check whether the file already exists and delete it if yes
833 QFile aFile( aFilename );
834 if ( aFile.exists() && toOverwrite )
836 SUIT_OverrideCursor wc;
839 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
840 // bool Renumber = false;
841 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
843 // Renumber= resMgr->booleanValue("renumbering");
845 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
846 // aMeshEditor->RenumberNodes();
847 // aMeshEditor->RenumberElements();
848 // if ( SMESHGUI::automaticUpdate() )
849 // SMESH::UpdateView();
853 aMeshIter = aMeshList.begin();
854 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
856 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
857 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
858 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
859 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
860 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
861 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
862 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
863 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
865 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
866 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
867 fields, geoAssFields.toLatin1().data() );
872 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
874 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
875 if( !aMeshItem->_is_nil() )
876 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
881 if ( aMeshOrGroup->_is_equivalent( aMesh ))
882 aMesh->ExportDAT( aFilename.toUtf8().data() );
884 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
888 if ( aMeshOrGroup->_is_equivalent( aMesh ))
889 aMesh->ExportUNV( aFilename.toUtf8().data() );
891 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
895 if ( aMeshOrGroup->_is_equivalent( aMesh ))
896 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
898 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
902 aMeshIter = aMeshList.begin();
903 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
905 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
906 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
907 aMeshItem->ExportCGNS( aMeshOrGroup,
908 aFilename.toUtf8().data(),
909 toOverwrite && aMeshIndex == 0 );
914 toCreateGroups = true;
915 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
918 catch (const SALOME::SALOME_Exception& S_ex){
920 SUIT_MessageBox::warning(SMESHGUI::desktop(),
921 QObject::tr("SMESH_WRN_WARNING"),
922 QObject::tr("SMESH_EXPORT_FAILED"));
928 inline void InverseEntityMode(unsigned int& theOutputMode,
929 unsigned int theMode)
931 bool anIsNotPresent = ~theOutputMode & theMode;
933 theOutputMode |= theMode;
935 theOutputMode &= ~theMode;
938 void SetDisplayEntity(int theCommandID)
940 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
941 SALOME_ListIO selected;
943 aSel->selectedObjects( selected );
945 if ( selected.Extent() >= 1 ) {
946 SALOME_ListIteratorOfListIO It( selected );
947 for( ; It.More(); It.Next()){
948 Handle(SALOME_InteractiveObject) IObject = It.Value();
949 if(IObject->hasEntry()){
950 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
951 unsigned int aMode = anActor->GetEntityMode();
952 switch(theCommandID){
953 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
954 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
955 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
956 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
957 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
958 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
961 anActor->SetEntityMode(aMode);
970 SalomeApp_Application* app =
971 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
975 LightApp_SelectionMgr* aSel = app->selectionMgr();
976 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
977 if ( !aSel || !appStudy )
980 SALOME_ListIO selected;
981 aSel->selectedObjects( selected );
982 if ( selected.IsEmpty() )
985 Handle(SALOME_InteractiveObject) anIObject = selected.First();
987 _PTR(Study) aStudy = appStudy->studyDS();
988 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
989 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
990 if ( aMainObject->_is_nil() )
993 SUIT_OverrideCursor wc;
995 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
997 QList<SALOMEDS::Color> aReservedColors;
999 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1000 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1002 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1004 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1005 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1006 #else // old algorithm for auto-colors
1007 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1008 aReservedColors.append( aColor );
1009 #endif // SIMPLE_AUTOCOLOR
1010 aGroupObject->SetColor( aColor );
1012 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1013 if ( aGroupSObject ) {
1016 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1017 switch ( aGroupObject->GetType ()) {
1019 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1021 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1023 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1025 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1027 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1028 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1031 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1032 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1038 SMESH::RepaintCurrentView();
1041 void OverallMeshQuality()
1043 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1044 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1045 SALOME_ListIO selected;
1047 aSel->selectedObjects( selected );
1049 if ( selected.IsEmpty() ) return;
1050 SALOME_ListIteratorOfListIO It( selected );
1051 for ( ; It.More(); It.Next() ) {
1052 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1053 ctrlDlg->showInfo( It.Value() );
1058 QString functorToString( SMESH::Controls::FunctorPtr f )
1060 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1061 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1062 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1063 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1064 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1065 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1066 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1067 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1068 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1069 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1070 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1071 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1072 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1073 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1074 type = QObject::tr( "WARP_ELEMENTS" );
1075 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1076 type = QObject::tr( "TAPER_ELEMENTS" );
1077 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1078 type = QObject::tr( "SKEW_ELEMENTS" );
1079 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1080 type = QObject::tr( "AREA_ELEMENTS" );
1081 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1082 type = QObject::tr( "LENGTH_EDGES" );
1083 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1084 type = QObject::tr( "LENGTH2D_EDGES" );
1085 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1086 type = QObject::tr( "MULTI_BORDERS" );
1087 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1088 type = QObject::tr( "MULTI2D_BORDERS" );
1089 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1090 type = QObject::tr( "FREE_NODES" );
1091 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1092 type = QObject::tr( "FREE_EDGES" );
1093 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1094 type = QObject::tr( "FREE_BORDERS" );
1095 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1096 type = QObject::tr( "FREE_FACES" );
1097 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1098 type = QObject::tr( "BARE_BORDER_VOLUME" );
1099 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1100 type = QObject::tr( "BARE_BORDER_FACE" );
1101 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1102 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1103 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1104 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1105 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1106 type = QObject::tr( "EQUAL_NODE" );
1107 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1108 type = QObject::tr( "EQUAL_EDGE" );
1109 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1110 type = QObject::tr( "EQUAL_FACE" );
1111 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1112 type = QObject::tr( "EQUAL_VOLUME" );
1116 void SaveDistribution()
1118 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1119 SALOME_ListIO selected;
1121 aSel->selectedObjects( selected );
1123 if ( selected.Extent() == 1 ) {
1124 Handle(SALOME_InteractiveObject) anIO = selected.First();
1125 if ( anIO->hasEntry() ) {
1126 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1128 anActor->GetScalarBarActor() &&
1129 anActor->GetControlMode() != SMESH_Actor::eNone )
1131 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1132 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1133 if ( aScalarBarActor && aFunctor ) {
1134 SMESH::Controls::NumericalFunctor* aNumFun =
1135 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1137 std::vector<int> elements;
1138 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1139 if ( mesh->_is_nil() ) {
1140 SMESH::SMESH_IDSource_var idSource =
1141 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1142 if ( !idSource->_is_nil() )
1144 SMESH::long_array_var ids = idSource->GetIDs();
1145 elements.resize( ids->length() );
1146 for ( unsigned i = 0; i < elements.size(); ++i )
1147 elements[i] = ids[i];
1150 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1151 vtkLookupTable* lookupTable =
1152 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1153 double * minmax = lookupTable->GetRange();
1154 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1155 std::vector<int> nbEvents;
1156 std::vector<double> funValues;
1157 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1158 elements, minmax, isLogarithmic );
1159 QString anInitialPath = "";
1160 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1161 anInitialPath = QDir::currentPath();
1162 QString aMeshName = anIO->getName();
1164 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1165 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1166 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1167 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1168 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1171 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1173 if ( !aFilename.isEmpty() ) {
1174 QFile f( aFilename );
1175 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1176 QTextStream out( &f );
1177 out << "# Mesh: " << aMeshName << endl;
1178 out << "# Control: " << functorToString( aFunctor ) << endl;
1180 out.setFieldWidth( 10 );
1181 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1182 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1193 void ShowElement( int theCommandID )
1195 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1196 SALOME_ListIO selected;
1198 aSel->selectedObjects( selected );
1200 if ( selected.Extent() == 1 ) {
1201 Handle(SALOME_InteractiveObject) anIO = selected.First();
1202 if ( anIO->hasEntry() ) {
1203 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1205 anActor->GetScalarBarActor() &&
1206 anActor->GetControlMode() != SMESH_Actor::eNone )
1208 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1209 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1210 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1212 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1213 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1220 #ifndef DISABLE_PLOT2DVIEWER
1221 void PlotDistribution()
1223 SalomeApp_Application* app =
1224 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1228 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1229 SALOME_ListIO selected;
1231 aSel->selectedObjects( selected );
1233 if ( selected.Extent() == 1 ) {
1234 Handle(SALOME_InteractiveObject) anIO = selected.First();
1235 if ( anIO->hasEntry() ) {
1236 //Find Actor by entry before getting Plot2d viewer,
1237 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1238 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1240 SUIT_ViewManager* aViewManager =
1241 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1245 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1249 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1253 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1255 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1256 QString functorName = functorToString( anActor->GetFunctor());
1257 QString aHistogramName("%1 : %2");
1258 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1259 aHistogram->setName(aHistogramName);
1260 aHistogram->setHorTitle(functorName);
1261 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1262 aPlot->displayObject(aHistogram, true);
1267 #endif //DISABLE_PLOT2DVIEWER
1269 void DisableAutoColor()
1271 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1272 SALOME_ListIO selected;
1274 aSel->selectedObjects( selected );
1276 if ( selected.Extent() ) {
1277 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1278 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1279 if ( !aMesh->_is_nil() ) {
1280 aMesh->SetAutoColor( false );
1287 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1288 SALOME_ListIO selected;
1290 aSel->selectedObjects( selected );
1291 if ( selected.Extent() )
1293 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1294 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1295 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1297 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1298 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1305 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1307 SALOME_ListIO selected;
1308 SalomeApp_Application* app =
1309 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1313 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1314 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1315 if ( !aSel || !appStudy )
1318 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1319 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1320 aModule->EmitSignalDeactivateDialog();
1321 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1322 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1327 _PTR(Study) aStudy = appStudy->studyDS();
1329 aSel->selectedObjects( selected );
1331 if ( selected.Extent() >= 1 )
1333 switch ( theCommandID ) {
1334 case SMESHOp::OpTransparency:
1336 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1337 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1340 case SMESHOp::OpProperties:
1343 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1344 QColor orientationColor, outlineColor, volumeColor;
1345 int deltaF = 0, deltaV = 0;
1348 double ballScale = 1.0;
1350 int outlineWidth = 1;
1351 double shrinkCoef = 0.0;
1352 double orientationScale = 0.0;
1353 bool orientation3d = false;
1354 VTK::MarkerType markerType = VTK::MT_NONE;
1355 VTK::MarkerScale markerScale = VTK::MS_NONE;
1357 bool hasNodes = false;
1358 int presentEntities = 0;
1359 bool firstTime = true;
1361 SALOME_ListIteratorOfListIO It( selected );
1362 for ( ; It.More(); It.Next() ) {
1363 Handle(SALOME_InteractiveObject) IObject = It.Value();
1364 if ( !IObject->hasEntry() ) continue;
1365 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1366 if ( !anActor || !anActor->GetObject() ) continue;
1369 // nodes: color, marker
1370 anActor->GetNodeColor( color[0], color[1], color[2] );
1371 nodeColor.setRgbF( color[0], color[1], color[2] );
1372 markerType = anActor->GetMarkerType();
1373 markerScale = anActor->GetMarkerScale();
1374 markerId = anActor->GetMarkerTexture();
1375 // edges: color, width
1376 anActor->GetEdgeColor( color[0], color[1], color[2] );
1377 edgeColor.setRgbF( color[0], color[1], color[2] );
1378 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1379 // faces: front color, back color (delta)
1380 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1381 faceColor.setRgbF( color[0], color[1], color[2] );
1382 // faces: front color, back color (delta)
1383 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1384 volumeColor.setRgbF( color[0], color[1], color[2] );
1385 // 0d elements: color, size
1386 anActor->Get0DColor( color[0], color[1], color[2] );
1387 elem0dColor.setRgbF( color[0], color[1], color[2] );
1388 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1389 // balls: color, size
1390 anActor->GetBallColor( color[0], color[1], color[2] );
1391 ballColor.setRgbF( color[0], color[1], color[2] );
1392 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1393 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1395 anActor->GetOutlineColor( color[0], color[1], color[2] );
1396 outlineColor.setRgbF( color[0], color[1], color[2] );
1397 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1398 // orientation vectors: color, scale, 3d flag
1399 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1400 orientationColor.setRgbF( color[0], color[1], color[2] );
1401 orientationScale = anActor->GetFacesOrientationScale();
1402 orientation3d = anActor->GetFacesOrientation3DVectors();
1404 shrinkCoef = anActor->GetShrinkFactor();
1407 firstTime = false; // we only take properties from first object (for performance reasons)
1410 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1411 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1412 presentEntities = presentEntities | SMESH_Actor::eEdges;
1413 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1414 presentEntities = presentEntities | SMESH_Actor::eFaces;
1415 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1416 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1417 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1418 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1419 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1420 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1422 // as we know that all types of elements are present, we can exit the loop
1423 if ( presentEntities == SMESH_Actor::eAllEntity )
1427 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1428 // nodes: color, marker
1429 dlg.setNodeColor( nodeColor );
1430 if( markerType != VTK::MT_USER )
1431 dlg.setNodeMarker( markerType, markerScale );
1433 dlg.setNodeCustomMarker( markerId );
1434 // edges: color, line width
1435 dlg.setEdgeColor( edgeColor );
1436 dlg.setEdgeWidth( edgeWidth );
1437 // faces: front color, back color
1438 dlg.setFaceColor( faceColor, deltaF );
1439 // volumes: normal color, reversed color
1440 dlg.setVolumeColor( volumeColor, deltaV );
1441 // outlines: color, line width
1442 dlg.setOutlineColor( outlineColor );
1443 dlg.setOutlineWidth( outlineWidth );
1444 // 0d elements: color, size
1445 dlg.setElem0dColor( elem0dColor );
1446 dlg.setElem0dSize( elem0dSize );
1447 // balls: color, size
1448 dlg.setBallColor( ballColor );
1449 //dlg.setBallSize( ballSize );
1450 dlg.setBallScale( ballScale );
1451 // orientation: color, scale, 3d flag
1452 dlg.setOrientationColor( orientationColor );
1453 dlg.setOrientationSize( int( orientationScale * 100. ) );
1454 dlg.setOrientation3d( orientation3d );
1455 // shrink: scale factor
1456 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1457 // hide unused controls
1458 dlg.showControls( presentEntities, hasNodes );
1461 nodeColor = dlg.nodeColor();
1462 markerType = dlg.nodeMarkerType();
1463 markerScale = dlg.nodeMarkerScale();
1464 markerId = dlg.nodeMarkerId();
1465 edgeColor = dlg.edgeColor();
1466 edgeWidth = dlg.edgeWidth();
1467 faceColor = dlg.faceColor();
1468 deltaF = dlg.faceColorDelta();
1469 volumeColor = dlg.volumeColor();
1470 deltaV = dlg.volumeColorDelta();
1471 outlineColor = dlg.outlineColor();
1472 outlineWidth = dlg.outlineWidth();
1473 elem0dColor = dlg.elem0dColor();
1474 elem0dSize = dlg.elem0dSize();
1475 ballColor = dlg.ballColor();
1476 // ballSize = dlg.ballSize();
1477 ballScale = dlg.ballScale();
1478 orientationColor = dlg.orientationColor();
1479 orientationScale = dlg.orientationSize() / 100.;
1480 orientation3d = dlg.orientation3d();
1481 shrinkCoef = dlg.shrinkCoef() / 100.;
1483 // store point markers map that might be changed by the user
1484 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1486 // set properties from dialog box to the presentations
1487 SALOME_ListIteratorOfListIO It( selected );
1488 for ( ; It.More(); It.Next() ) {
1489 Handle(SALOME_InteractiveObject) IObject = It.Value();
1490 if ( !IObject->hasEntry() ) continue;
1491 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1492 if ( !anActor ) continue;
1494 // nodes: color, marker
1495 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1496 if ( markerType != VTK::MT_USER ) {
1497 anActor->SetMarkerStd( markerType, markerScale );
1500 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1501 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1502 if ( iter != markerMap.end() )
1503 anActor->SetMarkerTexture( markerId, iter->second.second );
1505 // volumes: normal color, reversed color (delta)
1506 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1507 // faces: front color, back color (delta)
1508 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1509 // edges: color, width
1510 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1511 anActor->SetLineWidth( edgeWidth );
1513 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1514 anActor->SetOutlineWidth( outlineWidth );
1515 // 0D elements: color, size
1516 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1517 anActor->Set0DSize( elem0dSize );
1518 // balls: color, size
1519 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1520 // anActor->SetBallSize( ballSize );
1521 anActor->SetBallScale( ballScale );
1522 // orientation: color, scale, 3d flag
1523 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1524 anActor->SetFacesOrientationScale( orientationScale );
1525 anActor->SetFacesOrientation3DVectors( orientation3d );
1527 anActor->SetShrinkFactor( shrinkCoef );
1529 // for groups, set also proper color
1530 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1531 if ( !aGroupObject->_is_nil() ) {
1532 SMESH::ElementType anElementType = aGroupObject->GetType();
1534 switch( anElementType ) {
1536 aColor = nodeColor; break;
1538 aColor = edgeColor; break;
1540 aColor = faceColor; break;
1542 aColor = volumeColor; break;
1544 aColor = elem0dColor; break;
1546 aColor = ballColor; break;
1550 if ( aColor.isValid() ) {
1551 SALOMEDS::Color aGroupColor;
1552 aGroupColor.R = aColor.redF();
1553 aGroupColor.G = aColor.greenF();
1554 aGroupColor.B = aColor.blueF();
1555 aGroupObject->SetColor( aGroupColor );
1557 } // if ( !aGroupObject->_is_nil() )
1558 } // for ( ; It.More(); It.Next() )
1559 SMESH::RepaintCurrentView();
1560 } // if ( dlg.exec() )
1562 } // case SMESHOp::OpProperties:
1563 } // switch(theCommandID)
1564 SALOME_ListIteratorOfListIO It( selected );
1565 for( ; It.More(); It.Next()){
1566 Handle(SALOME_InteractiveObject) IObject = It.Value();
1567 if(IObject->hasEntry()){
1568 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1569 switch(theCommandID){
1570 case SMESHOp::OpDMWireframe:
1571 anActor->SetRepresentation(SMESH_Actor::eEdge);
1573 case SMESHOp::OpDMShading:
1574 anActor->SetRepresentation(SMESH_Actor::eSurface);
1576 case SMESHOp::OpDMShrink:
1577 if(anActor->IsShrunk())
1578 anActor->UnShrink();
1580 anActor->SetShrink();
1582 case SMESHOp::OpDMNodes:
1583 anActor->SetRepresentation(SMESH_Actor::ePoint);
1585 case SMESHOp::OpRepresentationLines:
1586 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1587 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1589 case SMESHOp::OpRepresentationArcs:
1590 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1591 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1597 SMESH::RepaintCurrentView();
1601 int ActionToControl( int theID, bool theReversed )
1603 NCollection_DoubleMap<int,int> ActionControl;
1604 ActionControl.Bind( 0, SMESH_Actor::eNone );
1605 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1606 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1607 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1608 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1609 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1610 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1611 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1612 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1613 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1614 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1615 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1616 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1617 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1618 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1619 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1620 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1621 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1622 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1623 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1624 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1625 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1626 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1627 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1628 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1629 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1630 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1632 return theReversed ? ActionControl.Find2( theID ) : ActionControl.Find1( theID );
1635 void Control( int theCommandID )
1637 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ) );
1638 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1639 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1640 SALOME_ListIO selected;
1642 aSel->selectedObjects( selected );
1644 if ( !selected.IsEmpty() ) {
1645 SALOME_ListIteratorOfListIO It(selected);
1646 for ( ; It.More(); It.Next())
1648 Handle(SALOME_InteractiveObject) anIO = It.Value();
1650 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1652 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1653 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1654 if ( !anIDSrc->_is_nil() ) {
1655 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry()) ) {
1656 QString functorName = functorToString( anActor->GetFunctor() );
1657 anActor->SetControlMode( aControl );
1658 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1659 SMESH::RepaintCurrentView();
1660 #ifndef DISABLE_PLOT2DVIEWER
1661 if ( anActor->GetPlot2Histogram() ) {
1662 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1663 QString aHistogramName("%1 : %2");
1664 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1665 aHistogram->setName( aHistogramName );
1666 aHistogram->setHorTitle( functorName );
1667 SMESH::ProcessIn2DViewers( anActor );
1679 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1680 SMESH::MeshObjectType theType,
1681 const QString theInTypeName,
1682 QString & theOutTypeName)
1684 SMESH_TypeFilter aTypeFilter( theType );
1686 if ( !theIO.IsNull() )
1688 entry = theIO->getEntry();
1689 LightApp_DataOwner owner( entry );
1690 if ( aTypeFilter.isOk( &owner )) {
1691 theOutTypeName = theInTypeName;
1699 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1701 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1702 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1704 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1705 CORBA::String_var anID = aSComp->GetID().c_str();
1706 if ( !strcmp(anID.in(),theIO->getEntry()) )
1712 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1713 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1714 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1715 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1716 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1724 // QString CheckHomogeneousSelection()
1726 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1727 // SALOME_ListIO selected;
1729 // aSel->selectedObjects( selected );
1731 // QString RefType = CheckTypeObject(selected.First());
1732 // SALOME_ListIteratorOfListIO It(selected);
1733 // for ( ; It.More(); It.Next())
1735 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1736 // QString Type = CheckTypeObject(IObject);
1737 // if ( Type.compare(RefType) != 0 )
1738 // return "Heterogeneous Selection";
1744 uint randomize( uint size )
1746 static bool initialized = false;
1747 if ( !initialized ) {
1748 qsrand( QDateTime::currentDateTime().toTime_t() );
1752 v = uint( (double)( v ) / RAND_MAX * size );
1753 v = qMax( uint(0), qMin ( v, size-1 ) );
1759 void SMESHGUI::OnEditDelete()
1761 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1762 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1763 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1765 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1766 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1767 _PTR(GenericAttribute) anAttr;
1768 _PTR(AttributeIOR) anIOR;
1770 int objectCount = 0;
1772 QString aParentComponent = QString::null;
1773 Handle(SALOME_InteractiveObject) anIO;
1774 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1776 anIO = anIt.Value();
1777 QString cur = anIO->getComponentDataType();
1778 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1780 // check if object is reference
1781 _PTR(SObject) aRefSObj;
1782 aNameList.append("\n - ");
1783 if ( aSO->ReferencedObject( aRefSObj ) ) {
1784 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1785 aNameList.append( aRefName );
1786 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1789 aNameList.append(anIO->getName());
1793 if( aParentComponent.isNull() )
1794 aParentComponent = cur;
1795 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1796 aParentComponent = "";
1799 if ( objectCount == 0 )
1800 return; // No Valid Objects Selected
1802 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1803 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1804 QObject::tr("ERR_ERROR"),
1805 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1808 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1809 if (SUIT_MessageBox::warning
1810 (SMESHGUI::desktop(),
1811 QObject::tr("SMESH_WRN_WARNING"),
1812 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1813 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1814 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1817 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1819 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1820 // then treat them all starting from the deepest objects (at list back)
1821 std::list< _PTR(SObject) > listSO;
1822 SALOME_ListIteratorOfListIO It(selected);
1823 for( ; It.More(); It.Next()) // loop on selected IO's
1825 Handle(SALOME_InteractiveObject) IObject = It.Value();
1826 if(IObject->hasEntry()) {
1827 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1829 // disable removal of "SMESH" component object
1830 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1832 if ( engineIOR() == anIOR->Value().c_str() )
1835 //Check the referenced object
1836 _PTR(SObject) aRefSObject;
1837 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1838 aSO = aRefSObject; // Delete main Object instead of reference
1840 listSO.push_back( aSO );
1841 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1842 for ( ; itSO != listSO.end(); ++itSO ) {
1843 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1844 for (it->InitEx(false); it->More(); it->Next())
1845 listSO.push_back( it->Value() );
1849 // Check if none of objects to delete is referred from outside
1850 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1851 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1853 _PTR(SObject) SO = *ritSO;
1854 if ( !SO ) continue;
1855 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1856 for (size_t i = 0; i < aReferences.size(); i++) {
1857 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1858 std::string type = aComponent->ComponentDataType();
1859 if ( type != "SMESH" )
1861 SUIT_MessageBox::warning( anApp->desktop(),
1862 QObject::tr("WRN_WARNING"),
1863 QObject::tr("DEP_OBJECT") );
1864 return; // outside SMESH, there is an object depending on a SMESH object
1869 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1870 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1872 Handle(SALOME_InteractiveObject) IObject = It.Value();
1873 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1874 if ( !mesh->_is_nil() )
1878 // Treat SO's in the list starting from the back
1879 aStudyBuilder->NewCommand(); // There is a transaction
1880 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1882 _PTR(SObject) SO = *ritSO;
1883 if ( !SO ) continue;
1884 std::string anEntry = SO->GetID();
1886 /** Erase graphical object and remove all its data **/
1887 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1888 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1890 /** Remove an object from data structures **/
1891 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1892 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1893 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1894 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1895 aMesh->RemoveGroup( aGroup );
1897 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1898 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1899 aMesh->RemoveSubMesh( aSubMesh );
1901 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1903 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1906 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1907 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1908 QString objType = CheckTypeObject(IObject);
1909 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1910 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1911 aStudyBuilder->RemoveObjectWithChildren( SO );
1913 else {// default action: remove SObject from the study
1914 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1915 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1917 aStudyBuilder->RemoveObjectWithChildren( SO );
1921 } /* listSO back loop */
1923 aStudyBuilder->CommitCommand();
1925 /* Clear any previous selection */
1927 aSel->setSelectedObjects( l1 );
1929 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1933 SMESHGUI_EXPORT CAM_Module* createModule()
1935 return new SMESHGUI();
1938 SMESHGUI_EXPORT char* getModuleVersion() {
1939 return (char*)SMESH_VERSION_STR;
1943 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1945 //=============================================================================
1949 //=============================================================================
1950 SMESHGUI::SMESHGUI() :
1951 SalomeApp_Module( "SMESH" )
1953 if ( CORBA::is_nil( myComponentSMESH ) )
1955 CORBA::Boolean anIsEmbeddedMode;
1956 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1957 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1959 // 0019923: EDF 765 SMESH : default values of hypothesis
1960 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1961 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1962 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1963 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1964 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1966 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
1967 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1968 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1970 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1971 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1975 myActiveDialogBox = 0;
1976 myFilterLibraryDlg = 0;
1980 myEventCallbackCommand = vtkCallbackCommand::New();
1981 myEventCallbackCommand->Delete();
1982 myEventCallbackCommand->SetClientData( this );
1983 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1986 /* load resources for all available meshers */
1987 SMESH::InitAvailableHypotheses();
1990 //=============================================================================
1994 //=============================================================================
1995 SMESHGUI::~SMESHGUI()
1999 //=============================================================================
2003 //=============================================================================
2004 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2006 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2008 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2013 //=============================================================================
2017 //=============================================================================
2018 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2020 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2024 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2025 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2026 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2027 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2028 return autoUpdate && !exceeded;
2031 //=============================================================================
2035 //=============================================================================
2036 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2037 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2039 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2043 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2044 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2045 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2047 SMESH::long_array_var info = theMesh->GetMeshInfo();
2048 long nbOdElems = info[SMDSEntity_0D];
2049 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2050 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2051 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2052 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2053 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2054 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2055 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2056 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
2057 info[SMDSEntity_Polyhedra] +
2058 info[SMDSEntity_Hexagonal_Prism];
2059 long nbBalls = info[SMDSEntity_Ball];
2061 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2062 *nbElements = requestedSize;
2064 *entities = SMESH_Actor::eAllEntity;
2067 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2069 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2071 if ( incrementalLimit ) {
2074 if ( nbOdElems > 0 ) {
2075 if ( total + nbOdElems > updateLimit ) {
2076 *entities = *entities & ~SMESH_Actor::e0DElements;
2077 *hidden = *hidden | SMESH_Actor::e0DElements;
2084 if ( nbEdges > 0 ) {
2085 if ( total + nbEdges > updateLimit ) {
2086 *entities = *entities & ~SMESH_Actor::eEdges;
2087 *hidden = *hidden | SMESH_Actor::eEdges;
2094 if ( nbFaces > 0 ) {
2095 if ( total + nbFaces > updateLimit ) {
2096 *entities = *entities & ~SMESH_Actor::eFaces;
2097 *hidden = *hidden | SMESH_Actor::eFaces;
2104 if ( nbVolumes > 0 ) {
2105 if ( total + nbVolumes > updateLimit ) {
2106 *entities = *entities & ~SMESH_Actor::eVolumes;
2107 *hidden = *hidden | SMESH_Actor::eVolumes;
2114 if ( nbBalls > 0 ) {
2115 if ( total + nbBalls > updateLimit ) {
2116 *entities = *entities & ~SMESH_Actor::eBallElem;
2117 *hidden = *hidden | SMESH_Actor::eBallElem;
2125 return autoUpdate && !exceeded;
2128 //=============================================================================
2132 //=============================================================================
2133 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2135 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2138 //=============================================================================
2142 //=============================================================================
2143 SMESHGUI* SMESHGUI::GetSMESHGUI()
2145 SMESHGUI* smeshMod = 0;
2146 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2149 CAM_Module* module = app->module( "Mesh" );
2150 smeshMod = dynamic_cast<SMESHGUI*>( module );
2153 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2155 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2158 _PTR(Study) aStudy = study->studyDS();
2160 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2169 Standard_EXPORT SMESHGUI* GetComponentGUI()
2171 return SMESHGUI::GetSMESHGUI();
2175 //=============================================================================
2179 //=============================================================================
2180 void SMESHGUI::SetState(int aState)
2185 //=============================================================================
2189 //=============================================================================
2190 void SMESHGUI::ResetState()
2195 //=============================================================================
2199 //=============================================================================
2200 void SMESHGUI::EmitSignalDeactivateDialog()
2202 emit SignalDeactivateActiveDialog();
2205 //=============================================================================
2209 //=============================================================================
2210 void SMESHGUI::EmitSignalStudyFrameChanged()
2212 emit SignalStudyFrameChanged();
2215 //=============================================================================
2219 //=============================================================================
2220 void SMESHGUI::EmitSignalCloseAllDialogs()
2222 emit SignalCloseAllDialogs();
2225 //=============================================================================
2229 //=============================================================================
2230 void SMESHGUI::EmitSignalVisibilityChanged()
2232 emit SignalVisibilityChanged();
2235 //=============================================================================
2239 //=============================================================================
2240 void SMESHGUI::EmitSignalCloseView()
2242 emit SignalCloseView();
2245 //=============================================================================
2249 //=============================================================================
2250 void SMESHGUI::EmitSignalActivatedViewManager()
2252 emit SignalActivatedViewManager();
2255 //=============================================================================
2259 //=============================================================================
2260 QDialog *SMESHGUI::GetActiveDialogBox()
2262 return myActiveDialogBox;
2265 //=============================================================================
2269 //=============================================================================
2270 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2272 myActiveDialogBox = (QDialog *) aDlg;
2276 //=============================================================================
2280 //=============================================================================
2281 SUIT_Desktop* SMESHGUI::desktop()
2283 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2285 return app->desktop();
2290 //=============================================================================
2294 //=============================================================================
2295 SalomeApp_Study* SMESHGUI::activeStudy()
2297 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2299 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2304 //=============================================================================
2308 //=============================================================================
2309 void SMESHGUI::Modified( bool theIsUpdateActions )
2311 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2312 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2313 appStudy->Modified();
2314 if( theIsUpdateActions )
2315 app->updateActions();
2320 //=============================================================================
2324 //=============================================================================
2325 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2327 /* Here the position is on the bottom right corner - 10 */
2328 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2330 SUIT_Desktop *PP = desktop();
2331 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2332 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2336 //=============================================================================
2340 //=============================================================================
2341 static int isStudyLocked(_PTR(Study) theStudy){
2342 return theStudy->GetProperties()->IsLocked();
2345 static bool checkLock(_PTR(Study) theStudy) {
2346 if (isStudyLocked(theStudy)) {
2347 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2348 QObject::tr("WRN_WARNING"),
2349 QObject::tr("WRN_STUDY_LOCKED") );
2355 //=======================================================================
2356 //function : CheckActiveStudyLocked
2358 //=======================================================================
2360 bool SMESHGUI::isActiveStudyLocked()
2362 _PTR(Study) aStudy = activeStudy()->studyDS();
2363 return checkLock( aStudy );
2366 //=============================================================================
2370 //=============================================================================
2371 bool SMESHGUI::OnGUIEvent( int theCommandID )
2373 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2377 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2378 SUIT_ResourceMgr* mgr = resourceMgr();
2382 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2383 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2386 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2387 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2389 //QAction* act = action( theCommandID );
2391 switch (theCommandID) {
2392 case SMESHOp::OpDelete:
2393 if(checkLock(aStudy)) break;
2396 case SMESHOp::OpImportDAT:
2397 case SMESHOp::OpImportUNV:
2398 case SMESHOp::OpImportMED:
2399 case SMESHOp::OpImportSTL:
2401 case SMESHOp::OpImportCGNS:
2403 case SMESHOp::OpImportSAUV:
2404 case SMESHOp::OpImportGMF:
2406 if(checkLock(aStudy)) break;
2407 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2411 case SMESHOp::OpFileInformation:
2413 SALOME_ListIO selected;
2414 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2416 aSel->selectedObjects( selected );
2417 if( selected.Extent() )
2419 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2420 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2421 if ( !aMesh->_is_nil() )
2423 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2429 case SMESHOp::OpExportDAT:
2430 case SMESHOp::OpExportMED:
2431 case SMESHOp::OpExportUNV:
2432 case SMESHOp::OpExportSTL:
2434 case SMESHOp::OpExportCGNS:
2436 case SMESHOp::OpExportSAUV:
2437 case SMESHOp::OpExportGMF:
2438 case SMESHOp::OpPopupExportDAT:
2439 case SMESHOp::OpPopupExportMED:
2440 case SMESHOp::OpPopupExportUNV:
2441 case SMESHOp::OpPopupExportSTL:
2443 case SMESHOp::OpPopupExportCGNS:
2445 case SMESHOp::OpPopupExportSAUV:
2446 case SMESHOp::OpPopupExportGMF:
2448 ::ExportMeshToFile(theCommandID);
2452 case SMESHOp::OpReset: // SCALAR BAR
2454 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2455 SALOME_ListIO selected;
2457 aSel->selectedObjects( selected );
2459 SALOME_ListIteratorOfListIO it(selected);
2460 for( ; it.More(); it.Next()) {
2461 Handle(SALOME_InteractiveObject) anIO = it.Value();
2462 if( anIO->hasEntry() ) {
2463 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2464 anActor->SetControlMode( SMESH_Actor::eNone );
2465 #ifndef DISABLE_PLOT2DVIEWER
2466 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2471 SMESH::UpdateView();
2474 case SMESHOp::OpScalarBarProperties:
2476 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2479 case SMESHOp::OpShowScalarBar:
2481 // show/hide scalar bar
2482 ::ShowElement(theCommandID);
2485 case SMESHOp::OpSaveDistribution:
2487 // dump control distribution data to the text file
2488 ::SaveDistribution();
2492 case SMESHOp::OpShowDistribution:
2494 // show/hide distribution
2495 ::ShowElement(theCommandID);
2499 #ifndef DISABLE_PLOT2DVIEWER
2500 case SMESHOp::OpPlotDistribution:
2502 // plot distribution
2503 ::PlotDistribution();
2509 case SMESHOp::OpAutoColor:
2513 case SMESHOp::OpDisableAutoColor:
2514 ::DisableAutoColor();
2517 case SMESHOp::OpClipping:
2518 case SMESHOp::OpTransparency:
2519 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2522 case SMESHOp::OpDMWireframe:
2523 case SMESHOp::OpDMShading:
2524 case SMESHOp::OpDMNodes:
2525 case SMESHOp::OpDMShrink:
2526 ::SetDisplayMode(theCommandID, myMarkerMap);
2529 //2D quadratic representation
2530 case SMESHOp::OpRepresentationLines:
2531 case SMESHOp::OpRepresentationArcs:
2532 ::SetDisplayMode(theCommandID, myMarkerMap);
2536 case SMESHOp::OpDE0DElements:
2537 case SMESHOp::OpDEEdges:
2538 case SMESHOp::OpDEFaces:
2539 case SMESHOp::OpDEVolumes:
2540 case SMESHOp::OpDEBalls:
2541 case SMESHOp::OpDEAllEntity:
2542 ::SetDisplayEntity(theCommandID);
2545 // Choose entities to be displayed
2546 case SMESHOp::OpDEChoose:
2548 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2552 case SMESHOp::OpOrientationOnFaces:
2554 LightApp_SelectionMgr* mgr = selectionMgr();
2555 SALOME_ListIO selected; mgr->selectedObjects( selected );
2557 SALOME_ListIteratorOfListIO it(selected);
2558 for( ; it.More(); it.Next()) {
2559 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2560 if(anIObject->hasEntry()) {
2561 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2562 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2569 case SMESHOp::OpUpdate:
2571 if(checkLock(aStudy)) break;
2572 SUIT_OverrideCursor wc;
2574 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2577 SMESH::UpdateView();
2579 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2580 SMESH::OnVisuException();
2582 catch (...) { // PAL16774 (Crash after display of many groups)
2583 SMESH::OnVisuException();
2587 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2588 aSel->selectedObjects( l );
2589 aSel->setSelectedObjects( l );
2593 case SMESHOp::OpHide:
2594 case SMESHOp::OpShow:
2595 case SMESHOp::OpShowOnly:
2597 SUIT_OverrideCursor wc;
2598 SMESH::EDisplaing anAction;
2599 switch (theCommandID) {
2600 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2601 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2602 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2605 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2606 SALOME_ListIO sel_objects, to_process;
2608 aSel->selectedObjects( sel_objects );
2610 if ( theCommandID==SMESHOp::OpShowOnly )
2612 //MESSAGE("anAction = SMESH::eDisplayOnly");
2613 startOperation( myEraseAll );
2616 extractContainers( sel_objects, to_process );
2619 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2623 SALOME_ListIteratorOfListIO It( to_process );
2624 for ( ; It.More(); It.Next())
2626 Handle(SALOME_InteractiveObject) IOS = It.Value();
2627 if ( IOS->hasEntry() )
2629 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2630 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2631 break; // PAL16774 (Crash after display of many groups)
2633 if (anAction == SMESH::eDisplayOnly)
2634 anAction = SMESH::eDisplay;
2639 // PAL13338 + PAL15161 -->
2640 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2641 SMESH::UpdateView();
2642 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2644 // PAL13338 + PAL15161 <--
2646 catch (...) { // PAL16774 (Crash after display of many groups)
2647 SMESH::OnVisuException();
2650 if (anAction == SMESH::eErase) {
2652 aSel->setSelectedObjects( l1 );
2655 aSel->setSelectedObjects( to_process );
2660 case SMESHOp::OpNode:
2662 if(checkLock(aStudy)) break;
2665 EmitSignalDeactivateDialog();
2667 ( new SMESHGUI_NodesDlg( this ) )->show();
2670 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2675 case SMESHOp::OpCreateMesh:
2676 case SMESHOp::OpCreateSubMesh:
2677 case SMESHOp::OpEditMeshOrSubMesh:
2678 case SMESHOp::OpCompute:
2679 case SMESHOp::OpPreCompute:
2680 case SMESHOp::OpEvaluate:
2681 case SMESHOp::OpMeshOrder:
2682 startOperation( theCommandID );
2684 case SMESHOp::OpCopyMesh:
2686 if (checkLock(aStudy)) break;
2687 EmitSignalDeactivateDialog();
2688 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2691 case SMESHOp::OpBuildCompoundMesh:
2693 if (checkLock(aStudy)) break;
2694 EmitSignalDeactivateDialog();
2695 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2699 case SMESHOp::OpDiagonalInversion:
2700 case SMESHOp::OpUnionOfTwoTriangle:
2704 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2708 if ( checkLock( aStudy ) )
2711 /*Standard_Boolean aRes;
2712 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2713 if ( aMesh->_is_nil() )
2715 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2716 tr( "SMESH_BAD_SELECTION" ) );
2720 EmitSignalDeactivateDialog();
2721 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2722 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2724 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2727 case SMESHOp::OpOrientation:
2728 case SMESHOp::OpUnionOfTriangles:
2729 case SMESHOp::OpCuttingOfQuadrangles:
2730 case SMESHOp::OpSplitVolumes:
2734 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2738 if ( checkLock( aStudy ) )
2741 EmitSignalDeactivateDialog();
2742 SMESHGUI_MultiEditDlg* aDlg = NULL;
2743 if ( theCommandID == SMESHOp::OpOrientation )
2744 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2745 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2746 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2747 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2748 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2750 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2755 case SMESHOp::OpSmoothing:
2757 if(checkLock(aStudy)) break;
2759 EmitSignalDeactivateDialog();
2760 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2763 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2767 case SMESHOp::OpExtrusion:
2769 if (checkLock(aStudy)) break;
2771 EmitSignalDeactivateDialog();
2772 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2774 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2778 case SMESHOp::OpExtrusionAlongAPath:
2780 if (checkLock(aStudy)) break;
2782 EmitSignalDeactivateDialog();
2783 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2785 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2789 case SMESHOp::OpRevolution:
2791 if(checkLock(aStudy)) break;
2793 EmitSignalDeactivateDialog();
2794 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2797 SUIT_MessageBox::warning(desktop(),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(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2815 case SMESHOp::OpSplitBiQuadratic:
2816 case SMESHOp::OpConvertMeshToQuadratic:
2817 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2818 case SMESHOp::OpReorientFaces:
2819 case SMESHOp::OpCreateGeometryGroup:
2821 startOperation( theCommandID );
2824 case SMESHOp::OpCreateGroup:
2828 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2832 if(checkLock(aStudy)) break;
2833 EmitSignalDeactivateDialog();
2834 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2836 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2837 SALOME_ListIO selected;
2839 aSel->selectedObjects( selected );
2841 int nbSel = selected.Extent();
2843 // check if mesh is selected
2844 aMesh = SMESH::GetMeshByIO( selected.First() );
2846 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2851 case SMESHOp::OpConstructGroup:
2855 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2859 if(checkLock(aStudy)) break;
2860 EmitSignalDeactivateDialog();
2862 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2863 SALOME_ListIO selected;
2865 aSel->selectedObjects( selected );
2867 int nbSel = selected.Extent();
2869 // check if submesh is selected
2870 Handle(SALOME_InteractiveObject) IObject = selected.First();
2871 if (IObject->hasEntry()) {
2872 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2874 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2875 if (!aSubMesh->_is_nil()) {
2877 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2878 // get submesh elements list by types
2879 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2880 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2881 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2882 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2883 // create group for each type o elements
2884 QString aName = IObject->getName();
2885 QStringList anEntryList;
2886 if (aNodes->length() > 0) {
2887 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2888 aGroup->Add(aNodes.inout());
2889 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2890 anEntryList.append( aSObject->GetID().c_str() );
2892 if (aEdges->length() > 0) {
2893 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2894 aGroup->Add(aEdges.inout());
2895 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2896 anEntryList.append( aSObject->GetID().c_str() );
2898 if (aFaces->length() > 0) {
2899 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2900 aGroup->Add(aFaces.inout());
2901 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2902 anEntryList.append( aSObject->GetID().c_str() );
2904 if (aVolumes->length() > 0) {
2905 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2906 aGroup->Add(aVolumes.inout());
2907 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2908 anEntryList.append( aSObject->GetID().c_str() );
2911 anApp->browseObjects( anEntryList );
2913 catch(const SALOME::SALOME_Exception & S_ex){
2914 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2921 SUIT_MessageBox::warning(desktop(),
2922 tr("SMESH_WRN_WARNING"),
2923 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2928 case SMESHOp::OpEditGroup:
2932 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2936 if(checkLock(aStudy)) break;
2937 EmitSignalDeactivateDialog();
2939 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2940 SALOME_ListIO selected;
2942 aSel->selectedObjects( selected );
2944 SALOME_ListIteratorOfListIO It (selected);
2945 int nbSelectedGroups = 0;
2946 for ( ; It.More(); It.Next() )
2948 SMESH::SMESH_GroupBase_var aGroup =
2949 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2950 if (!aGroup->_is_nil()) {
2952 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2956 if (nbSelectedGroups == 0)
2958 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2964 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
2966 if(checkLock(aStudy)) break;
2967 if (myState == 800) {
2968 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2969 if (aDlg) aDlg->onAdd();
2974 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
2976 if(checkLock(aStudy)) break;
2977 if (myState == 800) {
2978 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2979 if (aDlg) aDlg->onRemove();
2984 case SMESHOp::OpEditGeomGroupAsGroup:
2988 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2992 if(checkLock(aStudy)) break;
2993 EmitSignalDeactivateDialog();
2995 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2996 SALOME_ListIO selected;
2998 aSel->selectedObjects( selected );
3000 SALOME_ListIteratorOfListIO It (selected);
3001 for ( ; It.More(); It.Next() )
3003 SMESH::SMESH_GroupOnGeom_var aGroup =
3004 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3005 if (!aGroup->_is_nil()) {
3006 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3011 SMESH::SMESH_GroupOnFilter_var aGroup =
3012 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3013 if (!aGroup->_is_nil()) {
3014 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3022 case SMESHOp::OpUnionGroups:
3023 case SMESHOp::OpIntersectGroups:
3024 case SMESHOp::OpCutGroups:
3028 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3032 if ( checkLock( aStudy ) )
3035 EmitSignalDeactivateDialog();
3037 SMESHGUI_GroupOpDlg* aDlg = 0;
3038 if ( theCommandID == SMESHOp::OpUnionGroups )
3039 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3040 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3041 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3043 aDlg = new SMESHGUI_CutGroupsDlg( this );
3050 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3052 if ( checkLock( aStudy ) )
3055 EmitSignalDeactivateDialog();
3056 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3062 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3066 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3070 if ( checkLock( aStudy ) )
3073 EmitSignalDeactivateDialog();
3075 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3079 case SMESHOp::OpMeshInformation:
3080 case SMESHOp::OpWhatIs:
3082 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3083 EmitSignalDeactivateDialog();
3084 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3085 SALOME_ListIO selected;
3087 aSel->selectedObjects( selected );
3089 if ( selected.Extent() > 1 ) { // a dlg for each IO
3090 SALOME_ListIteratorOfListIO It( selected );
3091 for ( ; It.More(); It.Next() ) {
3092 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3093 dlg->showInfo( It.Value() );
3098 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3104 case SMESHOp::OpFindElementByPoint:
3106 startOperation( theCommandID );
3110 case SMESHOp::OpEditHypothesis:
3112 if(checkLock(aStudy)) break;
3114 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3115 SALOME_ListIO selected;
3117 aSel->selectedObjects( selected );
3119 int nbSel = selected.Extent();
3122 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3123 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3125 if ( !aHypothesis->_is_nil() )
3127 SMESHGUI_GenericHypothesisCreator* aCreator =
3128 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3131 // set geometry of mesh and sub-mesh to aCreator
3132 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3133 if ( selected.Extent() == 1 )
3135 QString subGeomID, meshGeomID;
3136 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3137 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3139 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3140 aCreator->setShapeEntry( subGeomID );
3141 aCreator->setMainShapeEntry( meshGeomID );
3145 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3155 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3157 if(checkLock(aStudy)) break;
3158 SUIT_OverrideCursor wc;
3160 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3161 SALOME_ListIO selected;
3163 aSel->selectedObjects( selected, QString::null, false );
3165 SALOME_ListIteratorOfListIO It(selected);
3166 for (int i = 0; It.More(); It.Next(), i++) {
3167 Handle(SALOME_InteractiveObject) IObject = It.Value();
3168 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3171 aSel->setSelectedObjects( l1 );
3176 case SMESHOp::OpElem0D:
3177 case SMESHOp::OpBall:
3178 case SMESHOp::OpEdge:
3179 case SMESHOp::OpTriangle:
3180 case SMESHOp::OpQuadrangle:
3181 case SMESHOp::OpPolygon:
3182 case SMESHOp::OpTetrahedron:
3183 case SMESHOp::OpHexahedron:
3184 case SMESHOp::OpPentahedron:
3185 case SMESHOp::OpPyramid:
3186 case SMESHOp::OpHexagonalPrism:
3188 if(checkLock(aStudy)) break;
3190 EmitSignalDeactivateDialog();
3191 SMDSAbs_EntityType type = SMDSEntity_Edge;
3192 switch (theCommandID) {
3193 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3194 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3195 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3196 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3197 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3198 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3199 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3200 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3201 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3202 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3205 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3208 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3212 case SMESHOp::OpPolyhedron:
3214 if(checkLock(aStudy)) break;
3216 EmitSignalDeactivateDialog();
3217 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3220 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3224 case SMESHOp::OpQuadraticEdge:
3225 case SMESHOp::OpQuadraticTriangle:
3226 case SMESHOp::OpBiQuadraticTriangle:
3227 case SMESHOp::OpQuadraticQuadrangle:
3228 case SMESHOp::OpBiQuadraticQuadrangle:
3229 case SMESHOp::OpQuadraticPolygon:
3230 case SMESHOp::OpQuadraticTetrahedron:
3231 case SMESHOp::OpQuadraticPyramid:
3232 case SMESHOp::OpQuadraticPentahedron:
3233 case SMESHOp::OpQuadraticHexahedron:
3234 case SMESHOp::OpTriQuadraticHexahedron:
3236 if(checkLock(aStudy)) break;
3238 EmitSignalDeactivateDialog();
3239 SMDSAbs_EntityType type = SMDSEntity_Last;
3241 switch (theCommandID) {
3242 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3243 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3244 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3245 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3246 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3247 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3248 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3249 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3250 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3251 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3252 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3255 if ( type != SMDSEntity_Last )
3256 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3259 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3260 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3264 case SMESHOp::OpRemoveNodes:
3266 if(checkLock(aStudy)) break;
3268 EmitSignalDeactivateDialog();
3269 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3272 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3273 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3277 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3279 if(checkLock(aStudy)) break;
3281 EmitSignalDeactivateDialog();
3282 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3286 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3287 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3291 case SMESHOp::OpClearMesh: {
3293 if(checkLock(aStudy)) break;
3295 SALOME_ListIO selected;
3296 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3297 aSel->selectedObjects( selected );
3299 SUIT_OverrideCursor wc;
3300 SALOME_ListIteratorOfListIO It (selected);
3301 for ( ; It.More(); It.Next() )
3303 Handle(SALOME_InteractiveObject) IOS = It.Value();
3304 SMESH::SMESH_Mesh_var aMesh =
3305 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3306 if ( aMesh->_is_nil()) continue;
3308 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3310 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3311 SMESH::ModifiedMesh( aMeshSObj, false, true);
3312 // hide groups and submeshes
3313 _PTR(ChildIterator) anIter =
3314 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3315 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3317 _PTR(SObject) so = anIter->Value();
3318 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3321 catch (const SALOME::SALOME_Exception& S_ex){
3323 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3327 SMESH::UpdateView();
3331 case SMESHOp::OpRemoveOrphanNodes:
3333 if(checkLock(aStudy)) break;
3334 SALOME_ListIO selected;
3335 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3336 aSel->selectedObjects( selected );
3337 if ( selected.Extent() == 1 ) {
3338 Handle(SALOME_InteractiveObject) anIO = selected.First();
3339 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3340 if ( !aMesh->_is_nil() ) {
3341 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3342 tr( "SMESH_WARNING" ),
3343 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3344 SUIT_MessageBox::Yes |
3345 SUIT_MessageBox::No,
3346 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3349 SUIT_OverrideCursor wc;
3350 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3351 int removed = aMeshEditor->RemoveOrphanNodes();
3352 SUIT_MessageBox::information(SMESHGUI::desktop(),
3353 tr("SMESH_INFORMATION"),
3354 tr("NB_NODES_REMOVED").arg(removed));
3355 if ( removed > 0 ) {
3356 SMESH::UpdateView();
3357 SMESHGUI::Modified();
3360 catch (const SALOME::SALOME_Exception& S_ex) {
3361 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3370 case SMESHOp::OpRenumberingNodes:
3372 if(checkLock(aStudy)) break;
3374 EmitSignalDeactivateDialog();
3375 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3379 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3380 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3384 case SMESHOp::OpRenumberingElements:
3386 if(checkLock(aStudy)) break;
3388 EmitSignalDeactivateDialog();
3389 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3393 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3394 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3398 case SMESHOp::OpTranslation:
3400 if(checkLock(aStudy)) break;
3402 EmitSignalDeactivateDialog();
3403 ( new SMESHGUI_TranslationDlg( this ) )->show();
3406 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3407 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3411 case SMESHOp::OpRotation:
3413 if(checkLock(aStudy)) break;
3415 EmitSignalDeactivateDialog();
3416 ( new SMESHGUI_RotationDlg( this ) )->show();
3419 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3420 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3424 case SMESHOp::OpSymmetry:
3426 if(checkLock(aStudy)) break;
3428 EmitSignalDeactivateDialog();
3429 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3432 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3433 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3437 case SMESHOp::OpScale:
3439 if(checkLock(aStudy)) break;
3441 EmitSignalDeactivateDialog();
3442 ( new SMESHGUI_ScaleDlg( this ) )->show();
3445 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3446 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3451 case SMESHOp::OpSewing:
3453 if(checkLock(aStudy)) break;
3455 EmitSignalDeactivateDialog();
3456 ( new SMESHGUI_SewingDlg( this ) )->show();
3459 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3460 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3464 case SMESHOp::OpMergeNodes:
3466 if(checkLock(aStudy)) break;
3468 EmitSignalDeactivateDialog();
3469 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3472 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3473 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3477 case SMESHOp::OpMergeElements:
3479 if (checkLock(aStudy)) break;
3481 EmitSignalDeactivateDialog();
3482 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3484 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3485 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3490 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3491 startOperation( SMESHOp::OpMoveNode );
3494 case SMESHOp::OpDuplicateNodes:
3496 if(checkLock(aStudy)) break;
3498 EmitSignalDeactivateDialog();
3499 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3502 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3503 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3508 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3509 startOperation( SMESHOp::OpElem0DOnElemNodes );
3512 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3514 static QList<int> aTypes;
3515 if ( aTypes.isEmpty() )
3517 aTypes.append( SMESH::NODE );
3518 aTypes.append( SMESH::EDGE );
3519 aTypes.append( SMESH::FACE );
3520 aTypes.append( SMESH::VOLUME );
3522 if (!myFilterLibraryDlg)
3523 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3524 else if (myFilterLibraryDlg->isHidden())
3525 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3526 myFilterLibraryDlg->raise();
3530 case SMESHOp::OpFreeNode:
3531 case SMESHOp::OpEqualNode:
3532 case SMESHOp::OpFreeEdge:
3533 case SMESHOp::OpFreeBorder:
3534 case SMESHOp::OpLength:
3535 case SMESHOp::OpConnection:
3536 case SMESHOp::OpEqualEdge:
3537 case SMESHOp::OpFreeFace:
3538 case SMESHOp::OpBareBorderFace:
3539 case SMESHOp::OpOverConstrainedFace:
3540 case SMESHOp::OpLength2D:
3541 case SMESHOp::OpConnection2D:
3542 case SMESHOp::OpArea:
3543 case SMESHOp::OpTaper:
3544 case SMESHOp::OpAspectRatio:
3545 case SMESHOp::OpMinimumAngle:
3546 case SMESHOp::OpWarpingAngle:
3547 case SMESHOp::OpSkew:
3548 case SMESHOp::OpMaxElementLength2D:
3549 case SMESHOp::OpEqualFace:
3550 case SMESHOp::OpAspectRatio3D:
3551 case SMESHOp::OpVolume:
3552 case SMESHOp::OpMaxElementLength3D:
3553 case SMESHOp::OpBareBorderVolume:
3554 case SMESHOp::OpOverConstrainedVolume:
3555 case SMESHOp::OpEqualVolume:
3558 LightApp_SelectionMgr* mgr = selectionMgr();
3559 SALOME_ListIO selected; mgr->selectedObjects( selected );
3561 if( !selected.IsEmpty() ) {
3562 SUIT_OverrideCursor wc;
3563 ::Control( theCommandID );
3566 SUIT_MessageBox::warning(desktop(),
3567 tr( "SMESH_WRN_WARNING" ),
3568 tr( "SMESH_BAD_SELECTION" ) );
3572 SUIT_MessageBox::warning(desktop(),
3573 tr( "SMESH_WRN_WARNING" ),
3574 tr( "NOT_A_VTK_VIEWER" ) );
3577 case SMESHOp::OpOverallMeshQuality:
3578 OverallMeshQuality();
3580 case SMESHOp::OpNumberingNodes:
3582 SUIT_OverrideCursor wc;
3583 LightApp_SelectionMgr* mgr = selectionMgr();
3584 SALOME_ListIO selected; mgr->selectedObjects( selected );
3586 SALOME_ListIteratorOfListIO it(selected);
3587 for( ; it.More(); it.Next()) {
3588 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3589 if(anIObject->hasEntry()) {
3590 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3591 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3597 case SMESHOp::OpNumberingElements:
3599 SUIT_OverrideCursor wc;
3600 LightApp_SelectionMgr* mgr = selectionMgr();
3601 SALOME_ListIO selected; mgr->selectedObjects( selected );
3603 SALOME_ListIteratorOfListIO it(selected);
3604 for( ; it.More(); it.Next()) {
3605 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3606 if(anIObject->hasEntry())
3607 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3608 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3613 case SMESHOp::OpPropertiesLength:
3614 case SMESHOp::OpPropertiesArea:
3615 case SMESHOp::OpPropertiesVolume:
3616 case SMESHOp::OpMinimumDistance:
3617 case SMESHOp::OpBoundingBox:
3619 int page = SMESHGUI_MeasureDlg::MinDistance;
3620 if ( theCommandID == SMESHOp::OpBoundingBox )
3621 page = SMESHGUI_MeasureDlg::BoundingBox;
3622 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3623 page = SMESHGUI_MeasureDlg::Length;
3624 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3625 page = SMESHGUI_MeasureDlg::Area;
3626 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3627 page = SMESHGUI_MeasureDlg::Volume;
3629 EmitSignalDeactivateDialog();
3630 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3634 case SMESHOp::OpSortChild:
3640 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3641 //updateObjBrowser();
3645 //=============================================================================
3649 //=============================================================================
3650 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3655 //=============================================================================
3659 //=============================================================================
3660 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3665 //=============================================================================
3669 //=============================================================================
3670 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3675 //=============================================================================
3676 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3677 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3679 //=============================================================================
3680 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3681 SUIT_ViewWindow* wnd )
3683 if(theIO->hasEntry()){
3684 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3685 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3689 //=======================================================================
3690 // function : createSMESHAction
3692 //=======================================================================
3693 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3694 const int key, const bool toggle, const QString& shortcutAction )
3697 QWidget* parent = application()->desktop();
3698 SUIT_ResourceMgr* resMgr = resourceMgr();
3700 if ( !icon_id.isEmpty() )
3701 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3703 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3704 if ( !pix.isNull() )
3705 icon = QIcon( pix );
3707 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3708 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3709 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3711 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3712 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3715 //=======================================================================
3716 // function : createPopupItem
3718 //=======================================================================
3719 void SMESHGUI::createPopupItem( const int id,
3720 const QString& clients,
3721 const QString& types,
3722 const QString& theRule,
3725 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3726 popupMgr()->insert( action( id ), pId, 0 );
3728 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3729 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3730 QString rule = "(%1) and (%2) and (%3)";
3731 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3732 if( clients.isEmpty() )
3733 rule = rule.arg( QString( "true" ) );
3735 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3736 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3739 bool cont = myRules.contains( id );
3741 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3743 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3744 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3747 //=======================================================================
3748 // function : initialize
3750 //=======================================================================
3751 void SMESHGUI::initialize( CAM_Application* app )
3753 SalomeApp_Module::initialize( app );
3755 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3757 /* Automatic Update flag */
3758 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3760 // ----- create actions --------------
3762 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3763 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3764 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3765 //createSMESHAction( 114, "NUM" );
3766 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3768 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3770 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3771 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3772 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3773 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3774 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3775 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3777 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3779 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3780 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3781 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3782 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3783 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3784 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3786 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3788 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3789 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3790 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3791 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3792 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3793 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3794 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3795 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3796 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3797 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3798 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3799 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3800 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3801 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3802 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3803 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3804 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3805 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3806 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3807 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3808 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3809 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3810 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3811 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3812 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3813 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3814 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3815 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3816 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3817 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3819 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3820 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3821 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3822 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3823 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3824 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3825 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3826 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3827 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3828 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3829 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3830 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3831 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3832 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3833 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3834 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3835 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3836 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3837 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3838 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3839 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3840 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3841 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3842 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3843 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3844 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3845 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3847 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3848 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3849 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3850 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3851 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3852 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3853 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3854 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3855 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3856 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3857 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3858 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3859 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3860 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3861 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3862 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3863 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3864 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3865 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3866 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3867 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3868 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3869 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3870 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3871 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3873 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3874 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3875 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3876 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3878 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3879 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3881 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3882 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3883 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3884 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3885 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3886 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3887 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3888 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3889 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3890 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3891 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3892 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3893 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3894 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3895 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3896 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3897 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3898 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3899 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3900 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3901 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3902 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3903 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3904 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3906 createSMESHAction( SMESHOp::OpReset, "RESET" );
3907 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3908 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
3909 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3910 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3911 #ifndef DISABLE_PLOT2DVIEWER
3912 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3914 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3915 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3916 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3917 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3918 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3919 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3920 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3921 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3922 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3923 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3924 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
3925 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
3926 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3928 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3929 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3931 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3932 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3933 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3934 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3935 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3936 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3937 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3938 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3939 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3941 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3942 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3943 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3944 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3945 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
3947 createSMESHAction( SMESHOp::OpHide, "HIDE" );
3948 createSMESHAction( SMESHOp::OpShow, "SHOW" );
3949 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
3951 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
3953 QList<int> aCtrlActions;
3954 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode // node controls
3955 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
3956 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
3957 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
3958 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
3959 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
3960 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
3961 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
3962 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
3963 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
3964 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
3965 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
3966 aCtrlGroup->setExclusive( true );
3967 for( int i = 0; i < aCtrlActions.size(); i++ )
3968 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
3970 // ----- create menu --------------
3971 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3972 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3973 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3974 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3975 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3976 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3977 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3978 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3980 createMenu( separator(), fileId );
3982 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
3983 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
3984 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3985 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3986 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
3987 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
3988 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
3989 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
3990 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3991 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3992 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3993 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
3994 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
3996 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
3997 createMenu( SMESHOp::OpImportUNV, importId, -1 );
3998 createMenu( SMESHOp::OpImportMED, importId, -1 );
3999 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4001 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4003 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4004 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4005 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4006 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4007 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4008 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4010 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4012 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4013 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4014 createMenu( separator(), fileId, 10 );
4016 createMenu( SMESHOp::OpDelete, editId, -1 );
4018 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4020 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4021 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4022 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4023 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4024 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4025 createMenu( separator(), meshId, -1 );
4026 createMenu( SMESHOp::OpCompute, meshId, -1 );
4027 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4028 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4029 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4030 createMenu( separator(), meshId, -1 );
4031 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4032 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4033 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4034 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4035 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4036 createMenu( separator(), meshId, -1 );
4037 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4038 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4039 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4040 createMenu( separator(), meshId, -1 );
4041 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4042 createMenu( separator(), meshId, -1 );
4043 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4044 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4045 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4046 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4047 createMenu( separator(), meshId, -1 );
4049 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4050 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4051 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4052 createMenu( SMESHOp::OpLength, edgeId, -1 );
4053 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4054 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4055 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4056 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4057 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4058 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4059 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4060 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4061 createMenu( SMESHOp::OpArea, faceId, -1 );
4062 createMenu( SMESHOp::OpTaper, faceId, -1 );
4063 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4064 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4065 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4066 createMenu( SMESHOp::OpSkew, faceId, -1 );
4067 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4068 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4069 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4070 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4071 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4072 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4073 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4074 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4075 createMenu( separator(), ctrlId, -1 );
4076 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4077 createMenu( separator(), ctrlId, -1 );
4078 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4080 createMenu( SMESHOp::OpNode, addId, -1 );
4081 createMenu( SMESHOp::OpElem0D, addId, -1 );
4082 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4083 createMenu( SMESHOp::OpBall, addId, -1 );
4084 createMenu( SMESHOp::OpEdge, addId, -1 );
4085 createMenu( SMESHOp::OpTriangle, addId, -1 );
4086 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4087 createMenu( SMESHOp::OpPolygon, addId, -1 );
4088 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4089 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4090 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4091 createMenu( SMESHOp::OpPyramid, addId, -1 );
4092 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4093 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4094 createMenu( separator(), addId, -1 );
4095 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4096 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4097 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4098 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4099 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4100 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4101 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4102 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4103 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4104 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4105 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4107 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4108 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4109 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4110 createMenu( separator(), removeId, -1 );
4111 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4112 createMenu( separator(), removeId, -1 );
4113 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4115 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4116 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4118 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4119 createMenu( SMESHOp::OpRotation, transfId, -1 );
4120 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4121 createMenu( SMESHOp::OpScale, transfId, -1 );
4122 createMenu( SMESHOp::OpSewing, transfId, -1 );
4123 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4124 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4125 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4127 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4128 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4129 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4130 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4131 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4132 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4133 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4134 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4135 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4136 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4137 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4138 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4139 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4140 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4141 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4142 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4144 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4145 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4146 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4147 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4148 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4149 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4151 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4152 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4153 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4154 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4156 // ----- create toolbars --------------
4157 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4158 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4159 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4160 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4161 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4162 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4163 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4164 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4165 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4166 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4167 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4168 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4169 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4170 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4171 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4173 createTool( SMESHOp::OpCreateMesh, meshTb );
4174 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4175 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4176 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4177 createTool( SMESHOp::OpCopyMesh, meshTb );
4178 createTool( separator(), meshTb );
4179 createTool( SMESHOp::OpCompute, meshTb );
4180 createTool( SMESHOp::OpPreCompute, meshTb );
4181 createTool( SMESHOp::OpEvaluate, meshTb );
4182 createTool( SMESHOp::OpMeshOrder, meshTb );
4184 createTool( SMESHOp::OpCreateGroup, groupTb );
4185 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4186 createTool( SMESHOp::OpConstructGroup, groupTb );
4187 createTool( SMESHOp::OpEditGroup, groupTb );
4189 createTool( SMESHOp::OpMeshInformation, info );
4190 //createTool( SMESHOp::OpStdInfo, meshTb );
4191 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4192 createTool( SMESHOp::OpFindElementByPoint, info );
4194 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4195 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4197 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4198 createTool( SMESHOp::OpLength, ctrl1dTb );
4199 createTool( SMESHOp::OpConnection, ctrl1dTb );
4200 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4202 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4203 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4204 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4205 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4206 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4207 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4208 createTool( SMESHOp::OpArea, ctrl2dTb );
4209 createTool( SMESHOp::OpTaper, ctrl2dTb );
4210 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4211 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4212 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4213 createTool( SMESHOp::OpSkew, ctrl2dTb );
4214 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4215 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4217 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4218 createTool( SMESHOp::OpVolume, ctrl3dTb );
4219 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4220 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4221 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4222 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4224 createTool( SMESHOp::OpNode, addElemTb );
4225 createTool( SMESHOp::OpElem0D, addElemTb );
4226 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4227 createTool( SMESHOp::OpBall, addElemTb );
4228 createTool( SMESHOp::OpEdge, addElemTb );
4229 createTool( SMESHOp::OpTriangle, addElemTb );
4230 createTool( SMESHOp::OpQuadrangle, addElemTb );
4231 createTool( SMESHOp::OpPolygon, addElemTb );
4232 createTool( SMESHOp::OpTetrahedron, addElemTb );
4233 createTool( SMESHOp::OpHexahedron, addElemTb );
4234 createTool( SMESHOp::OpPentahedron, addElemTb );
4235 createTool( SMESHOp::OpPyramid, addElemTb );
4236 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4237 createTool( SMESHOp::OpPolyhedron, addElemTb );
4239 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4240 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4241 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4242 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4243 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4244 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4245 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4246 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4247 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4248 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4249 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4251 createTool( SMESHOp::OpRemoveNodes, remTb );
4252 createTool( SMESHOp::OpRemoveElements, remTb );
4253 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4254 createTool( SMESHOp::OpClearMesh, remTb );
4256 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4257 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4259 createTool( SMESHOp::OpTranslation, transformTb );
4260 createTool( SMESHOp::OpRotation, transformTb );
4261 createTool( SMESHOp::OpSymmetry, transformTb );
4262 createTool( SMESHOp::OpScale, transformTb );
4263 createTool( SMESHOp::OpSewing, transformTb );
4264 createTool( SMESHOp::OpMergeNodes, transformTb );
4265 createTool( SMESHOp::OpMergeElements, transformTb );
4266 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4268 createTool( SMESHOp::OpMoveNode, modifyTb );
4269 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4270 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4271 createTool( SMESHOp::OpOrientation, modifyTb );
4272 createTool( SMESHOp::OpReorientFaces, modifyTb );
4273 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4274 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4275 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4276 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4277 createTool( SMESHOp::OpSmoothing, modifyTb );
4278 createTool( SMESHOp::OpExtrusion, modifyTb );
4279 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4280 createTool( SMESHOp::OpRevolution, modifyTb );
4281 createTool( SMESHOp::OpPatternMapping, modifyTb );
4282 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4283 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4285 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4287 createTool( SMESHOp::OpUpdate, dispModeTb );
4289 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4290 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4293 QString OB = "'ObjectBrowser'",
4294 View = "'" + SVTK_Viewer::Type() + "'",
4296 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4297 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4298 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4299 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4300 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4301 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4302 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4303 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4304 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4305 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4306 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4308 mesh_part = mesh + " " + subMesh + " " + group,
4309 mesh_group = mesh + " " + group,
4310 hyp_alg = hypo + " " + algo;
4312 // popup for object browser
4314 isInvisible("not( isVisible )"),
4315 isEmpty("numberOfNodes = 0"),
4316 isNotEmpty("numberOfNodes <> 0"),
4318 // has nodes, edges, etc in VISIBLE! actor
4319 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4320 hasElems("(count( elemTypes ) > 0)"),
4321 hasDifferentElems("(count( elemTypes ) > 1)"),
4322 hasBalls("({'BallElem'} in elemTypes)"),
4323 hasElems0d("({'Elem0d'} in elemTypes)"),
4324 hasEdges("({'Edge'} in elemTypes)"),
4325 hasFaces("({'Face'} in elemTypes)"),
4326 hasVolumes("({'Volume'} in elemTypes)"),
4327 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4329 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4330 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4331 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, mesh );
4332 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, subMesh, "&& hasGeomReference" );
4333 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4334 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4336 popupMgr()->insert( separator(), -1, 0 );
4337 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& isComputable" );
4338 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& isPreComputable" );
4339 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& isComputable" );
4340 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& isComputable && hasGeomReference" );
4341 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4342 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4343 createPopupItem( SMESHOp::OpFindElementByPoint, OB, mesh_group );
4344 createPopupItem( SMESHOp::OpOverallMeshQuality, OB, mesh_part );
4345 popupMgr()->insert( separator(), -1, 0 );
4346 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh );
4347 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& hasGeomReference" );
4348 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4349 popupMgr()->insert( separator(), -1, 0 );
4350 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4351 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4352 popupMgr()->insert( separator(), -1, 0 );
4353 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh + " " + subMesh ); // convert to quadratic
4354 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh + " " + group, // create 2D mesh from 3D
4356 popupMgr()->insert( separator(), -1, 0 );
4357 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4358 popupMgr()->insert( separator(), -1, 0 );
4360 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4361 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4362 QString only_one_2D = only_one_non_empty + " && dim>1";
4364 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4365 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4366 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4367 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4369 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4371 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4372 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4373 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4374 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4375 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4376 popupMgr()->insert( separator(), -1, 0 );
4379 createPopupItem( SMESHOp::OpEditGroup, View, group );
4380 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4381 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4383 popupMgr()->insert( separator(), -1, 0 );
4384 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4385 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4386 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4387 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4388 popupMgr()->insert( separator(), -1, 0 );
4390 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4391 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4392 popupMgr()->insert( separator(), -1, 0 );
4394 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4395 QString aType = QString( "%1type in {%2}" ).arg( lc );
4396 aType = aType.arg( mesh_part );
4397 QString aMeshInVTK = aClient + "&&" + aType;
4399 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4400 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4401 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4403 //-------------------------------------------------
4405 //-------------------------------------------------
4406 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4408 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4409 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4410 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4412 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4413 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4414 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4416 popupMgr()->insert( separator(), -1, -1 );
4418 //-------------------------------------------------
4420 //-------------------------------------------------
4421 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4423 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4424 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4425 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4427 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4428 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4429 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4431 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4432 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4433 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4435 popupMgr()->insert( separator(), anId, -1 );
4437 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4438 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4439 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4441 //-------------------------------------------------
4443 //-------------------------------------------------
4444 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4446 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4448 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4449 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4450 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4452 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4453 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4454 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4456 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4457 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4458 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4460 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4461 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4462 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4464 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4465 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4466 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4468 popupMgr()->insert( separator(), anId, -1 );
4470 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4471 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4473 popupMgr()->insert( separator(), anId, -1 );
4475 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4476 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4479 //-------------------------------------------------
4480 // Representation of the 2D Quadratic elements
4481 //-------------------------------------------------
4482 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4483 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4484 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4485 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4487 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4488 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4489 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4491 //-------------------------------------------------
4492 // Orientation of faces
4493 //-------------------------------------------------
4494 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4495 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4496 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4498 //-------------------------------------------------
4500 //-------------------------------------------------
4501 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4502 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4504 //-------------------------------------------------
4506 //-------------------------------------------------
4507 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4508 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4510 //-------------------------------------------------
4512 //-------------------------------------------------
4514 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4515 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4516 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4517 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4519 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4521 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4522 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4524 popupMgr()->insert( separator(), anId, -1 );
4526 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4528 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4529 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4530 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4532 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4533 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4534 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4536 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4538 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4539 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4540 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4542 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4543 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4544 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4546 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4547 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4548 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4549 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4550 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4551 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4553 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4555 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4556 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4557 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4559 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4560 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4561 QtxPopupMgr::VisibleRule );
4562 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4564 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4565 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4566 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4568 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4569 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4570 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4572 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4573 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4574 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4576 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4577 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4578 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4580 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4581 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4582 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4584 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4585 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4586 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4588 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4589 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4590 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4592 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4593 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4594 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4596 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4597 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4598 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4600 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4601 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4602 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4604 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4605 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4606 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4607 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4608 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4609 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4611 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4613 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4614 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4615 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4617 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4618 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4619 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4621 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4622 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4623 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4625 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4626 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4627 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4629 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4630 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4631 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4633 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4634 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4635 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4637 popupMgr()->insert( separator(), anId, -1 );
4639 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4640 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4641 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4642 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4643 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4645 popupMgr()->insert( separator(), anId, -1 );
4647 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4649 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4650 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4652 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4653 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4654 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4656 #ifndef DISABLE_PLOT2DVIEWER
4657 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4658 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4661 //-------------------------------------------------
4663 //-------------------------------------------------
4664 popupMgr()->insert( separator(), -1, -1 );
4665 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4666 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4667 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4668 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4670 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4671 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4673 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4674 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4676 popupMgr()->insert( separator(), -1, -1 );
4678 //-------------------------------------------------
4680 //-------------------------------------------------
4681 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4682 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4684 popupMgr()->insert( separator(), -1, -1 );
4686 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4687 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4688 popupMgr()->insert( separator(), -1, -1 );
4690 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4691 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4693 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4694 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4697 //================================================================================
4699 * \brief Return true if SMESH or GEOM objects are selected.
4700 * Is called form LightApp_Module::activateModule() which clear selection if
4701 * not isSelectionCompatible()
4703 //================================================================================
4705 bool SMESHGUI::isSelectionCompatible()
4707 bool isCompatible = true;
4708 SALOME_ListIO selected;
4709 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4710 Sel->selectedObjects( selected );
4712 SALOME_ListIteratorOfListIO It( selected );
4713 for ( ; isCompatible && It.More(); It.Next())
4715 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4716 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4718 return isCompatible;
4722 bool SMESHGUI::reusableOperation( const int id )
4724 // compute, evaluate and precompute are not reusable operations
4725 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4728 bool SMESHGUI::activateModule( SUIT_Study* study )
4730 bool res = SalomeApp_Module::activateModule( study );
4732 setMenuShown( true );
4733 setToolShown( true );
4735 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4736 PyGILState_STATE gstate = PyGILState_Ensure();
4737 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4738 if ( !pluginsmanager ) {
4742 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4747 PyGILState_Release(gstate);
4748 // end of SMESH plugins loading
4750 // Reset actions accelerator keys
4751 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4753 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4754 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4755 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4756 if ( _PTR(Study) aStudy = s->studyDS() )
4757 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4760 // get all view currently opened in the study and connect their signals to
4761 // the corresponding slots of the class.
4762 SUIT_Desktop* aDesk = study->application()->desktop();
4764 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4765 SUIT_ViewWindow* wnd;
4766 foreach ( wnd, wndList )
4770 Py_XDECREF(pluginsmanager);
4774 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4776 setMenuShown( false );
4777 setToolShown( false );
4779 EmitSignalCloseAllDialogs();
4781 // Unset actions accelerator keys
4782 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4784 return SalomeApp_Module::deactivateModule( study );
4787 void SMESHGUI::studyClosed( SUIT_Study* s )
4791 SMESH::RemoveVisuData( s->id() );
4792 SalomeApp_Module::studyClosed( s );
4795 void SMESHGUI::OnGUIEvent()
4797 const QObject* obj = sender();
4798 if ( !obj || !obj->inherits( "QAction" ) )
4800 int id = actionId((QAction*)obj);
4805 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4807 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4808 if ( CORBA::is_nil( myComponentSMESH ) )
4810 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4812 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4813 return aGUI.myComponentSMESH;
4816 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4817 return myComponentSMESH;
4820 QString SMESHGUI::engineIOR() const
4822 CORBA::ORB_var anORB = getApp()->orb();
4823 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4824 return QString( anIOR.in() );
4827 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4829 SalomeApp_Module::contextMenuPopup( client, menu, title );
4831 selectionMgr()->selectedObjects( lst );
4832 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4833 Handle(SALOME_InteractiveObject) io = lst.First();
4834 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4835 _PTR(Study) study = appStudy->studyDS();
4836 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4838 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4839 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4840 aName.remove( (aName.length() - 1), 1 );
4846 LightApp_Selection* SMESHGUI::createSelection() const
4848 return new SMESHGUI_Selection();
4851 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4853 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4854 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4855 #ifndef DISABLE_PYCONSOLE
4856 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4860 void SMESHGUI::viewManagers( QStringList& list ) const
4862 list.append( SVTK_Viewer::Type() );
4865 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4867 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4868 SMESH::UpdateSelectionProp( this );
4870 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4871 for(int i = 0; i < aViews.count() ; i++){
4872 SUIT_ViewWindow *sf = aViews[i];
4875 EmitSignalActivatedViewManager();
4879 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4881 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4882 myClippingPlaneInfoMap.erase( theViewManager );
4885 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4887 theActor->AddObserver( SMESH::DeleteActorEvent,
4888 myEventCallbackCommand.GetPointer(),
4892 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4893 unsigned long theEvent,
4894 void* theClientData,
4897 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4898 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
4899 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4900 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4901 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4902 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4903 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4904 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4905 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4906 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4907 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4908 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4909 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4910 if( anActor == *anIter3 ) {
4911 anActorList.erase( anIter3 );
4922 void SMESHGUI::createPreferences()
4924 // General tab ------------------------------------------------------------------------
4925 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4927 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4928 setPreferenceProperty( autoUpdate, "columns", 2 );
4929 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4930 setPreferenceProperty( lim, "min", 0 );
4931 setPreferenceProperty( lim, "max", 100000000 );
4932 setPreferenceProperty( lim, "step", 1000 );
4933 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4934 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4936 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4937 setPreferenceProperty( qaGroup, "columns", 2 );
4938 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4939 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4940 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4941 setPreferenceProperty( prec, "min", 0 );
4942 setPreferenceProperty( prec, "max", 100 );
4943 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4944 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4945 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4946 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4947 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4949 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
4950 setPreferenceProperty( dispgroup, "columns", 2 );
4951 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4953 modes.append( tr("MEN_WIRE") );
4954 modes.append( tr("MEN_SHADE") );
4955 modes.append( tr("MEN_NODES") );
4956 modes.append( tr("MEN_SHRINK") );
4957 QList<QVariant> indices;
4958 indices.append( 0 );
4959 indices.append( 1 );
4960 indices.append( 2 );
4961 indices.append( 3 );
4962 setPreferenceProperty( dispmode, "strings", modes );
4963 setPreferenceProperty( dispmode, "indexes", indices );
4965 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
4966 setPreferenceProperty( arcgroup, "columns", 2 );
4967 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4968 QStringList quadraticModes;
4969 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4970 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4972 indices.append( 0 );
4973 indices.append( 1 );
4974 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4975 setPreferenceProperty( quadraticmode, "indexes", indices );
4977 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4978 "SMESH", "max_angle" );
4979 setPreferenceProperty( maxAngle, "min", 1 );
4980 setPreferenceProperty( maxAngle, "max", 90 );
4984 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4985 setPreferenceProperty( exportgroup, "columns", 2 );
4986 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4987 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4989 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4990 setPreferenceProperty( computeGroup, "columns", 2 );
4991 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4993 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4994 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4995 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4997 indices.append( 0 );
4998 indices.append( 1 );
4999 indices.append( 2 );
5000 setPreferenceProperty( notifyMode, "strings", modes );
5001 setPreferenceProperty( notifyMode, "indexes", indices );
5003 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5004 setPreferenceProperty( infoGroup, "columns", 2 );
5005 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5007 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5008 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5010 indices.append( 0 );
5011 indices.append( 1 );
5012 setPreferenceProperty( elemInfo, "strings", modes );
5013 setPreferenceProperty( elemInfo, "indexes", indices );
5014 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5015 setPreferenceProperty( nodesLim, "min", 0 );
5016 setPreferenceProperty( nodesLim, "max", 10000000 );
5017 setPreferenceProperty( nodesLim, "step", 10000 );
5018 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5019 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5020 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5021 setPreferenceProperty( ctrlLim, "min", 0 );
5022 setPreferenceProperty( ctrlLim, "max", 10000000 );
5023 setPreferenceProperty( ctrlLim, "step", 1000 );
5024 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5025 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5026 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5027 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5028 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5030 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5031 setPreferenceProperty( segGroup, "columns", 2 );
5032 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5033 "SMESH", "segmentation" );
5034 setPreferenceProperty( segLen, "min", 1 );
5035 setPreferenceProperty( segLen, "max", 10000000 );
5036 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5037 "SMESH", "nb_segments_per_edge" );
5038 setPreferenceProperty( nbSeg, "min", 1 );
5039 setPreferenceProperty( nbSeg, "max", 10000000 );
5041 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5042 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5043 "SMESH", "forget_mesh_on_hyp_modif" );
5046 // Quantities with individual precision settings
5047 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5048 setPreferenceProperty( precGroup, "columns", 2 );
5050 const int nbQuantities = 6;
5051 int precs[nbQuantities], ii = 0;
5052 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5053 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5054 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5055 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5056 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5057 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5058 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5059 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5060 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5061 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5062 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5063 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5065 // Set property for precision value for spinboxes
5066 for ( ii = 0; ii < nbQuantities; ii++ ){
5067 setPreferenceProperty( precs[ii], "min", -14 );
5068 setPreferenceProperty( precs[ii], "max", 14 );
5069 setPreferenceProperty( precs[ii], "precision", 2 );
5072 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5073 setPreferenceProperty( previewGroup, "columns", 2 );
5074 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5075 setPreferenceProperty( chunkSize, "min", 1 );
5076 setPreferenceProperty( chunkSize, "max", 1000 );
5077 setPreferenceProperty( chunkSize, "step", 50 );
5079 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5080 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5082 // Mesh tab ------------------------------------------------------------------------
5083 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5084 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5085 setPreferenceProperty( nodeGroup, "columns", 3 );
5087 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5089 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5091 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5092 QList<QVariant> aMarkerTypeIndicesList;
5093 QList<QVariant> aMarkerTypeIconsList;
5094 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5095 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5096 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5097 aMarkerTypeIndicesList << i;
5098 aMarkerTypeIconsList << pixmap;
5100 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5101 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5103 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5105 QList<QVariant> aMarkerScaleIndicesList;
5106 QStringList aMarkerScaleValuesList;
5107 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5108 aMarkerScaleIndicesList << i;
5109 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5110 aMarkerScaleValuesList << QString::number( i );
5112 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5113 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5115 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5116 //setPreferenceProperty( elemGroup, "columns", 2 );
5118 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5119 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5120 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5121 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5122 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5123 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5124 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5125 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5126 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5129 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5130 setPreferenceProperty( grpGroup, "columns", 2 );
5132 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5133 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5135 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5136 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5137 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5138 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5139 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5140 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5141 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5142 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5143 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5144 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5145 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5146 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5147 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5148 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5150 setPreferenceProperty( size0d, "min", 1 );
5151 setPreferenceProperty( size0d, "max", 10 );
5153 // setPreferenceProperty( ballSize, "min", 1 );
5154 // setPreferenceProperty( ballSize, "max", 10 );
5156 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5157 setPreferenceProperty( ballDiameter, "max", 1e9 );
5158 setPreferenceProperty( ballDiameter, "step", 0.1 );
5160 setPreferenceProperty( ballScale, "min", 1e-2 );
5161 setPreferenceProperty( ballScale, "max", 1e7 );
5162 setPreferenceProperty( ballScale, "step", 0.5 );
5164 setPreferenceProperty( elemW, "min", 1 );
5165 setPreferenceProperty( elemW, "max", 5 );
5167 setPreferenceProperty( outW, "min", 1 );
5168 setPreferenceProperty( outW, "max", 5 );
5170 setPreferenceProperty( shrink, "min", 0 );
5171 setPreferenceProperty( shrink, "max", 100 );
5173 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5174 setPreferenceProperty( numGroup, "columns", 2 );
5176 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5177 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5179 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5180 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5182 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5183 setPreferenceProperty( orientGroup, "columns", 1 );
5185 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5186 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5188 setPreferenceProperty( orientScale, "min", 0.05 );
5189 setPreferenceProperty( orientScale, "max", 0.5 );
5190 setPreferenceProperty( orientScale, "step", 0.05 );
5192 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5194 // Selection tab ------------------------------------------------------------------------
5195 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5197 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5198 setPreferenceProperty( selGroup, "columns", 2 );
5200 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5201 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5203 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5204 setPreferenceProperty( preGroup, "columns", 2 );
5206 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5208 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5209 setPreferenceProperty( precSelGroup, "columns", 2 );
5211 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5212 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5213 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5215 // Scalar Bar tab ------------------------------------------------------------------------
5216 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5217 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5218 setPreferenceProperty( fontGr, "columns", 2 );
5220 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5221 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5223 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5224 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5226 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5227 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5229 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5230 setPreferenceProperty( numcol, "min", 2 );
5231 setPreferenceProperty( numcol, "max", 256 );
5233 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5234 setPreferenceProperty( numlab, "min", 2 );
5235 setPreferenceProperty( numlab, "max", 65 );
5237 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5238 setPreferenceProperty( orientGr, "columns", 2 );
5239 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5240 QStringList orients;
5241 orients.append( tr( "SMESH_VERTICAL" ) );
5242 orients.append( tr( "SMESH_HORIZONTAL" ) );
5243 indices.clear(); indices.append( 0 ); indices.append( 1 );
5244 setPreferenceProperty( orient, "strings", orients );
5245 setPreferenceProperty( orient, "indexes", indices );
5247 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5248 setPreferenceProperty( posVSizeGr, "columns", 2 );
5249 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5250 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5251 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5252 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5253 setPreferenceProperty( xv, "step", 0.1 );
5254 setPreferenceProperty( xv, "min", 0.0 );
5255 setPreferenceProperty( xv, "max", 1.0 );
5256 setPreferenceProperty( yv, "step", 0.1 );
5257 setPreferenceProperty( yv, "min", 0.0 );
5258 setPreferenceProperty( yv, "max", 1.0 );
5259 setPreferenceProperty( wv, "step", 0.1 );
5260 setPreferenceProperty( wv, "min", 0.0 );
5261 setPreferenceProperty( wv, "max", 1.0 );
5262 setPreferenceProperty( hv, "min", 0.0 );
5263 setPreferenceProperty( hv, "max", 1.0 );
5264 setPreferenceProperty( hv, "step", 0.1 );
5266 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5267 setPreferenceProperty( posHSizeGr, "columns", 2 );
5268 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5269 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5270 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5271 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5272 setPreferenceProperty( xv, "min", 0.0 );
5273 setPreferenceProperty( xv, "max", 1.0 );
5274 setPreferenceProperty( xv, "step", 0.1 );
5275 setPreferenceProperty( xh, "min", 0.0 );
5276 setPreferenceProperty( xh, "max", 1.0 );
5277 setPreferenceProperty( xh, "step", 0.1 );
5278 setPreferenceProperty( yh, "min", 0.0 );
5279 setPreferenceProperty( yh, "max", 1.0 );
5280 setPreferenceProperty( yh, "step", 0.1 );
5281 setPreferenceProperty( wh, "min", 0.0 );
5282 setPreferenceProperty( wh, "max", 1.0 );
5283 setPreferenceProperty( wh, "step", 0.1 );
5284 setPreferenceProperty( hh, "min", 0.0 );
5285 setPreferenceProperty( hh, "max", 1.0 );
5286 setPreferenceProperty( hh, "step", 0.1 );
5288 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5289 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5290 setPreferenceProperty( distributionGr, "columns", 3 );
5292 types.append( tr( "SMESH_MONOCOLOR" ) );
5293 types.append( tr( "SMESH_MULTICOLOR" ) );
5294 indices.clear(); indices.append( 0 ); indices.append( 1 );
5295 setPreferenceProperty( coloringType, "strings", types );
5296 setPreferenceProperty( coloringType, "indexes", indices );
5297 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5301 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5303 if ( sect=="SMESH" ) {
5304 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5305 float aTol = 1.00000009999999;
5306 std::string aWarning;
5307 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5309 if ( name== "selection_object_color" ||
5310 name=="selection_element_color" ||
5311 name== "highlight_color" ||
5312 name=="selection_precision_node" ||
5313 name=="selection_precision_element" ||
5314 name=="selection_precision_object" )
5316 SMESH::UpdateSelectionProp( this );
5318 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5320 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5321 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5322 if ( sbX1+sbW > aTol ) {
5323 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5326 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5327 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5330 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5332 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5333 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5334 if ( sbY1 + sbH > aTol ) {
5335 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5336 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5337 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5340 else if (name == "scalar_bar_horizontal_x" || name == "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 == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5354 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5355 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5356 if ( sbY1 + sbH > aTol ) {
5357 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5360 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5361 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5364 else if ( name == "segmentation" )
5366 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5367 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5369 else if ( name == "nb_segments_per_edge" )
5371 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5372 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5374 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5376 QString val = aResourceMgr->stringValue( "SMESH", name );
5377 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5379 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5381 SMESH::UpdateFontProp( this );
5383 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5385 SMESH::UpdateFontProp( this );
5388 if ( aWarning.size() != 0 ) {
5389 aWarning += "The default values are applied instead.";
5390 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5391 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5392 QObject::tr(aWarning.c_str()));
5397 //================================================================================
5399 * \brief Update something in accordance with update flags
5400 * \param theFlags - update flags
5402 * Update viewer or/and object browser etc. in accordance with update flags ( see
5403 * LightApp_UpdateFlags enumeration ).
5405 //================================================================================
5406 void SMESHGUI::update( const int flags )
5408 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5409 SMESH::UpdateView();
5411 SalomeApp_Module::update( flags );
5414 //================================================================================
5416 * \brief Set default selection mode
5418 * SLOT called when operation commited. Sets default selection mode
5420 //================================================================================
5421 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5423 SVTK_ViewWindow* vtkWnd =
5424 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5426 vtkWnd->SetSelectionMode( ActorSelection );
5429 //================================================================================
5431 * \brief Set default selection mode
5433 * SLOT called when operation aborted. Sets default selection mode
5435 //================================================================================
5436 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5438 SVTK_ViewWindow* vtkWnd =
5439 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5441 vtkWnd->SetSelectionMode( ActorSelection );
5444 //================================================================================
5446 * \brief Creates operation with given identifier
5447 * \param id - identifier of operation to be started
5448 * \return Pointer on created operation or NULL if operation is not created
5450 * Virtual method redefined from the base class creates operation with given id.
5451 * It is called called automatically from startOperation method of base class.
5453 //================================================================================
5454 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5456 LightApp_Operation* op = 0;
5457 // to do : create operation here
5460 case SMESHOp::OpSplitBiQuadratic:
5461 op = new SMESHGUI_SplitBiQuadOp();
5463 case SMESHOp::OpConvertMeshToQuadratic:
5464 op = new SMESHGUI_ConvToQuadOp();
5466 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5467 op = new SMESHGUI_Make2DFrom3DOp();
5469 case SMESHOp::OpReorientFaces:
5470 op = new SMESHGUI_ReorientFacesOp();
5472 case SMESHOp::OpCreateMesh:
5473 op = new SMESHGUI_MeshOp( true, true );
5475 case SMESHOp::OpCreateSubMesh:
5476 op = new SMESHGUI_MeshOp( true, false );
5478 case SMESHOp::OpEditMeshOrSubMesh:
5479 op = new SMESHGUI_MeshOp( false );
5481 case SMESHOp::OpCompute:
5482 op = new SMESHGUI_ComputeOp();
5484 case SMESHOp::OpPreCompute:
5485 op = new SMESHGUI_PrecomputeOp();
5487 case SMESHOp::OpEvaluate:
5488 op = new SMESHGUI_EvaluateOp();
5490 case SMESHOp::OpMeshOrder:
5491 op = new SMESHGUI_MeshOrderOp();
5493 case SMESHOp::OpCreateGeometryGroup:
5494 op = new SMESHGUI_GroupOnShapeOp();
5496 case SMESHOp::OpFindElementByPoint:
5497 op = new SMESHGUI_FindElemByPointOp();
5499 case SMESHOp::OpMoveNode: // Make mesh pass through point
5500 op = new SMESHGUI_MakeNodeAtPointOp();
5502 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5503 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5510 op = SalomeApp_Module::createOperation( id );
5514 //================================================================================
5516 * \brief Stops current operations and starts a given one
5517 * \param id - The id of the operation to start
5519 //================================================================================
5521 void SMESHGUI::switchToOperation(int id)
5523 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5524 activeStudy()->abortAllOperations();
5525 startOperation( id );
5528 LightApp_Displayer* SMESHGUI::displayer()
5531 myDisplayer = new SMESHGUI_Displayer( getApp() );
5535 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5538 int aTolerance = 64;
5539 int anIterations = 0;
5545 if( anIterations % aPeriod == 0 )
5548 if( aTolerance < 1 )
5552 aHue = (int)( 360.0 * rand() / RAND_MAX );
5555 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5556 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5557 for( ; it != itEnd; ++it )
5559 SALOMEDS::Color anAutoColor = *it;
5560 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5563 aQColor.getHsv( &h, &s, &v );
5564 if( abs( h - aHue ) < aTolerance )
5576 aColor.setHsv( aHue, 255, 255 );
5578 SALOMEDS::Color aSColor;
5579 aSColor.R = aColor.redF();
5580 aSColor.G = aColor.greenF();
5581 aSColor.B = aColor.blueF();
5586 const char* gSeparator = "_"; // character used to separate parameter names
5587 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5588 const char* gPathSep = "|"; // character used to separate paths
5591 * \brief Store visual parameters
5593 * This method is called just before the study document is saved.
5594 * Store visual parameters in AttributeParameter attribue(s)
5596 void SMESHGUI::storeVisualParameters (int savePoint)
5599 Kernel_Utils::Localizer loc;
5601 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5602 if (!appStudy || !appStudy->studyDS())
5604 _PTR(Study) studyDS = appStudy->studyDS();
5606 // componentName is used for encoding of entries when storing them in IParameters
5607 std::string componentName = myComponentSMESH->ComponentDataType();
5608 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5609 //if (!aSComponent) return;
5612 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5613 componentName.c_str(),
5615 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5617 // store map of custom markers
5618 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5619 if( !aMarkerMap.empty() )
5621 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5622 for( ; anIter != aMarkerMap.end(); anIter++ )
5624 int anId = anIter->first;
5625 VTK::MarkerData aMarkerData = anIter->second;
5626 std::string aMarkerFileName = aMarkerData.first;
5627 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5628 if( aMarkerTexture.size() < 3 )
5629 continue; // should contain at least width, height and the first value
5631 QString aPropertyName( "texture" );
5632 aPropertyName += gSeparator;
5633 aPropertyName += QString::number( anId );
5635 QString aPropertyValue = aMarkerFileName.c_str();
5636 aPropertyValue += gPathSep;
5638 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5639 ushort aWidth = *aTextureIter++;
5640 ushort aHeight = *aTextureIter++;
5641 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5642 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5643 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5644 aPropertyValue += QString::number( *aTextureIter );
5646 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5650 // viewers counters are used for storing view_numbers in IParameters
5653 // main cycle to store parameters of displayed objects
5654 QList<SUIT_ViewManager*> lst;
5655 QList<SUIT_ViewManager*>::Iterator it;
5656 getApp()->viewManagers(lst);
5657 for (it = lst.begin(); it != lst.end(); it++)
5659 SUIT_ViewManager* vman = *it;
5660 QString vType = vman->getType();
5662 // saving VTK actors properties
5663 if (vType == SVTK_Viewer::Type())
5665 // store the clipping planes attached to the view manager
5666 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5667 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5668 if( anIter != myClippingPlaneInfoMap.end() )
5669 aClippingPlaneInfoList = anIter->second;
5671 if( !aClippingPlaneInfoList.empty() ) {
5672 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5673 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5675 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5676 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5678 QString aPropertyName( "ClippingPlane" );
5679 aPropertyName += gSeparator;
5680 aPropertyName += QString::number( vtkViewers );
5681 aPropertyName += gSeparator;
5682 aPropertyName += QString::number( anId );
5684 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5685 aPropertyValue += gDigitsSep;
5686 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5687 aPropertyValue += gDigitsSep;
5688 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5689 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5690 aPropertyValue += gDigitsSep;
5691 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5692 aPropertyValue += gDigitsSep;
5693 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5694 aPropertyValue += gDigitsSep;
5695 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5696 aPropertyValue += gDigitsSep;
5697 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5698 aPropertyValue += gDigitsSep;
5699 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5700 aPropertyValue += gDigitsSep;
5701 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5703 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5704 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5705 aPropertyValue += gDigitsSep;
5706 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5707 aPropertyValue += gDigitsSep;
5708 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5709 aPropertyValue += gDigitsSep;
5710 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5713 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5717 QVector<SUIT_ViewWindow*> views = vman->getViews();
5718 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5720 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5722 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5723 vtkActorCollection* allActors = aCopy.GetActors();
5724 allActors->InitTraversal();
5725 while (vtkActor* actor = allActors->GetNextActor())
5727 if (actor->GetVisibility()) // store only visible actors
5729 SMESH_Actor* aSmeshActor = 0;
5730 if (actor->IsA("SMESH_Actor"))
5731 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5732 if (aSmeshActor && aSmeshActor->hasIO())
5734 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5737 // entry is "encoded" = it does NOT contain component adress,
5738 // since it is a subject to change on next component loading
5739 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5741 std::string param, vtkParam = vType.toLatin1().data();
5742 vtkParam += gSeparator;
5743 vtkParam += QString::number(vtkViewers).toLatin1().data();
5744 vtkParam += gSeparator;
5747 param = vtkParam + "Visibility";
5748 ip->setParameter(entry, param, "On");
5751 param = vtkParam + "Representation";
5752 ip->setParameter(entry, param, QString::number
5753 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5756 param = vtkParam + "IsShrunk";
5757 ip->setParameter(entry, param, QString::number
5758 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5760 // Displayed entities
5761 unsigned int aMode = aSmeshActor->GetEntityMode();
5762 bool isE = aMode & SMESH_Actor::eEdges;
5763 bool isF = aMode & SMESH_Actor::eFaces;
5764 bool isV = aMode & SMESH_Actor::eVolumes;
5765 bool is0d = aMode & SMESH_Actor::e0DElements;
5766 bool isB = aMode & SMESH_Actor::eBallElem;
5768 QString modeStr ("e");
5769 modeStr += gDigitsSep; modeStr += QString::number(isE);
5770 modeStr += gDigitsSep; modeStr += "f";
5771 modeStr += gDigitsSep; modeStr += QString::number(isF);
5772 modeStr += gDigitsSep; modeStr += "v";
5773 modeStr += gDigitsSep; modeStr += QString::number(isV);
5774 modeStr += gDigitsSep; modeStr += "0d";
5775 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5776 modeStr += gDigitsSep; modeStr += "b";
5777 modeStr += gDigitsSep; modeStr += QString::number(isB);
5779 param = vtkParam + "Entities";
5780 ip->setParameter(entry, param, modeStr.toLatin1().data());
5786 aSmeshActor->GetSufaceColor(r, g, b, delta);
5787 QStringList colorStr;
5788 colorStr << "surface";
5789 colorStr << QString::number(r);
5790 colorStr << QString::number(g);
5791 colorStr << QString::number(b);
5793 colorStr << "backsurface";
5794 colorStr << QString::number(delta);
5796 aSmeshActor->GetVolumeColor(r, g, b, delta);
5797 colorStr << "volume";
5798 colorStr << QString::number(r);
5799 colorStr << QString::number(g);
5800 colorStr << QString::number(b);
5801 colorStr << QString::number(delta);
5803 aSmeshActor->GetEdgeColor(r, g, b);
5805 colorStr << QString::number(r);
5806 colorStr << QString::number(g);
5807 colorStr << QString::number(b);
5809 aSmeshActor->GetNodeColor(r, g, b);
5811 colorStr << QString::number(r);
5812 colorStr << QString::number(g);
5813 colorStr << QString::number(b);
5815 aSmeshActor->GetOutlineColor(r, g, b);
5816 colorStr << "outline";
5817 colorStr << QString::number(r);
5818 colorStr << QString::number(g);
5819 colorStr << QString::number(b);
5821 aSmeshActor->Get0DColor(r, g, b);
5822 colorStr << "elem0d";
5823 colorStr << QString::number(r);
5824 colorStr << QString::number(g);
5825 colorStr << QString::number(b);
5827 aSmeshActor->GetBallColor(r, g, b);
5829 colorStr << QString::number(r);
5830 colorStr << QString::number(g);
5831 colorStr << QString::number(b);
5833 aSmeshActor->GetFacesOrientationColor(r, g, b);
5834 colorStr << "orientation";
5835 colorStr << QString::number(r);
5836 colorStr << QString::number(g);
5837 colorStr << QString::number(b);
5839 param = vtkParam + "Colors";
5840 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5843 QStringList sizeStr;
5845 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5846 sizeStr << "outline";
5847 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5848 sizeStr << "elem0d";
5849 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5851 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5852 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5853 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5854 sizeStr << "shrink";
5855 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5856 sizeStr << "orientation";
5857 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5858 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5860 param = vtkParam + "Sizes";
5861 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5866 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5867 if( aMarkerType == VTK::MT_USER ) {
5868 markerStr += "custom";
5869 markerStr += gDigitsSep;
5870 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5874 markerStr += gDigitsSep;
5875 markerStr += QString::number( (int)aMarkerType );
5876 markerStr += gDigitsSep;
5877 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5880 param = vtkParam + "PointMarker";
5881 ip->setParameter(entry, param, markerStr.toLatin1().data());
5884 param = vtkParam + "Opacity";
5885 ip->setParameter(entry, param,
5886 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5889 param = vtkParam + "ClippingPlane";
5891 if( !aClippingPlaneInfoList.empty() ) {
5892 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5893 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5895 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5896 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5897 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5898 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5899 if( aSmeshActor == *anIter2 ) {
5900 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5901 QString::number( anId ).toLatin1().constData() );
5908 ip->setParameter( entry, param, "Off" );
5909 } // if (io->hasEntry())
5910 } // SMESH_Actor && hasIO
5912 } // while.. actors traversal
5916 } // if (SVTK view model)
5917 } // for (viewManagers)
5920 // data structures for clipping planes processing
5924 bool isOpenGLClipping;
5925 vtkIdType RelativeOrientation;
5928 int AbsoluteOrientation;
5929 double X, Y, Z, Dx, Dy, Dz;
5931 typedef std::list<TPlaneData> TPlaneDataList;
5932 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5934 typedef std::list<vtkActor*> TActorList;
5937 TActorList ActorList;
5938 SUIT_ViewManager* ViewManager;
5940 typedef std::list<TPlaneInfo> TPlaneInfoList;
5941 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5944 * \brief Restore visual parameters
5946 * This method is called after the study document is opened.
5947 * Restore visual parameters from AttributeParameter attribue(s)
5949 void SMESHGUI::restoreVisualParameters (int savePoint)
5952 Kernel_Utils::Localizer loc;
5954 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5955 if (!appStudy || !appStudy->studyDS())
5957 _PTR(Study) studyDS = appStudy->studyDS();
5959 // componentName is used for encoding of entries when storing them in IParameters
5960 std::string componentName = myComponentSMESH->ComponentDataType();
5961 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5962 //if (!aSComponent) return;
5965 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5966 componentName.c_str(),
5968 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5970 // restore map of custom markers and map of clipping planes
5971 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5972 TPlaneDataMap aPlaneDataMap;
5974 std::vector<std::string> properties = ip->getProperties();
5975 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5977 std::string property = *propIt;
5978 QString aPropertyName( property.c_str() );
5979 QString aPropertyValue( ip->getProperty( property ).c_str() );
5981 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5982 if( aPropertyNameList.isEmpty() )
5985 QString aPropertyType = aPropertyNameList[0];
5986 if( aPropertyType == "texture" )
5988 if( aPropertyNameList.size() != 2 )
5992 int anId = aPropertyNameList[1].toInt( &ok );
5993 if( !ok || anId < 1 )
5996 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5997 if( aPropertyValueList.size() != 2 )
6000 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6001 QString aMarkerTextureString = aPropertyValueList[1];
6002 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6003 if( aMarkerTextureStringList.size() != 3 )
6007 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6012 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6016 VTK::MarkerTexture aMarkerTexture;
6017 aMarkerTexture.push_back( aWidth );
6018 aMarkerTexture.push_back( aHeight );
6020 QString aMarkerTextureData = aMarkerTextureStringList[2];
6021 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6023 QChar aChar = aMarkerTextureData.at( i );
6024 if( aChar.isDigit() )
6025 aMarkerTexture.push_back( aChar.digitValue() );
6028 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6030 else if( aPropertyType == "ClippingPlane" )
6032 if( aPropertyNameList.size() != 3 )
6036 int aViewId = aPropertyNameList[1].toInt( &ok );
6037 if( !ok || aViewId < 0 )
6041 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6042 if( !ok || aClippingPlaneId < 0 )
6045 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6046 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6049 TPlaneData aPlaneData;
6050 aPlaneData.AbsoluteOrientation = false;
6051 aPlaneData.RelativeOrientation = 0;
6052 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6053 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6054 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6056 aPlaneData.Id = aClippingPlaneId;
6059 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6064 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6068 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6071 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6076 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6081 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6086 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6091 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6096 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6101 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6105 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6107 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6112 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6117 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6122 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6127 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6128 aPlaneDataList.push_back( aPlaneData );
6132 TPlaneInfoMap aPlaneInfoMap;
6134 std::vector<std::string> entries = ip->getEntries();
6136 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6138 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6139 QString entry (ip->decodeEntry(*entIt).c_str());
6141 // Check that the entry corresponds to a real object in the Study
6142 // as the object may be deleted or modified after the visual state is saved.
6143 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6144 if (!so) continue; //Skip the not existent entry
6146 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6147 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6149 std::vector<std::string>::iterator namesIt = paramNames.begin();
6150 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6152 // actors are stored in a map after displaying of them for
6153 // quicker access in the future: map < viewID to actor >
6154 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6156 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6158 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6159 // '_' is used as separator and should not be used in viewer type or parameter names.
6160 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6161 if (lst.size() != 3)
6164 QString viewerTypStr = lst[0];
6165 QString viewIndexStr = lst[1];
6166 QString paramNameStr = lst[2];
6169 int viewIndex = viewIndexStr.toUInt(&ok);
6170 if (!ok) // bad conversion of view index to integer
6174 if (viewerTypStr == SVTK_Viewer::Type())
6176 SMESH_Actor* aSmeshActor = 0;
6177 if (vtkActors.IsBound(viewIndex))
6178 aSmeshActor = vtkActors.Find(viewIndex);
6180 QList<SUIT_ViewManager*> lst;
6181 getApp()->viewManagers(viewerTypStr, lst);
6183 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6184 SUIT_ViewManager* vman = NULL;
6185 if (viewIndex >= 0 && viewIndex < lst.count())
6186 vman = lst.at(viewIndex);
6188 if (paramNameStr == "Visibility")
6190 if (!aSmeshActor && displayer() && vman)
6192 SUIT_ViewModel* vmodel = vman->getViewModel();
6193 // SVTK view model can be casted to SALOME_View
6194 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6196 // store displayed actor in a temporary map for quicker
6197 // access later when restoring other parameters
6198 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6199 vtkRenderer* Renderer = vtkView->getRenderer();
6200 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6201 vtkActorCollection* theActors = aCopy.GetActors();
6202 theActors->InitTraversal();
6203 bool isFound = false;
6204 vtkActor *ac = theActors->GetNextActor();
6205 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6206 if (ac->IsA("SMESH_Actor")) {
6207 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6208 if (aGeomAc->hasIO()) {
6209 Handle(SALOME_InteractiveObject) io =
6210 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6211 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6213 vtkActors.Bind(viewIndex, aGeomAc);
6219 } // if (paramNameStr == "Visibility")
6222 // the rest properties "work" with SMESH_Actor
6225 QString val ((*valuesIt).c_str());
6228 if (paramNameStr == "Representation") {
6229 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6232 else if (paramNameStr == "IsShrunk") {
6234 if (!aSmeshActor->IsShrunk())
6235 aSmeshActor->SetShrink();
6238 if (aSmeshActor->IsShrunk())
6239 aSmeshActor->UnShrink();
6242 // Displayed entities
6243 else if (paramNameStr == "Entities") {
6244 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6245 int aEntityMode = SMESH_Actor::eAllEntity;
6246 for ( int i = 0; i < mode.count(); i+=2 ) {
6247 if ( i < mode.count()-1 ) {
6248 QString type = mode[i];
6249 bool val = mode[i+1].toInt();
6250 if ( type == "e" && !val )
6251 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6252 else if ( type == "f" && !val )
6253 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6254 else if ( type == "v" && !val )
6255 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6256 else if ( type == "0d" && !val )
6257 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6258 else if ( type == "b" && !val )
6259 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6262 aSmeshActor->SetEntityMode( aEntityMode );
6265 else if (paramNameStr == "Colors") {
6266 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6273 QColor outlineColor;
6274 QColor orientationColor;
6280 // below lines are required to get default values for delta coefficients
6281 // of backface color for faces and color of reversed volumes
6282 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6283 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6284 for ( int i = 0; i < colors.count(); i++ ) {
6285 QString type = colors[i];
6286 if ( type == "surface" ) {
6287 // face color is set by 3 values r:g:b, where
6288 // - r,g,b - is rgb color components
6289 if ( i+1 >= colors.count() ) break; // format error
6290 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6291 if ( i+2 >= colors.count() ) break; // format error
6292 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6293 if ( i+3 >= colors.count() ) break; // format error
6294 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6295 faceColor.setRgbF( r, g, b );
6298 else if ( type == "backsurface" ) {
6299 // backface color can be defined in several ways
6300 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6301 // - in latest versions, it is set as delta coefficient
6302 bool rgbOk = false, deltaOk;
6303 if ( i+1 >= colors.count() ) break; // format error
6304 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6305 int delta = colors[i+1].toInt( &deltaOk );
6307 if ( i+1 < colors.count() ) // index is shifted to 1
6308 g = colors[i+1].toDouble( &rgbOk );
6309 if ( rgbOk ) i++; // shift index
6310 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6311 b = colors[i+1].toDouble( &rgbOk );
6313 // - as currently there's no way to set directly backsurface color as it was before,
6314 // we ignore old dump where r,g,b triple was set
6315 // - also we check that delta parameter is set properly
6316 if ( !rgbOk && deltaOk )
6319 else if ( type == "volume" ) {
6320 // volume color is set by 4 values r:g:b:delta, where
6321 // - r,g,b - is a normal volume rgb color components
6322 // - delta - is a reversed volume color delta coefficient
6323 if ( i+1 >= colors.count() ) break; // format error
6324 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6325 if ( i+2 >= colors.count() ) break; // format error
6326 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6327 if ( i+3 >= colors.count() ) break; // format error
6328 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6329 if ( i+4 >= colors.count() ) break; // format error
6330 int delta = colors[i+4].toInt( &bOk );
6331 if ( !bOk ) break; // format error
6332 volumeColor.setRgbF( r, g, b );
6336 else if ( type == "edge" ) {
6337 // edge color is set by 3 values r:g:b, where
6338 // - r,g,b - is rgb color components
6339 if ( i+1 >= colors.count() ) break; // format error
6340 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6341 if ( i+2 >= colors.count() ) break; // format error
6342 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6343 if ( i+3 >= colors.count() ) break; // format error
6344 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6345 edgeColor.setRgbF( r, g, b );
6348 else if ( type == "node" ) {
6349 // node color is set by 3 values r:g:b, where
6350 // - r,g,b - is rgb color components
6351 if ( i+1 >= colors.count() ) break; // format error
6352 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6353 if ( i+2 >= colors.count() ) break; // format error
6354 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6355 if ( i+3 >= colors.count() ) break; // format error
6356 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6357 nodeColor.setRgbF( r, g, b );
6360 else if ( type == "elem0d" ) {
6361 // 0d element color is set by 3 values r:g:b, where
6362 // - r,g,b - is rgb color components
6363 if ( i+1 >= colors.count() ) break; // format error
6364 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6365 if ( i+2 >= colors.count() ) break; // format error
6366 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6367 if ( i+3 >= colors.count() ) break; // format error
6368 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6369 elem0dColor.setRgbF( r, g, b );
6372 else if ( type == "ball" ) {
6373 // ball color is set by 3 values r:g:b, where
6374 // - r,g,b - is rgb color components
6375 if ( i+1 >= colors.count() ) break; // format error
6376 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6377 if ( i+2 >= colors.count() ) break; // format error
6378 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6379 if ( i+3 >= colors.count() ) break; // format error
6380 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6381 ballColor.setRgbF( r, g, b );
6384 else if ( type == "outline" ) {
6385 // outline color is set by 3 values r:g:b, where
6386 // - r,g,b - is rgb color components
6387 if ( i+1 >= colors.count() ) break; // format error
6388 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6389 if ( i+2 >= colors.count() ) break; // format error
6390 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6391 if ( i+3 >= colors.count() ) break; // format error
6392 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6393 outlineColor.setRgbF( r, g, b );
6396 else if ( type == "orientation" ) {
6397 // orientation color is set by 3 values r:g:b, where
6398 // - r,g,b - is rgb color components
6399 if ( i+1 >= colors.count() ) break; // format error
6400 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6401 if ( i+2 >= colors.count() ) break; // format error
6402 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6403 if ( i+3 >= colors.count() ) break; // format error
6404 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6405 orientationColor.setRgbF( r, g, b );
6410 if ( nodeColor.isValid() )
6411 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6413 if ( edgeColor.isValid() )
6414 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6416 if ( faceColor.isValid() )
6417 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6419 if ( volumeColor.isValid() )
6420 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6421 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6422 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6424 if ( elem0dColor.isValid() )
6425 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6427 if ( ballColor.isValid() )
6428 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6430 if ( outlineColor.isValid() )
6431 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6432 // orientation color
6433 if ( orientationColor.isValid() )
6434 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6437 else if (paramNameStr == "Sizes") {
6438 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6441 int outlineWidth = -1;
6442 int elem0dSize = -1;
6443 //int ballSize = -1;
6444 double ballDiameter = -1.0;
6445 double ballScale = -1.0;
6446 double shrinkSize = -1;
6447 double orientationSize = -1;
6448 bool orientation3d = false;
6449 for ( int i = 0; i < sizes.count(); i++ ) {
6450 QString type = sizes[i];
6451 if ( type == "line" ) {
6452 // line (wireframe) width is given as single integer value
6453 if ( i+1 >= sizes.count() ) break; // format error
6454 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6458 if ( type == "outline" ) {
6459 // outline width is given as single integer value
6460 if ( i+1 >= sizes.count() ) break; // format error
6461 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6465 else if ( type == "elem0d" ) {
6466 // 0d element size is given as single integer value
6467 if ( i+1 >= sizes.count() ) break; // format error
6468 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6472 else if ( type == "ball" ) {
6473 // balls are specified by two values: size:scale, where
6474 // - size - is a integer value specifying size
6475 // - scale - is a double value specifying scale factor
6476 if ( i+1 >= sizes.count() ) break; // format error
6477 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6478 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6479 if ( i+2 >= sizes.count() ) break; // format error
6480 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6486 else if ( type == "shrink" ) {
6487 // shrink factor is given as single floating point value
6488 if ( i+1 >= sizes.count() ) break; // format error
6489 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6493 else if ( type == "orientation" ) {
6494 // orientation vectors are specified by two values size:3d, where
6495 // - size - is a floating point value specifying scale factor
6496 // - 3d - is a boolean
6497 if ( i+1 >= sizes.count() ) break; // format error
6498 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6499 if ( i+2 >= sizes.count() ) break; // format error
6500 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6501 orientationSize = v1;
6502 orientation3d = (bool)v2;
6506 // line (wireframe) width
6507 if ( lineWidth > 0 )
6508 aSmeshActor->SetLineWidth( lineWidth );
6510 if ( outlineWidth > 0 )
6511 aSmeshActor->SetOutlineWidth( outlineWidth );
6512 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6513 aSmeshActor->SetOutlineWidth( lineWidth );
6515 if ( elem0dSize > 0 )
6516 aSmeshActor->Set0DSize( elem0dSize );
6518 /*if ( ballSize > 0 )
6519 aSmeshActor->SetBallSize( ballSize );*/
6521 if ( ballDiameter > 0 )
6522 aSmeshActor->SetBallSize( ballDiameter );
6524 if ( ballScale > 0.0 )
6525 aSmeshActor->SetBallScale( ballScale );
6527 if ( shrinkSize > 0 )
6528 aSmeshActor->SetShrinkFactor( shrinkSize );
6529 // orientation vectors
6530 if ( orientationSize > 0 ) {
6531 aSmeshActor->SetFacesOrientationScale( orientationSize );
6532 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6536 else if (paramNameStr == "PointMarker") {
6537 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6538 if( data.count() >= 2 ) {
6540 int aParam1 = data[1].toInt( &ok );
6542 if( data[0] == "std" && data.count() == 3 ) {
6543 int aParam2 = data[2].toInt( &ok );
6544 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6546 else if( data[0] == "custom" ) {
6547 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6548 if( markerIt != aMarkerMap.end() ) {
6549 VTK::MarkerData aMarkerData = markerIt->second;
6550 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6557 else if (paramNameStr == "Opacity") {
6558 aSmeshActor->SetOpacity(val.toFloat());
6561 else if (paramNameStr.startsWith("ClippingPlane")) {
6562 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6563 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6564 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6565 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6566 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6567 // new format - val looks like "Off" or "0" (plane id)
6568 // (note: in new format "Off" value is used only for consistency,
6569 // so it is processed together with values in old format)
6570 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6571 if( anIsOldFormat ) {
6572 if (paramNameStr == "ClippingPlane1" || val == "Off")
6573 aSmeshActor->RemoveAllClippingPlanes();
6575 QList<SUIT_ViewManager*> lst;
6576 getApp()->viewManagers(viewerTypStr, lst);
6577 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6578 if (viewIndex >= 0 && viewIndex < lst.count()) {
6579 SUIT_ViewManager* vman = lst.at(viewIndex);
6580 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6582 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6584 SMESH::TActorList anActorList;
6585 anActorList.push_back( aSmeshActor );
6586 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6587 aPlane->myViewWindow = vtkView;
6588 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6589 aPlane->PlaneMode = aMode;
6590 bool isOpenGLClipping = ( bool )vals[1].toInt();
6591 aPlane->IsOpenGLClipping = isOpenGLClipping;
6592 if ( aMode == SMESH::Absolute ) {
6593 aPlane->myAbsoluteOrientation = vals[2].toInt();
6594 aPlane->X = vals[3].toFloat();
6595 aPlane->Y = vals[4].toFloat();
6596 aPlane->Z = vals[5].toFloat();
6597 aPlane->Dx = vals[6].toFloat();
6598 aPlane->Dy = vals[7].toFloat();
6599 aPlane->Dz = vals[8].toFloat();
6601 else if ( aMode == SMESH::Relative ) {
6602 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6603 aPlane->myDistance = vals[3].toFloat();
6604 aPlane->myAngle[0] = vals[4].toFloat();
6605 aPlane->myAngle[1] = vals[5].toFloat();
6609 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6610 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6611 aClippingPlaneInfo.Plane = aPlane;
6612 aClippingPlaneInfo.ActorList = anActorList;
6613 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6621 int aPlaneId = val.toInt( &ok );
6622 if( ok && aPlaneId >= 0 ) {
6623 bool anIsDefinedPlane = false;
6624 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6625 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6626 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6627 TPlaneInfo& aPlaneInfo = *anIter;
6628 if( aPlaneInfo.PlaneId == aPlaneId ) {
6629 aPlaneInfo.ActorList.push_back( aSmeshActor );
6630 anIsDefinedPlane = true;
6634 if( !anIsDefinedPlane ) {
6635 TPlaneInfo aPlaneInfo;
6636 aPlaneInfo.PlaneId = aPlaneId;
6637 aPlaneInfo.ActorList.push_back( aSmeshActor );
6638 aPlaneInfo.ViewManager = vman;
6640 // to make the list sorted by plane id
6641 anIter = aPlaneInfoList.begin();
6642 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6643 const TPlaneInfo& aPlaneInfoRef = *anIter;
6644 if( aPlaneInfoRef.PlaneId > aPlaneId )
6647 aPlaneInfoList.insert( anIter, aPlaneInfo );
6652 } // if (aSmeshActor)
6653 } // other parameters than Visibility
6655 } // for names/parameters iterator
6656 } // for entries iterator
6658 // take into account planes with empty list of actors referred to them
6659 QList<SUIT_ViewManager*> aVMList;
6660 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6662 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6663 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6664 int aViewId = aPlaneDataIter->first;
6665 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6666 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6668 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6670 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6671 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6672 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6673 const TPlaneData& aPlaneData = *anIter2;
6674 int aPlaneId = aPlaneData.Id;
6676 bool anIsFound = false;
6677 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6678 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6679 const TPlaneInfo& aPlaneInfo = *anIter3;
6680 if( aPlaneInfo.PlaneId == aPlaneId ) {
6687 TPlaneInfo aPlaneInfo; // ActorList field is empty
6688 aPlaneInfo.PlaneId = aPlaneId;
6689 aPlaneInfo.ViewManager = aViewManager;
6691 // to make the list sorted by plane id
6692 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6693 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6694 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6695 if( aPlaneInfoRef.PlaneId > aPlaneId )
6698 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6704 // add clipping planes to actors according to the restored parameters
6705 // and update the clipping plane map
6706 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6707 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6708 int aViewId = anIter1->first;
6709 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6711 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6712 if( anIter2 == aPlaneDataMap.end() )
6714 const TPlaneDataList& aPlaneDataList = anIter2->second;
6716 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6717 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6718 const TPlaneInfo& aPlaneInfo = *anIter3;
6719 int aPlaneId = aPlaneInfo.PlaneId;
6720 const TActorList& anActorList = aPlaneInfo.ActorList;
6721 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6725 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6729 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6731 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6732 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6733 const TPlaneData& aPlaneData = *anIter4;
6734 if( aPlaneData.Id == aPlaneId ) {
6735 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6736 aPlane->myViewWindow = aViewWindow;
6737 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6738 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6739 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6740 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6741 aPlane->X = aPlaneData.X;
6742 aPlane->Y = aPlaneData.Y;
6743 aPlane->Z = aPlaneData.Z;
6744 aPlane->Dx = aPlaneData.Dx;
6745 aPlane->Dy = aPlaneData.Dy;
6746 aPlane->Dz = aPlaneData.Dz;
6748 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6749 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6750 aPlane->myDistance = aPlaneData.Distance;
6751 aPlane->myAngle[0] = aPlaneData.Angle[0];
6752 aPlane->myAngle[1] = aPlaneData.Angle[1];
6755 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6756 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6757 aClippingPlaneInfo.Plane = aPlane;
6758 aClippingPlaneInfo.ActorList = anActorList;
6759 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6770 // update all VTK views
6771 QList<SUIT_ViewManager*> lst;
6772 getApp()->viewManagers(lst);
6773 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6774 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6775 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6776 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6777 // set OpenGL clipping planes
6778 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6779 vtkActorCollection* anAllActors = aCopy.GetActors();
6780 anAllActors->InitTraversal();
6781 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6782 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6783 anActor->SetOpenGLClippingPlane();
6785 vtkView->getRenderer()->ResetCameraClippingRange();
6792 \brief Adds preferences for dfont of VTK viewer
6794 \param pIf group identifier
6795 \param param parameter
6796 \return identifier of preferences
6798 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6800 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6802 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6805 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6806 fam.append( tr( "SMESH_FONT_COURIER" ) );
6807 fam.append( tr( "SMESH_FONT_TIMES" ) );
6809 setPreferenceProperty( tfont, "fonts", fam );
6811 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6812 if ( needSize ) f = f | QtxFontEdit::Size;
6813 setPreferenceProperty( tfont, "features", f );
6819 \brief Actions after hypothesis edition
6820 Updates object browser after hypothesis edition
6822 void SMESHGUI::onHypothesisEdit( int result )
6825 SMESHGUI::Modified();
6826 updateObjBrowser( true );
6830 \brief Actions after choosing menu of control modes
6831 Updates control mode actions according to current selection
6833 void SMESHGUI::onUpdateControlActions()
6835 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
6836 SALOME_ListIO selected;
6838 aSel->selectedObjects( selected );
6840 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6841 if ( selected.Extent() ) {
6842 if ( selected.First()->hasEntry() ) {
6843 aControl = SMESH::FindActorByEntry( selected.First()->getEntry() )->GetControlMode();
6844 SALOME_ListIteratorOfListIO it(selected);
6845 for ( ; it.More(); it.Next() ) {
6846 Handle(SALOME_InteractiveObject) anIO = it.Value();
6847 if ( anIO->hasEntry() ) {
6848 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6849 if ( aControl != anActor->GetControlMode() ) {
6850 aControl = SMESH_Actor::eNone;
6859 int anAction = ActionToControl( aControl, true );
6861 action( anAction )->setChecked( true );
6863 QMenu* send = (QMenu*)sender();
6864 QList<QAction*> actions = send->actions();
6865 for ( int i = 0; i < actions.size(); i++ )
6866 actions[i]->setChecked( false );
6872 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6873 \param pview view being closed
6875 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6876 #ifndef DISABLE_PLOT2DVIEWER
6877 //Crear all Plot2d Viewers if need.
6878 SMESH::ClearPlot2Viewers(pview);
6880 EmitSignalCloseView();
6883 void SMESHGUI::message( const QString& msg )
6886 QStringList data = msg.split("/");
6887 if ( data.count() > 0 ) {
6888 if ( data.first() == "mesh_loading" ) {
6890 QString entry = data.count() > 1 ? data[1] : QString();
6891 if ( entry.isEmpty() )
6894 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6896 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6899 name = SMESH::fromUtf8(obj->GetName());
6900 if ( name.isEmpty() )
6903 if ( data.last() == "stop" )
6904 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6906 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6907 QApplication::processEvents();
6913 \brief Connects or disconnects signals about activating and cloning view on the module slots
6914 \param pview view which is connected/disconnected
6916 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6920 SUIT_ViewManager* viewMgr = pview->getViewManager();
6922 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6923 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6925 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6926 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6931 \brief Return \c true if object can be renamed
6933 bool SMESHGUI::renameAllowed( const QString& entry) const {
6934 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6938 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6942 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6947 if(appStudy->isComponent(entry) || obj->isReference())
6950 // check type to prevent renaming of inappropriate objects
6951 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6952 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6953 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6954 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6955 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6956 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6963 Rename object by entry.
6964 \param entry entry of the object
6965 \param name new name of the object
6966 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6968 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6970 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6974 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6979 _PTR(Study) aStudy = appStudy->studyDS();
6984 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6986 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6991 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6992 _PTR(GenericAttribute) anAttr;
6993 _PTR(AttributeName) aName;
6995 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6997 // check type to prevent renaming of inappropriate objects
6998 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6999 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7000 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7001 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7002 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7003 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7004 if ( !name.isEmpty() ) {
7005 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
7007 // update name of group object and its actor
7008 Handle(SALOME_InteractiveObject) IObject =
7009 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7011 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7012 if( !aGroupObject->_is_nil() ) {
7013 aGroupObject->SetName( qPrintable(name) );
7014 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7015 anActor->setName( qPrintable(name) );
7025 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7027 static QList<QColor> colors;
7029 if ( colors.isEmpty() ) {
7031 for (int s = 0; s < 2 ; s++)
7033 for (int v = 100; v >= 40; v = v - 20)
7035 for (int h = 0; h < 359 ; h = h + 60)
7037 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7042 static int currentColor = randomize( colors.size() );
7044 SALOMEDS::Color color;
7045 color.R = (double)colors[currentColor].red() / 255.0;
7046 color.G = (double)colors[currentColor].green() / 255.0;
7047 color.B = (double)colors[currentColor].blue() / 255.0;
7049 currentColor = (currentColor+1) % colors.count();