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_OffsetDlg.h"
78 #include "SMESHGUI_Selection.h"
79 #include "SMESHGUI_SewingDlg.h"
80 #include "SMESHGUI_SingleEditDlg.h"
81 #include "SMESHGUI_SmoothingDlg.h"
82 #include "SMESHGUI_SymmetryDlg.h"
83 #include "SMESHGUI_TranslationDlg.h"
84 #include "SMESHGUI_TransparencyDlg.h"
85 #include "SMESHGUI_DisplayEntitiesDlg.h"
86 #include "SMESHGUI_SplitBiQuad.h"
88 #include "SMESHGUI_FilterUtils.h"
89 #include "SMESHGUI_GEOMGenUtils.h"
90 #include "SMESHGUI_GroupUtils.h"
91 #include "SMESHGUI_HypothesesUtils.h"
92 #include "SMESHGUI_MeshUtils.h"
93 #include "SMESHGUI_PatternUtils.h"
94 #include "SMESHGUI_Utils.h"
95 #include "SMESHGUI_VTKUtils.h"
97 #include "SMESH_version.h"
99 #include "SMESH_ControlsDef.hxx"
100 #include "SMESH_Actor.h"
101 #include "SMESH_ActorUtils.h"
102 #include "SMESH_Client.hxx"
103 #include "SMESH_ScalarBarActor.h"
104 #include "SMESH_TypeFilter.hxx"
106 // SALOME GUI includes
107 #include <SalomeApp_Application.h>
108 #include <SalomeApp_CheckFileDlg.h>
109 #include <SalomeApp_DataObject.h>
110 #include <SalomeApp_Study.h>
111 #include <SalomeApp_Tools.h>
113 #include <LightApp_DataOwner.h>
114 #include <LightApp_NameDlg.h>
115 #include <LightApp_Preferences.h>
116 #include <LightApp_SelectionMgr.h>
117 #include <LightApp_UpdateFlags.h>
119 #include <SVTK_ViewManager.h>
120 #include <SVTK_ViewModel.h>
121 #include <SVTK_ViewWindow.h>
123 #include <VTKViewer_Algorithm.h>
125 #include <SUIT_Desktop.h>
126 #include <SUIT_FileDlg.h>
127 #include <SUIT_MessageBox.h>
128 #include <SUIT_OverrideCursor.h>
129 #include <SUIT_ResourceMgr.h>
130 #include <SUIT_Session.h>
132 #include <QtxPopupMgr.h>
133 #include <QtxFontEdit.h>
135 #include <SALOME_ListIO.hxx>
137 #ifndef DISABLE_PLOT2DVIEWER
138 #include <SPlot2d_ViewModel.h>
139 #include <SPlot2d_Histogram.h>
143 #include <SALOMEconfig.h>
144 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
145 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
146 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
147 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
150 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
151 #include <QApplication>
153 #include <QTextStream>
158 #include <QDialogButtonBox>
161 #include <boost/shared_ptr.hpp>
164 #include <vtkCallbackCommand.h>
165 #include <vtkCamera.h>
166 #include <vtkLookupTable.h>
167 #include <vtkPlane.h>
168 #include <vtkRenderer.h>
170 // SALOME KERNEL includes
171 #include <SALOMEDSClient_ClientFactory.hxx>
172 #include <SALOMEDSClient_IParameters.hxx>
173 #include <SALOMEDSClient_SComponent.hxx>
174 #include <SALOMEDSClient_StudyBuilder.hxx>
175 #include <SALOMEDS_Study.hxx>
176 #include <SALOMEDS_SObject.hxx>
177 #include "utilities.h"
180 #include <Standard_ErrorHandler.hxx>
181 #include <NCollection_DataMap.hxx>
182 #include <NCollection_DoubleMap.hxx>
184 #include <Basics_Utils.hxx>
186 // Below macro, when uncommented, switches on simplified (more performant) algorithm
187 // of auto-color picking up
188 #define SIMPLE_AUTOCOLOR
193 //=============================================================
194 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
197 void ExportMeshToFile(int theCommandID);
199 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap);
201 void SetDisplayEntity(int theCommandID);
203 int ActionToControl( int theID, bool theReversed = false );
205 void Control( int theCommandID );
208 //================================================================================
210 * \brief Reads meshes from file
212 //================================================================================
214 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
218 std::string myExtension;
220 if ( theCommandID == SMESHOp::OpImportMED ||
221 theCommandID == SMESHOp::OpPopupImportMED ) {
222 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
223 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
225 else if ( theCommandID == SMESHOp::OpImportUNV ||
226 theCommandID == SMESHOp::OpPopupImportUNV ) {
227 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
229 else if ( theCommandID == SMESHOp::OpImportDAT ||
230 theCommandID == SMESHOp::OpPopupImportDAT ) {
231 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
233 else if ( theCommandID == SMESHOp::OpImportSTL ||
234 theCommandID == SMESHOp::OpPopupImportSTL ) {
235 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
237 else if ( theCommandID == SMESHOp::OpImportCGNS ||
238 theCommandID == SMESHOp::OpPopupImportCGNS ) {
239 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
241 else if ( theCommandID == SMESHOp::OpImportSAUV ||
242 theCommandID == SMESHOp::OpPopupImportSAUV ) {
243 filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
244 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
246 else if ( theCommandID == SMESHOp::OpImportGMF ||
247 theCommandID == SMESHOp::OpPopupImportGMF ) {
248 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
249 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
252 QString anInitialPath = "";
253 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
254 anInitialPath = QDir::currentPath();
256 QStringList filenames;
257 bool toCreateGroups = true;
259 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
260 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
261 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
262 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
263 // fd->setNameFilters( filter );
264 // fd->SetChecked( true );
266 // filenames << fd->selectedFile();
267 // toCreateGroups = fd->IsChecked();
273 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
276 QObject::tr( "SMESH_IMPORT_MESH" ) );
278 if ( filenames.count() > 0 )
280 SUIT_OverrideCursor wc;
281 _PTR(Study) aStudy = SMESH::getStudy();
284 QStringList anEntryList;
285 bool isEmpty = false;
286 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
288 QString filename = *it;
289 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
291 switch ( theCommandID ) {
292 case SMESHOp::OpImportDAT:
293 case SMESHOp::OpPopupImportDAT:
295 // DAT format (currently unsupported)
296 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
297 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
300 case SMESHOp::OpImportUNV:
301 case SMESHOp::OpPopupImportUNV:
304 aMeshes->length( 1 );
305 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
306 if ( aMeshes[0]->_is_nil() )
307 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
308 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
311 case SMESHOp::OpImportMED:
312 case SMESHOp::OpPopupImportMED:
315 SMESH::DriverMED_ReadStatus res;
316 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
317 if ( res != SMESH::DRS_OK ) {
318 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
319 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
323 case SMESHOp::OpImportSTL:
324 case SMESHOp::OpPopupImportSTL:
327 aMeshes->length( 1 );
328 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
329 if ( aMeshes[0]->_is_nil() ) {
330 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
331 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
335 case SMESHOp::OpImportCGNS:
336 case SMESHOp::OpPopupImportCGNS:
339 SMESH::DriverMED_ReadStatus res;
340 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
341 if ( res != SMESH::DRS_OK ) {
342 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
343 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
347 case SMESHOp::OpImportSAUV:
348 case SMESHOp::OpPopupImportSAUV:
351 SMESH::DriverMED_ReadStatus res;
352 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
353 if ( res != SMESH::DRS_OK ) {
354 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
355 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
359 case SMESHOp::OpImportGMF:
360 case SMESHOp::OpPopupImportGMF:
363 SMESH::ComputeError_var res;
364 aMeshes->length( 1 );
365 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
368 if ( res->code != SMESH::DRS_OK ) {
369 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
370 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
371 if ( strlen( res->comment.in() ) > 0 ) {
372 errors.back() += ": ";
373 errors.back() += res->comment.in();
380 catch ( const SALOME::SALOME_Exception& S_ex ) {
381 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
382 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
385 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
387 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
389 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
390 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
391 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
392 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
393 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
395 anEntryList.append( aMeshSO->GetID().c_str() );
403 // update Object browser
404 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
406 // browse to the published meshes
407 if( LightApp_Application* anApp =
408 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
409 anApp->browseObjects( anEntryList );
411 // show Error message box if there were errors
412 if ( errors.count() > 0 ) {
413 SUIT_MessageBox::critical( SMESHGUI::desktop(),
414 QObject::tr( "SMESH_ERROR" ),
415 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
418 // show warning message box, if some imported mesh is empty
420 SUIT_MessageBox::warning( SMESHGUI::desktop(),
421 QObject::tr( "SMESH_WRN_WARNING" ),
422 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
427 //================================================================================
429 * \brief Export selected meshes or groups into a file
431 //================================================================================
433 void ExportMeshToFile( int theCommandID )
435 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
436 SALOME_ListIO selected;
438 aSel->selectedObjects( selected );
440 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
441 theCommandID == SMESHOp::OpPopupExportDAT );
442 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
443 theCommandID == SMESHOp::OpPopupExportMED );
444 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
445 theCommandID == SMESHOp::OpPopupExportUNV );
446 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
447 theCommandID == SMESHOp::OpPopupExportSTL );
448 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
449 theCommandID == SMESHOp::OpPopupExportCGNS );
450 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
451 theCommandID == SMESHOp::OpPopupExportSAUV );
452 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
453 theCommandID == SMESHOp::OpPopupExportGMF );
455 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
456 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
458 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
459 bool aCheckWarn = true;
461 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
462 // get mesh object from selection and check duplication of their names
463 bool hasDuplicatedMeshNames = false;
464 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
465 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
466 SALOME_ListIteratorOfListIO It( selected );
467 for( ; It.More(); It.Next() )
469 Handle(SALOME_InteractiveObject) anIObject = It.Value();
470 SMESH::SMESH_IDSource_var aMeshItem =
471 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
472 if ( aMeshItem->_is_nil() ) {
473 SUIT_MessageBox::warning( SMESHGUI::desktop(),
474 QObject::tr( "SMESH_WRN_WARNING" ),
475 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
478 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
479 if ( aCheckWarn && !aGroup->_is_nil() )
481 QMessageBox msgBox(SUIT_MessageBox::Warning,
482 QObject::tr("SMESH_WRN_WARNING"),
483 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
484 QMessageBox::StandardButton::NoButton,
485 SMESHGUI::desktop());
486 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
487 msgBox.addButton(QMessageBox::Ok);
488 msgBox.addButton(QMessageBox::Cancel);
489 msgBox.setDefaultButton(QMessageBox::Cancel);
490 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
491 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
492 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
493 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
494 if(msgBox.exec() == QMessageBox::Ok)
496 if(dontShowCheckBox.checkState() == Qt::Checked)
499 resMgr->setValue( "SMESH", "show_warning", false);
507 QString aMeshName = anIObject->getName();
509 // check for name duplications
510 if ( !hasDuplicatedMeshNames )
511 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
512 if( aMeshName == (*aMeshIter).second ) {
513 hasDuplicatedMeshNames = true;
518 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
521 if( hasDuplicatedMeshNames && isMED ) {
522 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
523 QObject::tr("SMESH_WRN_WARNING"),
524 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
525 QObject::tr("SMESH_BUT_YES"),
526 QObject::tr("SMESH_BUT_NO"), 0, 1);
531 aMeshIter = aMeshList.begin();
532 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
533 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
534 QString aMeshName = (*aMeshIter).second;
536 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
538 // check for equal group names within each mesh
539 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
540 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
541 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
542 int aRet = SUIT_MessageBox::warning
543 (SMESHGUI::desktop(),
544 QObject::tr("SMESH_WRN_WARNING"),
545 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
546 QObject::tr("SMESH_BUT_YES"),
547 QObject::tr("SMESH_BUT_NO"), 0, 1);
554 // Warn the user about presence of not supported elements
556 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
560 notSupportedElemTypes.push_back( SMESH::Entity_0D );
561 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
566 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
567 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
568 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
569 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
570 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
571 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
572 notSupportedElemTypes.push_back( SMESH::Entity_0D );
573 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
578 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
579 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
580 notSupportedElemTypes.push_back( SMESH::Entity_0D );
581 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
586 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
591 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
592 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
593 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
594 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
595 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
596 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
597 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
598 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
603 notSupportedElemTypes.push_back( SMESH::Entity_0D );
604 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
605 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
606 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
607 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
608 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
609 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
610 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
611 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
612 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
614 if ( ! notSupportedElemTypes.empty() )
616 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
617 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
618 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
619 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
621 if ( !presentNotSupported.empty() )
624 const char* typeMsg[] = {
625 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
626 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
627 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
628 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
629 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
630 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
631 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
632 "SMESH_BIQUADRATIC_PENTAHEDRONS",
633 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
635 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
636 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
637 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
639 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
640 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
641 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
642 if ( iType != presentNotSupported.size() - 1 )
643 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
645 int aRet = SUIT_MessageBox::warning
646 (SMESHGUI::desktop(),
647 QObject::tr("SMESH_WRN_WARNING"),
648 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
649 QObject::tr("SMESH_BUT_YES"),
650 QObject::tr("SMESH_BUT_NO"), 0, 1);
655 // Get parameters of export operation
658 int aFormat =-1; // for MED minor versions
659 bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
661 // Init the parameters with the default values
662 bool aIsASCII_STL = true;
663 bool toCreateGroups = false;
665 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
666 bool toOverwrite = true;
667 bool toFindOutDim = true;
669 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
670 QString anInitialPath = "";
671 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
672 anInitialPath = QDir::currentPath();
674 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
676 // Get a file name to write in and additional otions
677 if ( isUNV || isDAT || isGMF ) // Export w/o options
680 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
682 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
684 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
685 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
686 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
687 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
688 anInitialPath + QString("/") + aMeshName,
689 aFilter, aTitle, false);
691 else if ( isCGNS )// Export to CGNS
693 const char* theByTypeResource = "cgns_group_elems_by_type";
694 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
696 QStringList checkBoxes;
697 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
699 SalomeApp_CheckFileDlg* fd =
700 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
701 fd->setWindowTitle( aTitle );
702 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
703 if ( !anInitialPath.isEmpty() )
704 fd->setDirectory( anInitialPath );
705 fd->selectFile(aMeshName);
706 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
707 fd->setValidator( fv );
708 fd->SetChecked( toCreateGroups, 0 );
711 aFilename = fd->selectedFile();
712 toOverwrite = fv->isOverwrite(aFilename);
713 toCreateGroups = fd->IsChecked(0);
714 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
718 else if ( isSTL ) // Export to STL
720 QMap<QString, int> aFilterMap;
721 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
722 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
725 QMap<QString, int>::const_iterator it = aFilterMap.begin();
726 for ( ; it != aFilterMap.end(); ++it )
727 filters.push_back( it.key() );
729 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
730 fd->setWindowTitle( aTitle );
731 fd->setNameFilters( filters );
732 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
733 if ( !anInitialPath.isEmpty() )
734 fd->setDirectory( anInitialPath );
735 fd->selectFile(aMeshName);
739 aFilename = fd->selectedFile();
740 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
745 else if ( isMED || isSAUV ) // Export to MED or SAUV
747 QMap<QString, int> aFilterMap;
749 //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
750 QString vmed (aMesh->GetVersionString(-1, 2));
751 //MESSAGE("MED version: " << vmed.toStdString());
752 int minor = vmed.split(".").last().toInt();
753 //MESSAGE("MED version minor: "<< minor);
754 //minor +=3; // TODO remove: test multiple minor
755 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vmed ) + " (*.med)", minor );
756 for (int ii=0; ii<minor; ii++)
758 QString vs = aMesh->GetVersionString(ii, 2);
759 //std::ostringstream vss; // TODO remove: test multiple minor
760 //vss << "4."; // TODO remove: test multiple minor
761 //vss << ii; // TODO remove: test multiple minor
762 //vs = vss.str().c_str(); // TODO remove: test multiple minor
763 //MESSAGE("MED version: " << vs.toStdString());
764 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", ii);
768 aFilterMap.insert("All files (*)", -1 );
769 aFilterMap.insert("SAUV files (*.sauv)", -1 );
770 aFilterMap.insert("SAUV files (*.sauve)", -1 );
774 QString aDefaultFilter;
775 QMap<QString, int>::const_iterator it = aFilterMap.begin();
776 for ( ; it != aFilterMap.end(); ++it ) {
777 filters.push_back( it.key() );
779 aDefaultFilter = it.key();
781 QStringList checkBoxes;
782 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
784 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
785 QList< QWidget* > wdgList;
786 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
787 wdgList.append( fieldSelWdg );
789 SalomeApp_CheckFileDlg* fd =
790 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
791 fd->setWindowTitle( aTitle );
792 fd->setNameFilters( filters );
793 fd->SetChecked( toCreateGroups, 0 );
794 fd->SetChecked( toFindOutDim, 1 );
795 if ( !anInitialPath.isEmpty() )
796 fd->setDirectory( anInitialPath );
797 fd->selectFile(aMeshName);
800 QListView *lview = fd->findChild<QListView*>("listView");
802 lview->setMinimumHeight(200);
804 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
806 tview->setMinimumHeight(200);
809 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
810 fd->setValidator( fv );
814 MESSAGE("******* Loop on file dialog ***********");
817 aFilename = fd->selectedFile();
819 aFilename = QString::null;
822 aFormat = aFilterMap[fd->selectedNameFilter()];
823 MESSAGE("selected minor: " << aFormat << " file: " << aFilename.toUtf8().constData());
824 toOverwrite = fv->isOverwrite(aFilename);
825 MESSAGE("toOverwrite:" << toOverwrite);
827 if ( !aFilename.isEmpty() ) {
829 // can't append to an existing using other format
830 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
831 MESSAGE("Append check, isVersionOk:" << isVersionOk);
832 if ( !isVersionOk ) {
833 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
834 QObject::tr("SMESH_WRN_WARNING"),
835 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
836 QObject::tr("SMESH_BUT_YES"),
837 QObject::tr("SMESH_BUT_NO"), 0, 1);
841 MESSAGE("incompatible MED file version for add, overwrite accepted");
847 MESSAGE("incompatible MED file version for add, overwrite refused");
850 QStringList aMeshNamesCollisionList;
851 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
852 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
853 QString anExistingMeshName( aMeshNames[ i ] );
854 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
855 QString anExportMeshName = (*aMeshIter).second;
856 if( anExportMeshName == anExistingMeshName ) {
857 aMeshNamesCollisionList.append( anExportMeshName );
862 if( !aMeshNamesCollisionList.isEmpty() ) {
864 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
865 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
866 QObject::tr("SMESH_WRN_WARNING"),
867 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
868 QObject::tr("SMESH_BUT_YES"),
869 QObject::tr("SMESH_BUT_NO"),
870 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
871 MESSAGE("answer collision name " << aRet);
882 MESSAGE(" ****** end of file dialog loop, toOverwrite:" << toOverwrite << " isOkToWrite:" << isOkToWrite);
883 toCreateGroups = fd->IsChecked(0);
884 toFindOutDim = fd->IsChecked(1);
885 fieldSelWdg->GetSelectedFields();
886 if ( !fieldSelWdg->parent() )
897 if ( !aFilename.isEmpty() ) {
898 // Check whether the file already exists and delete it if yes
899 QFile aFile( aFilename );
900 if ( aFile.exists() && toOverwrite )
902 SUIT_OverrideCursor wc;
905 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
906 // bool Renumber = false;
907 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
909 // Renumber= resMgr->booleanValue("renumbering");
911 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
912 // aMeshEditor->RenumberNodes();
913 // aMeshEditor->RenumberElements();
914 // if ( SMESHGUI::automaticUpdate() )
915 // SMESH::UpdateView();
917 if ( isMED && isOkToWrite)
919 MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
920 aMeshIter = aMeshList.begin();
921 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
923 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
924 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
925 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
926 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
927 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
928 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
929 aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
930 toOverwrite && aMeshIndex == 0, toFindOutDim );
932 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups, aFormat,
933 toOverwrite && aMeshIndex == 0, toFindOutDim,
934 fields, geoAssFields.toLatin1().data() );
939 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
941 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
942 if( !aMeshItem->_is_nil() )
943 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
948 if ( aMeshOrGroup->_is_equivalent( aMesh ))
949 aMesh->ExportDAT( aFilename.toUtf8().data() );
951 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
955 if ( aMeshOrGroup->_is_equivalent( aMesh ))
956 aMesh->ExportUNV( aFilename.toUtf8().data() );
958 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
962 if ( aMeshOrGroup->_is_equivalent( aMesh ))
963 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
965 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
969 aMeshIter = aMeshList.begin();
970 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
972 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
973 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
974 aMeshItem->ExportCGNS( aMeshOrGroup,
975 aFilename.toUtf8().data(),
976 toOverwrite && aMeshIndex == 0,
982 toCreateGroups = true;
983 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
986 catch (const SALOME::SALOME_Exception& S_ex){
988 SUIT_MessageBox::warning(SMESHGUI::desktop(),
989 QObject::tr("SMESH_WRN_WARNING"),
990 QObject::tr("SMESH_EXPORT_FAILED"));
996 inline void InverseEntityMode(unsigned int& theOutputMode,
997 unsigned int theMode)
999 bool anIsNotPresent = ~theOutputMode & theMode;
1001 theOutputMode |= theMode;
1003 theOutputMode &= ~theMode;
1006 void SetDisplayEntity(int theCommandID)
1008 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1009 SALOME_ListIO selected;
1011 aSel->selectedObjects( selected );
1013 if ( selected.Extent() >= 1 ) {
1014 SUIT_OverrideCursor wc;
1015 SALOME_ListIteratorOfListIO It( selected );
1016 for( ; It.More(); It.Next()){
1017 Handle(SALOME_InteractiveObject) IObject = It.Value();
1018 if(IObject->hasEntry()){
1019 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1020 unsigned int aMode = anActor->GetEntityMode();
1021 switch(theCommandID){
1022 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1023 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1024 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1025 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1026 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1027 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1030 anActor->SetEntityMode(aMode);
1039 SalomeApp_Application* app =
1040 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1044 LightApp_SelectionMgr* aSel = app->selectionMgr();
1045 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1046 if ( !aSel || !appStudy )
1049 SALOME_ListIO selected;
1050 aSel->selectedObjects( selected );
1051 if ( selected.IsEmpty() )
1054 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1056 _PTR(Study) aStudy = appStudy->studyDS();
1057 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1058 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1059 if ( aMainObject->_is_nil() )
1062 SUIT_OverrideCursor wc;
1064 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1066 QList<SALOMEDS::Color> aReservedColors;
1068 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1069 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1071 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1073 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1074 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1075 #else // old algorithm for auto-colors
1076 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1077 aReservedColors.append( aColor );
1078 #endif // SIMPLE_AUTOCOLOR
1079 aGroupObject->SetColor( aColor );
1081 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1082 if ( aGroupSObject ) {
1085 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1086 switch ( aGroupObject->GetType ()) {
1088 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1090 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1092 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1094 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1096 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1097 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1100 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1101 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1107 SMESH::RepaintCurrentView();
1110 void OverallMeshQuality()
1112 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1113 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1114 SALOME_ListIO selected;
1116 aSel->selectedObjects( selected );
1118 if ( selected.IsEmpty() ) return;
1119 SALOME_ListIteratorOfListIO It( selected );
1120 for ( ; It.More(); It.Next() ) {
1121 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1122 ctrlDlg->showInfo( It.Value() );
1127 QString functorToString( SMESH::Controls::FunctorPtr f )
1129 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1130 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1131 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1132 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1133 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1134 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1135 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1136 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1137 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1138 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1139 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1140 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1141 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1142 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1143 type = QObject::tr( "WARP_ELEMENTS" );
1144 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1145 type = QObject::tr( "TAPER_ELEMENTS" );
1146 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1147 type = QObject::tr( "SKEW_ELEMENTS" );
1148 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1149 type = QObject::tr( "AREA_ELEMENTS" );
1150 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1151 type = QObject::tr( "LENGTH_EDGES" );
1152 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1153 type = QObject::tr( "LENGTH2D_EDGES" );
1154 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1155 type = QObject::tr( "DEFLECTION2D_FACES" );
1156 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1157 type = QObject::tr( "MULTI_BORDERS" );
1158 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1159 type = QObject::tr( "MULTI2D_BORDERS" );
1160 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1161 type = QObject::tr( "FREE_NODES" );
1162 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1163 type = QObject::tr( "FREE_EDGES" );
1164 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1165 type = QObject::tr( "FREE_BORDERS" );
1166 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1167 type = QObject::tr( "FREE_FACES" );
1168 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1169 type = QObject::tr( "BARE_BORDER_VOLUME" );
1170 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1171 type = QObject::tr( "BARE_BORDER_FACE" );
1172 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1173 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1174 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1175 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1176 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1177 type = QObject::tr( "EQUAL_NODE" );
1178 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1179 type = QObject::tr( "EQUAL_EDGE" );
1180 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1181 type = QObject::tr( "EQUAL_FACE" );
1182 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1183 type = QObject::tr( "EQUAL_VOLUME" );
1184 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1185 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1189 void SaveDistribution()
1191 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1192 SALOME_ListIO selected;
1194 aSel->selectedObjects( selected );
1196 if ( selected.Extent() == 1 ) {
1197 Handle(SALOME_InteractiveObject) anIO = selected.First();
1198 if ( anIO->hasEntry() ) {
1199 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1201 anActor->GetScalarBarActor() &&
1202 anActor->GetControlMode() != SMESH_Actor::eNone )
1204 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1205 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1206 if ( aScalarBarActor && aFunctor ) {
1207 SMESH::Controls::NumericalFunctor* aNumFun =
1208 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1210 std::vector<int> elements;
1211 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1212 if ( mesh->_is_nil() ) {
1213 SMESH::SMESH_IDSource_var idSource =
1214 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1215 if ( !idSource->_is_nil() )
1217 SMESH::long_array_var ids = idSource->GetIDs();
1218 elements.resize( ids->length() );
1219 for ( unsigned i = 0; i < elements.size(); ++i )
1220 elements[i] = ids[i];
1223 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1224 vtkLookupTable* lookupTable =
1225 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1226 double * minmax = lookupTable->GetRange();
1227 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1228 std::vector<int> nbEvents;
1229 std::vector<double> funValues;
1230 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1231 elements, minmax, isLogarithmic );
1232 QString anInitialPath = "";
1233 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1234 anInitialPath = QDir::currentPath();
1235 QString aMeshName = anIO->getName();
1237 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1238 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1239 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1240 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1241 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1244 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1246 if ( !aFilename.isEmpty() ) {
1247 QFile f( aFilename );
1248 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1249 QTextStream out( &f );
1250 out << "# Mesh: " << aMeshName << endl;
1251 out << "# Control: " << functorToString( aFunctor ) << endl;
1253 out.setFieldWidth( 10 );
1254 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1255 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1266 void ShowElement( int theCommandID )
1268 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1269 SALOME_ListIO selected;
1271 aSel->selectedObjects( selected );
1273 if ( selected.Extent() == 1 ) {
1274 Handle(SALOME_InteractiveObject) anIO = selected.First();
1275 if ( anIO->hasEntry() ) {
1276 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1278 anActor->GetScalarBarActor() &&
1279 anActor->GetControlMode() != SMESH_Actor::eNone )
1281 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1282 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1283 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1285 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1286 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1293 #ifndef DISABLE_PLOT2DVIEWER
1294 void PlotDistribution()
1296 SalomeApp_Application* app =
1297 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1301 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1302 SALOME_ListIO selected;
1304 aSel->selectedObjects( selected );
1306 if ( selected.Extent() == 1 ) {
1307 Handle(SALOME_InteractiveObject) anIO = selected.First();
1308 if ( anIO->hasEntry() ) {
1309 //Find Actor by entry before getting Plot2d viewer,
1310 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1311 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1313 SUIT_ViewManager* aViewManager =
1314 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1318 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1322 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1326 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1328 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1329 QString functorName = functorToString( anActor->GetFunctor());
1330 QString aHistogramName("%1 : %2");
1331 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1332 aHistogram->setName(aHistogramName);
1333 aHistogram->setHorTitle(functorName);
1334 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1335 aPlot->displayObject(aHistogram, true);
1340 #endif //DISABLE_PLOT2DVIEWER
1342 void DisableAutoColor()
1344 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1345 SALOME_ListIO selected;
1347 aSel->selectedObjects( selected );
1349 if ( selected.Extent() ) {
1350 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1351 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1352 if ( !aMesh->_is_nil() ) {
1353 aMesh->SetAutoColor( false );
1360 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1361 SALOME_ListIO selected;
1363 aSel->selectedObjects( selected );
1364 if ( selected.Extent() )
1366 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1367 _PTR(Study) aStudy = SMESH::getStudy();
1368 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1370 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1371 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1378 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1380 SALOME_ListIO selected;
1381 SalomeApp_Application* app =
1382 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1386 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1387 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1388 if ( !aSel || !appStudy )
1391 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1392 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1393 aModule->EmitSignalDeactivateDialog();
1394 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1395 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1400 aSel->selectedObjects( selected );
1402 if ( selected.Extent() >= 1 )
1404 switch ( theCommandID ) {
1405 case SMESHOp::OpTransparency:
1407 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1408 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1411 case SMESHOp::OpProperties:
1414 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1415 QColor orientationColor, outlineColor, volumeColor;
1416 int deltaF = 0, deltaV = 0;
1419 double ballScale = 1.0;
1421 int outlineWidth = 1;
1422 double shrinkCoef = 0.0;
1423 double orientationScale = 0.0;
1424 bool orientation3d = false;
1425 VTK::MarkerType markerType = VTK::MT_NONE;
1426 VTK::MarkerScale markerScale = VTK::MS_NONE;
1428 bool hasNodes = false;
1429 int presentEntities = 0;
1430 bool firstTime = true;
1432 SALOME_ListIteratorOfListIO It( selected );
1433 for ( ; It.More(); It.Next() ) {
1434 Handle(SALOME_InteractiveObject) IObject = It.Value();
1435 if ( !IObject->hasEntry() ) continue;
1436 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1437 if ( !anActor || !anActor->GetObject() ) continue;
1440 // nodes: color, marker
1441 anActor->GetNodeColor( color[0], color[1], color[2] );
1442 nodeColor.setRgbF( color[0], color[1], color[2] );
1443 markerType = anActor->GetMarkerType();
1444 markerScale = anActor->GetMarkerScale();
1445 markerId = anActor->GetMarkerTexture();
1446 // edges: color, width
1447 anActor->GetEdgeColor( color[0], color[1], color[2] );
1448 edgeColor.setRgbF( color[0], color[1], color[2] );
1449 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1450 // faces: front color, back color (delta)
1451 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1452 faceColor.setRgbF( color[0], color[1], color[2] );
1453 // faces: front color, back color (delta)
1454 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1455 volumeColor.setRgbF( color[0], color[1], color[2] );
1456 // 0d elements: color, size
1457 anActor->Get0DColor( color[0], color[1], color[2] );
1458 elem0dColor.setRgbF( color[0], color[1], color[2] );
1459 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1460 // balls: color, size
1461 anActor->GetBallColor( color[0], color[1], color[2] );
1462 ballColor.setRgbF( color[0], color[1], color[2] );
1463 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1464 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1466 anActor->GetOutlineColor( color[0], color[1], color[2] );
1467 outlineColor.setRgbF( color[0], color[1], color[2] );
1468 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1469 // orientation vectors: color, scale, 3d flag
1470 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1471 orientationColor.setRgbF( color[0], color[1], color[2] );
1472 orientationScale = anActor->GetFacesOrientationScale();
1473 orientation3d = anActor->GetFacesOrientation3DVectors();
1475 shrinkCoef = anActor->GetShrinkFactor();
1478 firstTime = false; // we only take properties from first object (for performance reasons)
1481 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1482 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1483 presentEntities = presentEntities | SMESH_Actor::eEdges;
1484 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1485 presentEntities = presentEntities | SMESH_Actor::eFaces;
1486 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1487 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1488 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1489 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1490 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1491 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1493 // as we know that all types of elements are present, we can exit the loop
1494 if ( presentEntities == SMESH_Actor::eAllEntity )
1498 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1499 // nodes: color, marker
1500 dlg.setNodeColor( nodeColor );
1501 if( markerType != VTK::MT_USER )
1502 dlg.setNodeMarker( markerType, markerScale );
1504 dlg.setNodeCustomMarker( markerId );
1505 // edges: color, line width
1506 dlg.setEdgeColor( edgeColor );
1507 dlg.setEdgeWidth( edgeWidth );
1508 // faces: front color, back color
1509 dlg.setFaceColor( faceColor, deltaF );
1510 // volumes: normal color, reversed color
1511 dlg.setVolumeColor( volumeColor, deltaV );
1512 // outlines: color, line width
1513 dlg.setOutlineColor( outlineColor );
1514 dlg.setOutlineWidth( outlineWidth );
1515 // 0d elements: color, size
1516 dlg.setElem0dColor( elem0dColor );
1517 dlg.setElem0dSize( elem0dSize );
1518 // balls: color, size
1519 dlg.setBallColor( ballColor );
1520 //dlg.setBallSize( ballSize );
1521 dlg.setBallScale( ballScale );
1522 // orientation: color, scale, 3d flag
1523 dlg.setOrientationColor( orientationColor );
1524 dlg.setOrientationSize( int( orientationScale * 100. ) );
1525 dlg.setOrientation3d( orientation3d );
1526 // shrink: scale factor
1527 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1528 // hide unused controls
1529 dlg.showControls( presentEntities, hasNodes );
1532 nodeColor = dlg.nodeColor();
1533 markerType = dlg.nodeMarkerType();
1534 markerScale = dlg.nodeMarkerScale();
1535 markerId = dlg.nodeMarkerId();
1536 edgeColor = dlg.edgeColor();
1537 edgeWidth = dlg.edgeWidth();
1538 faceColor = dlg.faceColor();
1539 deltaF = dlg.faceColorDelta();
1540 volumeColor = dlg.volumeColor();
1541 deltaV = dlg.volumeColorDelta();
1542 outlineColor = dlg.outlineColor();
1543 outlineWidth = dlg.outlineWidth();
1544 elem0dColor = dlg.elem0dColor();
1545 elem0dSize = dlg.elem0dSize();
1546 ballColor = dlg.ballColor();
1547 // ballSize = dlg.ballSize();
1548 ballScale = dlg.ballScale();
1549 orientationColor = dlg.orientationColor();
1550 orientationScale = dlg.orientationSize() / 100.;
1551 orientation3d = dlg.orientation3d();
1552 shrinkCoef = dlg.shrinkCoef() / 100.;
1554 // store point markers that might be changed by the user
1555 theMarkerMap = dlg.customMarkers();
1557 // set properties from dialog box to the presentations
1558 SALOME_ListIteratorOfListIO It( selected );
1559 for ( ; It.More(); It.Next() ) {
1560 Handle(SALOME_InteractiveObject) IObject = It.Value();
1561 if ( !IObject->hasEntry() ) continue;
1562 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1563 if ( !anActor ) continue;
1565 // nodes: color, marker
1566 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1567 if ( markerType != VTK::MT_USER ) {
1568 anActor->SetMarkerStd( markerType, markerScale );
1571 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1572 if ( iter != theMarkerMap.end() )
1573 anActor->SetMarkerTexture( markerId, iter->second.second );
1575 // volumes: normal color, reversed color (delta)
1576 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1577 // faces: front color, back color (delta)
1578 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1579 // edges: color, width
1580 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1581 anActor->SetLineWidth( edgeWidth );
1583 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1584 anActor->SetOutlineWidth( outlineWidth );
1585 // 0D elements: color, size
1586 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1587 anActor->Set0DSize( elem0dSize );
1588 // balls: color, size
1589 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1590 // anActor->SetBallSize( ballSize );
1591 anActor->SetBallScale( ballScale );
1592 // orientation: color, scale, 3d flag
1593 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1594 anActor->SetFacesOrientationScale( orientationScale );
1595 anActor->SetFacesOrientation3DVectors( orientation3d );
1597 anActor->SetShrinkFactor( shrinkCoef );
1599 // for groups, set also proper color
1600 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1601 if ( !aGroupObject->_is_nil() ) {
1602 SMESH::ElementType anElementType = aGroupObject->GetType();
1604 switch( anElementType ) {
1606 aColor = nodeColor; break;
1608 aColor = edgeColor; break;
1610 aColor = faceColor; break;
1612 aColor = volumeColor; break;
1614 aColor = elem0dColor; break;
1616 aColor = ballColor; break;
1620 if ( aColor.isValid() ) {
1621 SALOMEDS::Color aGroupColor;
1622 aGroupColor.R = aColor.redF();
1623 aGroupColor.G = aColor.greenF();
1624 aGroupColor.B = aColor.blueF();
1625 aGroupObject->SetColor( aGroupColor );
1627 } // if ( !aGroupObject->_is_nil() )
1628 } // for ( ; It.More(); It.Next() )
1629 SMESH::RepaintCurrentView();
1630 } // if ( dlg.exec() )
1632 } // case SMESHOp::OpProperties:
1633 } // switch(theCommandID)
1634 SUIT_OverrideCursor wc;
1635 SALOME_ListIteratorOfListIO It( selected );
1636 for( ; It.More(); It.Next()){
1637 Handle(SALOME_InteractiveObject) IObject = It.Value();
1638 if(IObject->hasEntry()){
1639 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1640 switch(theCommandID){
1641 case SMESHOp::OpDMWireframe:
1642 anActor->SetRepresentation(SMESH_Actor::eEdge);
1644 case SMESHOp::OpDMShading:
1645 anActor->SetRepresentation(SMESH_Actor::eSurface);
1647 case SMESHOp::OpDMShrink:
1648 if(anActor->IsShrunk())
1649 anActor->UnShrink();
1651 anActor->SetShrink();
1653 case SMESHOp::OpDMNodes:
1654 anActor->SetRepresentation(SMESH_Actor::ePoint);
1656 case SMESHOp::OpRepresentationLines:
1657 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1658 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1660 case SMESHOp::OpRepresentationArcs:
1661 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1662 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1668 SMESH::RepaintCurrentView();
1672 int ActionToControl( int theID, bool theReversed )
1674 NCollection_DoubleMap<int,int> ActionControl;
1675 ActionControl.Bind( 0, SMESH_Actor::eNone );
1676 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1677 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1678 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1679 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1680 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1681 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1682 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1683 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1684 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1685 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1686 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1687 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1688 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1689 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1690 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1691 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1692 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1693 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1694 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1695 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1696 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1697 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1698 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1699 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1700 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1701 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1702 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1703 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1706 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1707 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1710 void Control( int theCommandID )
1712 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1713 _PTR(Study) aStudy = SMESH::getStudy();
1715 SALOME_ListIO selected;
1716 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1717 aSel->selectedObjects( selected );
1719 if ( !selected.IsEmpty() ) {
1720 SALOME_ListIteratorOfListIO It(selected);
1721 for ( ; It.More(); It.Next())
1723 Handle(SALOME_InteractiveObject) anIO = It.Value();
1724 if ( !anIO.IsNull() ) {
1725 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1727 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1728 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1729 if ( !anIDSrc->_is_nil() ) {
1730 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1731 if (( !anActor && selected.Extent() == 1 ) &&
1732 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1734 anActor->SetControlMode( aControl );
1735 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1736 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1740 if ( anActor->GetControlMode() != aControl )
1741 anActor->SetControlMode( aControl );
1742 QString functorName = functorToString( anActor->GetFunctor() );
1743 int anEntitiesCount = anActor->GetNumberControlEntities();
1744 if (anEntitiesCount >= 0)
1745 functorName = functorName + ": " + QString::number(anEntitiesCount);
1746 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1747 SMESH::RepaintCurrentView();
1748 #ifndef DISABLE_PLOT2DVIEWER
1749 if ( anActor->GetPlot2Histogram() ) {
1750 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1751 QString aHistogramName("%1 : %2");
1752 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1753 aHistogram->setName( aHistogramName );
1754 aHistogram->setHorTitle( functorName );
1755 SMESH::ProcessIn2DViewers( anActor );
1767 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1768 SMESH::MeshObjectType theType,
1769 const QString theInTypeName,
1770 QString & theOutTypeName)
1772 SMESH_TypeFilter aTypeFilter( theType );
1774 if ( !theIO.IsNull() )
1776 entry = theIO->getEntry();
1777 LightApp_DataOwner owner( entry );
1778 if ( aTypeFilter.isOk( &owner )) {
1779 theOutTypeName = theInTypeName;
1787 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1789 _PTR(Study) aStudy = SMESH::getStudy();
1790 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1792 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1793 CORBA::String_var anID = aSComp->GetID().c_str();
1794 if ( !strcmp(anID.in(),theIO->getEntry()) )
1800 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1801 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1802 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1803 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1804 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1812 // QString CheckHomogeneousSelection()
1814 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1815 // SALOME_ListIO selected;
1817 // aSel->selectedObjects( selected );
1819 // QString RefType = CheckTypeObject(selected.First());
1820 // SALOME_ListIteratorOfListIO It(selected);
1821 // for ( ; It.More(); It.Next())
1823 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1824 // QString Type = CheckTypeObject(IObject);
1825 // if ( Type.compare(RefType) != 0 )
1826 // return "Heterogeneous Selection";
1832 uint randomize( uint size )
1834 static bool initialized = false;
1835 if ( !initialized ) {
1836 qsrand( QDateTime::currentDateTime().toTime_t() );
1840 v = uint( (double)( v ) / RAND_MAX * size );
1841 v = qMax( uint(0), qMin ( v, size-1 ) );
1847 void SMESHGUI::OnEditDelete()
1849 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1850 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1851 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1853 _PTR(Study) aStudy = SMESH::getStudy();
1854 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1855 _PTR(GenericAttribute) anAttr;
1856 _PTR(AttributeIOR) anIOR;
1858 int objectCount = 0;
1860 QString aParentComponent = QString::null;
1862 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1864 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1865 if ( anIO.IsNull() ) continue;
1867 QString father = "unknown";
1869 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1871 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1872 // check if object is reference
1873 _PTR(SObject) aRefSObj;
1874 aNameList.append("\n - ");
1875 if ( aSO->ReferencedObject( aRefSObj ) ) {
1876 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1877 aNameList.append( aRefName );
1878 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1881 aNameList.append(anIO->getName());
1885 if( aParentComponent.isNull() )
1886 aParentComponent = father;
1887 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1888 aParentComponent = "";
1891 if ( objectCount == 0 )
1892 return; // No Valid Objects Selected
1894 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1895 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1896 QObject::tr("ERR_ERROR"),
1897 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1900 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1901 if (SUIT_MessageBox::warning
1902 (SMESHGUI::desktop(),
1903 QObject::tr("SMESH_WRN_WARNING"),
1904 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1905 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1906 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1909 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1911 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1912 // then treat them all starting from the deepest objects (at list back)
1913 std::list< _PTR(SObject) > listSO;
1914 SALOME_ListIteratorOfListIO It(selected);
1915 for( ; It.More(); It.Next()) // loop on selected IO's
1917 Handle(SALOME_InteractiveObject) IObject = It.Value();
1918 if(IObject->hasEntry()) {
1919 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1921 // disable removal of "SMESH" component object
1922 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1924 if ( engineIOR() == anIOR->Value().c_str() )
1927 //Check the referenced object
1928 _PTR(SObject) aRefSObject;
1929 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1930 aSO = aRefSObject; // Delete main Object instead of reference
1932 listSO.push_back( aSO );
1933 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1934 for ( ; itSO != listSO.end(); ++itSO ) {
1935 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1936 for (it->InitEx(false); it->More(); it->Next())
1937 listSO.push_back( it->Value() );
1941 // Check if none of objects to delete is referred from outside
1942 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1943 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1945 _PTR(SObject) SO = *ritSO;
1946 if ( !SO ) continue;
1947 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1948 for (size_t i = 0; i < aReferences.size(); i++) {
1949 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1950 std::string type = aComponent->ComponentDataType();
1951 if ( type != "SMESH" )
1953 SUIT_MessageBox::warning( anApp->desktop(),
1954 QObject::tr("WRN_WARNING"),
1955 QObject::tr("DEP_OBJECT") );
1956 return; // outside SMESH, there is an object depending on a SMESH object
1961 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1962 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1964 Handle(SALOME_InteractiveObject) IObject = It.Value();
1965 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1966 if ( !mesh->_is_nil() )
1970 // Treat SO's in the list starting from the back
1971 aStudyBuilder->NewCommand(); // There is a transaction
1972 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1974 _PTR(SObject) SO = *ritSO;
1975 if ( !SO ) continue;
1976 std::string anEntry = SO->GetID();
1978 /** Erase graphical object and remove all its data **/
1979 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1980 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1982 /** Remove an object from data structures **/
1983 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1984 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1985 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1986 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1987 aMesh->RemoveGroup( aGroup );
1989 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1990 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1991 aMesh->RemoveSubMesh( aSubMesh );
1994 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1995 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1996 QString objType = CheckTypeObject(IObject);
1997 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1998 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1999 aStudyBuilder->RemoveObjectWithChildren( SO );
2001 else {// default action: remove SObject from the study
2002 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2003 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2005 aStudyBuilder->RemoveObjectWithChildren( SO );
2009 } /* listSO back loop */
2011 aStudyBuilder->CommitCommand();
2013 /* Clear any previous selection */
2015 aSel->setSelectedObjects( l1 );
2017 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2021 SMESHGUI_EXPORT CAM_Module* createModule()
2023 return new SMESHGUI();
2026 SMESHGUI_EXPORT char* getModuleVersion() {
2027 return (char*)SMESH_VERSION_STR;
2031 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2033 //=============================================================================
2037 //=============================================================================
2038 SMESHGUI::SMESHGUI() :
2039 SalomeApp_Module( "SMESH" )
2041 if ( CORBA::is_nil( myComponentSMESH ) )
2043 CORBA::Boolean anIsEmbeddedMode;
2044 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2045 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2047 // 0019923: EDF 765 SMESH : default values of hypothesis
2048 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2049 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2050 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2051 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2052 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2054 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2055 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2056 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2058 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2059 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2063 myActiveDialogBox = 0;
2064 myFilterLibraryDlg = 0;
2068 myEventCallbackCommand = vtkCallbackCommand::New();
2069 myEventCallbackCommand->Delete();
2070 myEventCallbackCommand->SetClientData( this );
2071 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2074 /* load resources for all available meshers */
2075 SMESH::InitAvailableHypotheses();
2078 //=============================================================================
2082 //=============================================================================
2083 SMESHGUI::~SMESHGUI()
2087 //=============================================================================
2091 //=============================================================================
2092 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2094 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2096 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2101 //=============================================================================
2105 //=============================================================================
2106 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2108 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2112 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2113 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2114 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2115 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2116 return autoUpdate && !exceeded;
2119 //=============================================================================
2123 //=============================================================================
2124 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2125 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2127 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2131 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2132 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2133 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2135 SMESH::long_array_var info = theMesh->GetMeshInfo();
2136 long nbOdElems = info[SMDSEntity_0D];
2137 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2138 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2139 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2140 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2141 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2142 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2143 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2144 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2145 info[SMDSEntity_Polyhedra] +
2146 info[SMDSEntity_Hexagonal_Prism];
2147 long nbBalls = info[SMDSEntity_Ball];
2149 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2150 *nbElements = requestedSize;
2152 *entities = SMESH_Actor::eAllEntity;
2155 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2157 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2159 if ( incrementalLimit ) {
2162 if ( nbOdElems > 0 ) {
2163 if ( total + nbOdElems > updateLimit ) {
2164 *entities = *entities & ~SMESH_Actor::e0DElements;
2165 *hidden = *hidden | SMESH_Actor::e0DElements;
2172 if ( nbEdges > 0 ) {
2173 if ( total + nbEdges > updateLimit ) {
2174 *entities = *entities & ~SMESH_Actor::eEdges;
2175 *hidden = *hidden | SMESH_Actor::eEdges;
2182 if ( nbFaces > 0 ) {
2183 if ( total + nbFaces > updateLimit ) {
2184 *entities = *entities & ~SMESH_Actor::eFaces;
2185 *hidden = *hidden | SMESH_Actor::eFaces;
2192 if ( nbVolumes > 0 ) {
2193 if ( total + nbVolumes > updateLimit ) {
2194 *entities = *entities & ~SMESH_Actor::eVolumes;
2195 *hidden = *hidden | SMESH_Actor::eVolumes;
2202 if ( nbBalls > 0 ) {
2203 if ( total + nbBalls > updateLimit ) {
2204 *entities = *entities & ~SMESH_Actor::eBallElem;
2205 *hidden = *hidden | SMESH_Actor::eBallElem;
2213 return autoUpdate && !exceeded;
2216 //=============================================================================
2220 //=============================================================================
2221 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2223 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2226 //=============================================================================
2230 //=============================================================================
2231 SMESHGUI* SMESHGUI::GetSMESHGUI()
2233 SMESHGUI* smeshMod = 0;
2234 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2237 CAM_Module* module = app->module( "Mesh" );
2238 smeshMod = dynamic_cast<SMESHGUI*>( module );
2246 Standard_EXPORT SMESHGUI* GetComponentGUI()
2248 return SMESHGUI::GetSMESHGUI();
2252 //=============================================================================
2256 //=============================================================================
2257 void SMESHGUI::SetState(int aState)
2262 //=============================================================================
2266 //=============================================================================
2267 void SMESHGUI::ResetState()
2272 //=============================================================================
2276 //=============================================================================
2277 void SMESHGUI::EmitSignalDeactivateDialog()
2279 emit SignalDeactivateActiveDialog();
2282 //=============================================================================
2286 //=============================================================================
2287 void SMESHGUI::EmitSignalStudyFrameChanged()
2289 emit SignalStudyFrameChanged();
2292 //=============================================================================
2296 //=============================================================================
2297 void SMESHGUI::EmitSignalCloseAllDialogs()
2299 emit SignalCloseAllDialogs();
2302 //=============================================================================
2306 //=============================================================================
2307 void SMESHGUI::EmitSignalVisibilityChanged()
2309 emit SignalVisibilityChanged();
2312 //=============================================================================
2316 //=============================================================================
2317 void SMESHGUI::EmitSignalCloseView()
2319 emit SignalCloseView();
2322 //=============================================================================
2326 //=============================================================================
2327 void SMESHGUI::EmitSignalActivatedViewManager()
2329 emit SignalActivatedViewManager();
2332 //=============================================================================
2336 //=============================================================================
2337 QDialog *SMESHGUI::GetActiveDialogBox()
2339 return myActiveDialogBox;
2342 //=============================================================================
2346 //=============================================================================
2347 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2349 myActiveDialogBox = (QDialog *) aDlg;
2353 //=============================================================================
2357 //=============================================================================
2358 SUIT_Desktop* SMESHGUI::desktop()
2360 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2362 return app->desktop();
2367 //=============================================================================
2371 //=============================================================================
2372 SalomeApp_Study* SMESHGUI::activeStudy()
2374 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2376 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2381 //=============================================================================
2385 //=============================================================================
2386 void SMESHGUI::Modified( bool theIsUpdateActions )
2388 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2389 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2390 appStudy->Modified();
2391 if( theIsUpdateActions )
2392 app->updateActions();
2397 //=============================================================================
2401 //=============================================================================
2402 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2404 /* Here the position is on the bottom right corner - 10 */
2405 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2407 SUIT_Desktop *PP = desktop();
2408 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2409 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2414 * \brief Verifies whether study of operation is locked
2415 * \param theMess - specifies whether message box must be shown if study is locked
2416 * \return State of study.
2418 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2419 * is locked when corresponding message box appears
2421 bool SMESHGUI::isStudyLocked( bool theMessage )
2423 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2426 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2427 QObject::tr( "WRN_WARNING" ),
2428 QObject::tr( "WRN_STUDY_LOCKED" ) );
2434 //=============================================================================
2438 //=============================================================================
2439 bool SMESHGUI::OnGUIEvent( int theCommandID )
2441 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2445 SUIT_ResourceMgr* mgr = resourceMgr();
2449 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2450 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2452 //QAction* act = action( theCommandID );
2454 switch (theCommandID) {
2455 case SMESHOp::OpDelete:
2456 if(isStudyLocked()) break;
2459 case SMESHOp::OpImportDAT:
2460 case SMESHOp::OpImportUNV:
2461 case SMESHOp::OpImportMED:
2462 case SMESHOp::OpImportSTL:
2463 case SMESHOp::OpImportCGNS:
2464 case SMESHOp::OpImportSAUV:
2465 case SMESHOp::OpImportGMF:
2466 case SMESHOp::OpPopupImportDAT:
2467 case SMESHOp::OpPopupImportUNV:
2468 case SMESHOp::OpPopupImportMED:
2469 case SMESHOp::OpPopupImportSTL:
2470 case SMESHOp::OpPopupImportCGNS:
2471 case SMESHOp::OpPopupImportSAUV:
2472 case SMESHOp::OpPopupImportGMF:
2474 if(isStudyLocked()) break;
2475 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2479 case SMESHOp::OpFileInformation:
2481 SALOME_ListIO selected;
2482 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2484 aSel->selectedObjects( selected );
2485 if( selected.Extent() )
2487 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2488 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2489 if ( !aMesh->_is_nil() )
2491 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2497 case SMESHOp::OpExportDAT:
2498 case SMESHOp::OpExportMED:
2499 case SMESHOp::OpExportUNV:
2500 case SMESHOp::OpExportSTL:
2501 case SMESHOp::OpExportCGNS:
2502 case SMESHOp::OpExportSAUV:
2503 case SMESHOp::OpExportGMF:
2504 case SMESHOp::OpPopupExportDAT:
2505 case SMESHOp::OpPopupExportMED:
2506 case SMESHOp::OpPopupExportUNV:
2507 case SMESHOp::OpPopupExportSTL:
2508 case SMESHOp::OpPopupExportCGNS:
2509 case SMESHOp::OpPopupExportSAUV:
2510 case SMESHOp::OpPopupExportGMF:
2512 ::ExportMeshToFile(theCommandID);
2516 case SMESHOp::OpReset: // SCALAR BAR
2518 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2519 SALOME_ListIO selected;
2521 aSel->selectedObjects( selected );
2523 SALOME_ListIteratorOfListIO it(selected);
2524 for( ; it.More(); it.Next()) {
2525 Handle(SALOME_InteractiveObject) anIO = it.Value();
2526 if( anIO->hasEntry() ) {
2527 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2528 anActor->SetControlMode( SMESH_Actor::eNone );
2529 #ifndef DISABLE_PLOT2DVIEWER
2530 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2535 SMESH::UpdateView();
2538 case SMESHOp::OpScalarBarProperties:
2540 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2543 case SMESHOp::OpShowScalarBar:
2545 // show/hide scalar bar
2546 ::ShowElement(theCommandID);
2549 case SMESHOp::OpSaveDistribution:
2551 // dump control distribution data to the text file
2552 ::SaveDistribution();
2556 case SMESHOp::OpShowDistribution:
2558 // show/hide distribution
2559 ::ShowElement(theCommandID);
2563 #ifndef DISABLE_PLOT2DVIEWER
2564 case SMESHOp::OpPlotDistribution:
2566 // plot distribution
2567 ::PlotDistribution();
2573 case SMESHOp::OpAutoColor:
2577 case SMESHOp::OpDisableAutoColor:
2578 ::DisableAutoColor();
2581 case SMESHOp::OpClipping:
2582 case SMESHOp::OpTransparency:
2583 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2586 case SMESHOp::OpDMWireframe:
2587 case SMESHOp::OpDMShading:
2588 case SMESHOp::OpDMNodes:
2589 case SMESHOp::OpDMShrink:
2590 ::SetDisplayMode(theCommandID, myMarkerMap);
2593 //2D quadratic representation
2594 case SMESHOp::OpRepresentationLines:
2595 case SMESHOp::OpRepresentationArcs:
2596 ::SetDisplayMode(theCommandID, myMarkerMap);
2600 case SMESHOp::OpDE0DElements:
2601 case SMESHOp::OpDEEdges:
2602 case SMESHOp::OpDEFaces:
2603 case SMESHOp::OpDEVolumes:
2604 case SMESHOp::OpDEBalls:
2605 case SMESHOp::OpDEAllEntity:
2606 ::SetDisplayEntity(theCommandID);
2609 // Choose entities to be displayed
2610 case SMESHOp::OpDEChoose:
2612 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2616 case SMESHOp::OpOrientationOnFaces:
2618 SUIT_OverrideCursor wc;
2619 LightApp_SelectionMgr* mgr = selectionMgr();
2620 SALOME_ListIO selected; mgr->selectedObjects( selected );
2622 SALOME_ListIteratorOfListIO it(selected);
2623 for( ; it.More(); it.Next()) {
2624 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2625 if(anIObject->hasEntry()) {
2626 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2627 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2634 case SMESHOp::OpUpdate:
2636 if(isStudyLocked()) break;
2637 SUIT_OverrideCursor wc;
2640 SMESH::UpdateView();
2642 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2643 SMESH::OnVisuException();
2645 catch (...) { // PAL16774 (Crash after display of many groups)
2646 SMESH::OnVisuException();
2650 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2651 aSel->selectedObjects( l );
2652 aSel->setSelectedObjects( l );
2656 case SMESHOp::OpHide:
2657 case SMESHOp::OpShow:
2658 case SMESHOp::OpShowOnly:
2660 SUIT_OverrideCursor wc;
2661 SMESH::EDisplaing anAction;
2662 switch (theCommandID) {
2663 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2664 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2665 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2668 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2669 SALOME_ListIO sel_objects, to_process;
2671 aSel->selectedObjects( sel_objects );
2673 if ( theCommandID==SMESHOp::OpShowOnly )
2675 //MESSAGE("anAction = SMESH::eDisplayOnly");
2676 startOperation( myEraseAll );
2679 extractContainers( sel_objects, to_process );
2684 SALOME_ListIteratorOfListIO It( to_process );
2685 for ( ; It.More(); It.Next())
2687 Handle(SALOME_InteractiveObject) IOS = It.Value();
2688 if ( IOS->hasEntry() )
2690 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2691 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2692 break; // PAL16774 (Crash after display of many groups)
2694 if (anAction == SMESH::eDisplayOnly)
2695 anAction = SMESH::eDisplay;
2700 // PAL13338 + PAL15161 -->
2701 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2702 SMESH::UpdateView();
2703 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2705 // PAL13338 + PAL15161 <--
2707 catch (...) { // PAL16774 (Crash after display of many groups)
2708 SMESH::OnVisuException();
2711 if (anAction == SMESH::eErase) {
2713 aSel->setSelectedObjects( l1 );
2716 aSel->setSelectedObjects( to_process );
2721 case SMESHOp::OpNode:
2723 if(isStudyLocked()) break;
2726 EmitSignalDeactivateDialog();
2728 ( new SMESHGUI_NodesDlg( this ) )->show();
2731 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2736 case SMESHOp::OpCreateMesh:
2737 case SMESHOp::OpCreateSubMesh:
2738 case SMESHOp::OpEditMeshOrSubMesh:
2739 case SMESHOp::OpEditMesh:
2740 case SMESHOp::OpEditSubMesh:
2741 case SMESHOp::OpCompute:
2742 case SMESHOp::OpComputeSubMesh:
2743 case SMESHOp::OpPreCompute:
2744 case SMESHOp::OpEvaluate:
2745 case SMESHOp::OpMeshOrder:
2746 startOperation( theCommandID );
2748 case SMESHOp::OpCopyMesh:
2750 if (isStudyLocked()) break;
2751 EmitSignalDeactivateDialog();
2752 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2755 case SMESHOp::OpBuildCompoundMesh:
2757 if (isStudyLocked()) break;
2758 EmitSignalDeactivateDialog();
2759 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2763 case SMESHOp::OpDiagonalInversion:
2764 case SMESHOp::OpUnionOfTwoTriangle:
2768 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2772 if ( isStudyLocked() )
2775 /*Standard_Boolean aRes;
2776 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2777 if ( aMesh->_is_nil() )
2779 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2780 tr( "SMESH_BAD_SELECTION" ) );
2784 EmitSignalDeactivateDialog();
2785 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2786 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2788 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2791 case SMESHOp::OpOrientation:
2792 case SMESHOp::OpUnionOfTriangles:
2793 case SMESHOp::OpCuttingOfQuadrangles:
2794 case SMESHOp::OpSplitVolumes:
2798 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2802 if ( isStudyLocked() )
2805 EmitSignalDeactivateDialog();
2806 SMESHGUI_MultiEditDlg* aDlg = NULL;
2807 if ( theCommandID == SMESHOp::OpOrientation )
2808 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2809 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2810 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2811 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2812 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2814 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2819 case SMESHOp::OpSmoothing:
2821 if(isStudyLocked()) break;
2823 EmitSignalDeactivateDialog();
2824 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2827 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2831 case SMESHOp::OpExtrusion:
2833 if (isStudyLocked()) break;
2835 EmitSignalDeactivateDialog();
2836 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2838 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2842 case SMESHOp::OpExtrusionAlongAPath:
2844 if (isStudyLocked()) break;
2846 EmitSignalDeactivateDialog();
2847 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2849 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2853 case SMESHOp::OpRevolution:
2855 if(isStudyLocked()) break;
2857 EmitSignalDeactivateDialog();
2858 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2861 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2865 case SMESHOp::OpPatternMapping:
2867 if ( isStudyLocked() )
2871 EmitSignalDeactivateDialog();
2872 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2875 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2879 case SMESHOp::OpSplitBiQuadratic:
2880 case SMESHOp::OpConvertMeshToQuadratic:
2881 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2882 case SMESHOp::OpReorientFaces:
2883 case SMESHOp::OpCreateGeometryGroup:
2885 startOperation( theCommandID );
2888 case SMESHOp::OpCreateGroup:
2892 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2896 if(isStudyLocked()) break;
2897 EmitSignalDeactivateDialog();
2898 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2900 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2901 SALOME_ListIO selected;
2903 aSel->selectedObjects( selected );
2905 int nbSel = selected.Extent();
2907 // check if mesh is selected
2908 aMesh = SMESH::GetMeshByIO( selected.First() );
2910 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2915 case SMESHOp::OpConstructGroup:
2919 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2923 if(isStudyLocked()) break;
2924 EmitSignalDeactivateDialog();
2926 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2927 SALOME_ListIO selected;
2929 aSel->selectedObjects( selected );
2931 int nbSel = selected.Extent();
2933 // check if submesh is selected
2934 Handle(SALOME_InteractiveObject) IObject = selected.First();
2935 if (IObject->hasEntry()) {
2936 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
2938 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2939 if (!aSubMesh->_is_nil()) {
2941 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2942 // get submesh elements list by types
2943 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2944 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2945 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2946 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2947 // create group for each type o elements
2948 QString aName = IObject->getName();
2949 QStringList anEntryList;
2950 if (aNodes->length() > 0) {
2951 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2952 aGroup->Add(aNodes.inout());
2953 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2954 anEntryList.append( aSObject->GetID().c_str() );
2956 if (aEdges->length() > 0) {
2957 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2958 aGroup->Add(aEdges.inout());
2959 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2960 anEntryList.append( aSObject->GetID().c_str() );
2962 if (aFaces->length() > 0) {
2963 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2964 aGroup->Add(aFaces.inout());
2965 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2966 anEntryList.append( aSObject->GetID().c_str() );
2968 if (aVolumes->length() > 0) {
2969 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2970 aGroup->Add(aVolumes.inout());
2971 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2972 anEntryList.append( aSObject->GetID().c_str() );
2975 anApp->browseObjects( anEntryList );
2977 catch(const SALOME::SALOME_Exception & S_ex){
2978 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2985 SUIT_MessageBox::warning(desktop(),
2986 tr("SMESH_WRN_WARNING"),
2987 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2992 case SMESHOp::OpEditGroup:
2996 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3000 if(isStudyLocked()) break;
3001 EmitSignalDeactivateDialog();
3003 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3004 SALOME_ListIO selected;
3006 aSel->selectedObjects( selected );
3008 SALOME_ListIteratorOfListIO It (selected);
3009 int nbSelectedGroups = 0;
3010 for ( ; It.More(); It.Next() )
3012 SMESH::SMESH_GroupBase_var aGroup =
3013 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3014 if (!aGroup->_is_nil()) {
3016 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3020 if (nbSelectedGroups == 0)
3022 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3028 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3030 if(isStudyLocked()) break;
3031 if (myState == 800) {
3032 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3033 if (aDlg) aDlg->onAdd();
3038 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3040 if(isStudyLocked()) break;
3041 if (myState == 800) {
3042 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3043 if (aDlg) aDlg->onRemove();
3048 case SMESHOp::OpEditGeomGroupAsGroup:
3052 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3056 if(isStudyLocked()) break;
3057 EmitSignalDeactivateDialog();
3059 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3060 SALOME_ListIO selected;
3062 aSel->selectedObjects( selected );
3064 SALOME_ListIteratorOfListIO It (selected);
3065 for ( ; It.More(); It.Next() )
3067 SMESH::SMESH_GroupOnGeom_var aGroup =
3068 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3069 if (!aGroup->_is_nil()) {
3070 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3075 SMESH::SMESH_GroupOnFilter_var aGroup =
3076 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3077 if (!aGroup->_is_nil()) {
3078 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3086 case SMESHOp::OpUnionGroups:
3087 case SMESHOp::OpIntersectGroups:
3088 case SMESHOp::OpCutGroups:
3092 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3096 if ( isStudyLocked() )
3099 EmitSignalDeactivateDialog();
3101 SMESHGUI_GroupOpDlg* aDlg = 0;
3102 if ( theCommandID == SMESHOp::OpUnionGroups )
3103 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3104 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3105 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3107 aDlg = new SMESHGUI_CutGroupsDlg( this );
3114 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3116 if ( isStudyLocked() )
3119 EmitSignalDeactivateDialog();
3120 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3126 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3130 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3134 if ( isStudyLocked() )
3137 EmitSignalDeactivateDialog();
3139 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3143 case SMESHOp::OpMeshInformation:
3144 case SMESHOp::OpWhatIs:
3146 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3147 EmitSignalDeactivateDialog();
3148 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3149 SALOME_ListIO selected;
3151 aSel->selectedObjects( selected );
3153 if ( selected.Extent() > 1 ) { // a dlg for each IO
3154 SALOME_ListIteratorOfListIO It( selected );
3155 for ( ; It.More(); It.Next() ) {
3156 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3157 dlg->showInfo( It.Value() );
3162 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3168 case SMESHOp::OpFindElementByPoint:
3170 startOperation( theCommandID );
3174 case SMESHOp::OpEditHypothesis:
3176 if(isStudyLocked()) break;
3178 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3179 SALOME_ListIO selected;
3181 aSel->selectedObjects( selected );
3183 int nbSel = selected.Extent();
3186 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3187 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3189 if ( !aHypothesis->_is_nil() )
3191 SMESHGUI_GenericHypothesisCreator* aCreator =
3192 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3195 // set geometry of mesh and sub-mesh to aCreator
3196 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3197 if ( selected.Extent() == 1 )
3199 QString subGeomID, meshGeomID;
3200 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3201 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3203 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3204 aCreator->setShapeEntry( subGeomID );
3205 aCreator->setMainShapeEntry( meshGeomID );
3209 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3219 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3221 if(isStudyLocked()) break;
3222 SUIT_OverrideCursor wc;
3224 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3225 SALOME_ListIO selected;
3227 aSel->selectedObjects( selected, QString::null, false );
3229 SALOME_ListIteratorOfListIO It(selected);
3230 for (int i = 0; It.More(); It.Next(), i++) {
3231 Handle(SALOME_InteractiveObject) IObject = It.Value();
3232 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3235 aSel->setSelectedObjects( l1 );
3240 case SMESHOp::OpElem0D:
3241 case SMESHOp::OpBall:
3242 case SMESHOp::OpEdge:
3243 case SMESHOp::OpTriangle:
3244 case SMESHOp::OpQuadrangle:
3245 case SMESHOp::OpPolygon:
3246 case SMESHOp::OpTetrahedron:
3247 case SMESHOp::OpHexahedron:
3248 case SMESHOp::OpPentahedron:
3249 case SMESHOp::OpPyramid:
3250 case SMESHOp::OpHexagonalPrism:
3252 if(isStudyLocked()) break;
3254 EmitSignalDeactivateDialog();
3255 SMDSAbs_EntityType type = SMDSEntity_Edge;
3256 switch (theCommandID) {
3257 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3258 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3259 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3260 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3261 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3262 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3263 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3264 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3265 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3266 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3269 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3272 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3276 case SMESHOp::OpPolyhedron:
3278 if(isStudyLocked()) break;
3280 EmitSignalDeactivateDialog();
3281 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3284 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3288 case SMESHOp::OpQuadraticEdge:
3289 case SMESHOp::OpQuadraticTriangle:
3290 case SMESHOp::OpBiQuadraticTriangle:
3291 case SMESHOp::OpQuadraticQuadrangle:
3292 case SMESHOp::OpBiQuadraticQuadrangle:
3293 case SMESHOp::OpQuadraticPolygon:
3294 case SMESHOp::OpQuadraticTetrahedron:
3295 case SMESHOp::OpQuadraticPyramid:
3296 case SMESHOp::OpQuadraticPentahedron:
3297 case SMESHOp::OpBiQuadraticPentahedron:
3298 case SMESHOp::OpQuadraticHexahedron:
3299 case SMESHOp::OpTriQuadraticHexahedron:
3301 if(isStudyLocked()) break;
3303 EmitSignalDeactivateDialog();
3304 SMDSAbs_EntityType type = SMDSEntity_Last;
3306 switch (theCommandID) {
3307 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3308 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3309 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3310 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3311 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3312 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3313 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3314 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3315 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3316 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3317 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3318 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3321 if ( type != SMDSEntity_Last )
3322 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3325 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3326 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3330 case SMESHOp::OpRemoveNodes:
3332 if(isStudyLocked()) break;
3334 EmitSignalDeactivateDialog();
3335 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3338 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3339 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3343 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3345 if(isStudyLocked()) break;
3347 EmitSignalDeactivateDialog();
3348 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3352 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3353 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3357 case SMESHOp::OpClearMesh: {
3359 if(isStudyLocked()) break;
3361 SALOME_ListIO selected;
3362 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3363 aSel->selectedObjects( selected );
3365 SUIT_OverrideCursor wc;
3366 SALOME_ListIteratorOfListIO It (selected);
3367 for ( ; It.More(); It.Next() )
3369 Handle(SALOME_InteractiveObject) IOS = It.Value();
3370 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3371 if ( aMesh->_is_nil()) continue;
3374 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3375 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3376 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3377 // hide groups and submeshes
3378 _PTR(ChildIterator) anIter =
3379 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3380 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3382 _PTR(SObject) so = anIter->Value();
3383 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3386 catch (const SALOME::SALOME_Exception& S_ex){
3388 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3392 SMESH::UpdateView();
3396 case SMESHOp::OpRemoveOrphanNodes:
3398 if(isStudyLocked()) break;
3399 SALOME_ListIO selected;
3400 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3401 aSel->selectedObjects( selected );
3402 if ( selected.Extent() == 1 ) {
3403 Handle(SALOME_InteractiveObject) anIO = selected.First();
3404 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3405 if ( !aMesh->_is_nil() ) {
3406 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3407 tr( "SMESH_WARNING" ),
3408 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3409 SUIT_MessageBox::Yes |
3410 SUIT_MessageBox::No,
3411 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3414 SUIT_OverrideCursor wc;
3415 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3416 int removed = aMeshEditor->RemoveOrphanNodes();
3417 SUIT_MessageBox::information(SMESHGUI::desktop(),
3418 tr("SMESH_INFORMATION"),
3419 tr("NB_NODES_REMOVED").arg(removed));
3420 if ( removed > 0 ) {
3421 SMESH::UpdateView();
3422 SMESHGUI::Modified();
3425 catch (const SALOME::SALOME_Exception& S_ex) {
3426 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3435 case SMESHOp::OpRenumberingNodes:
3437 if(isStudyLocked()) break;
3439 EmitSignalDeactivateDialog();
3440 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3444 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3445 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3449 case SMESHOp::OpRenumberingElements:
3451 if(isStudyLocked()) break;
3453 EmitSignalDeactivateDialog();
3454 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3458 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3459 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3463 case SMESHOp::OpTranslation:
3465 if(isStudyLocked()) break;
3467 EmitSignalDeactivateDialog();
3468 ( new SMESHGUI_TranslationDlg( this ) )->show();
3471 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3472 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3476 case SMESHOp::OpRotation:
3478 if(isStudyLocked()) break;
3480 EmitSignalDeactivateDialog();
3481 ( new SMESHGUI_RotationDlg( this ) )->show();
3484 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3485 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3489 case SMESHOp::OpSymmetry:
3491 if(isStudyLocked()) break;
3493 EmitSignalDeactivateDialog();
3494 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3497 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3498 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3502 case SMESHOp::OpScale:
3504 if(isStudyLocked()) break;
3506 EmitSignalDeactivateDialog();
3507 ( new SMESHGUI_ScaleDlg( this ) )->show();
3510 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3511 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3516 case SMESHOp::OpOffset:
3518 if(isStudyLocked()) break;
3520 EmitSignalDeactivateDialog();
3521 ( new SMESHGUI_OffsetDlg( this ) )->show();
3524 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3525 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3530 case SMESHOp::OpSewing:
3532 if(isStudyLocked()) break;
3534 EmitSignalDeactivateDialog();
3535 ( new SMESHGUI_SewingDlg( this ) )->show();
3538 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3539 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3543 case SMESHOp::OpMergeNodes:
3545 if(isStudyLocked()) break;
3547 EmitSignalDeactivateDialog();
3548 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3551 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3552 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3556 case SMESHOp::OpMergeElements:
3558 if (isStudyLocked()) break;
3560 EmitSignalDeactivateDialog();
3561 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3563 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3564 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3569 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3570 startOperation( SMESHOp::OpMoveNode );
3573 case SMESHOp::OpDuplicateNodes:
3575 if(isStudyLocked()) break;
3577 EmitSignalDeactivateDialog();
3578 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3581 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3582 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3587 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3588 startOperation( SMESHOp::OpElem0DOnElemNodes );
3591 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3593 static QList<int> aTypes;
3594 if ( aTypes.isEmpty() )
3596 aTypes.append( SMESH::NODE );
3597 aTypes.append( SMESH::EDGE );
3598 aTypes.append( SMESH::FACE );
3599 aTypes.append( SMESH::VOLUME );
3601 if (!myFilterLibraryDlg)
3602 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3603 else if (myFilterLibraryDlg->isHidden())
3604 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3605 myFilterLibraryDlg->raise();
3609 case SMESHOp::OpFreeNode:
3610 case SMESHOp::OpEqualNode:
3611 case SMESHOp::OpNodeConnectivityNb:
3612 case SMESHOp::OpFreeEdge:
3613 case SMESHOp::OpFreeBorder:
3614 case SMESHOp::OpLength:
3615 case SMESHOp::OpConnection:
3616 case SMESHOp::OpEqualEdge:
3617 case SMESHOp::OpFreeFace:
3618 case SMESHOp::OpBareBorderFace:
3619 case SMESHOp::OpOverConstrainedFace:
3620 case SMESHOp::OpLength2D:
3621 case SMESHOp::OpDeflection2D:
3622 case SMESHOp::OpConnection2D:
3623 case SMESHOp::OpArea:
3624 case SMESHOp::OpTaper:
3625 case SMESHOp::OpAspectRatio:
3626 case SMESHOp::OpMinimumAngle:
3627 case SMESHOp::OpWarpingAngle:
3628 case SMESHOp::OpSkew:
3629 case SMESHOp::OpMaxElementLength2D:
3630 case SMESHOp::OpEqualFace:
3631 case SMESHOp::OpAspectRatio3D:
3632 case SMESHOp::OpVolume:
3633 case SMESHOp::OpMaxElementLength3D:
3634 case SMESHOp::OpBareBorderVolume:
3635 case SMESHOp::OpOverConstrainedVolume:
3636 case SMESHOp::OpEqualVolume:
3639 LightApp_SelectionMgr* mgr = selectionMgr();
3640 SALOME_ListIO selected; mgr->selectedObjects( selected );
3642 if( !selected.IsEmpty() ) {
3643 SUIT_OverrideCursor wc;
3644 ::Control( theCommandID );
3647 SUIT_MessageBox::warning(desktop(),
3648 tr( "SMESH_WRN_WARNING" ),
3649 tr( "SMESH_BAD_SELECTION" ) );
3653 SUIT_MessageBox::warning(desktop(),
3654 tr( "SMESH_WRN_WARNING" ),
3655 tr( "NOT_A_VTK_VIEWER" ) );
3658 case SMESHOp::OpOverallMeshQuality:
3659 OverallMeshQuality();
3661 case SMESHOp::OpNumberingNodes:
3663 SUIT_OverrideCursor wc;
3664 LightApp_SelectionMgr* mgr = selectionMgr();
3665 SALOME_ListIO selected; mgr->selectedObjects( selected );
3667 SALOME_ListIteratorOfListIO it(selected);
3668 for( ; it.More(); it.Next()) {
3669 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3670 if(anIObject->hasEntry()) {
3671 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3672 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3678 case SMESHOp::OpNumberingElements:
3680 SUIT_OverrideCursor wc;
3681 LightApp_SelectionMgr* mgr = selectionMgr();
3682 SALOME_ListIO selected; mgr->selectedObjects( selected );
3684 SALOME_ListIteratorOfListIO it(selected);
3685 for( ; it.More(); it.Next()) {
3686 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3687 if(anIObject->hasEntry())
3688 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3689 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3694 case SMESHOp::OpPropertiesLength:
3695 case SMESHOp::OpPropertiesArea:
3696 case SMESHOp::OpPropertiesVolume:
3697 case SMESHOp::OpMinimumDistance:
3698 case SMESHOp::OpBoundingBox:
3700 int page = SMESHGUI_MeasureDlg::MinDistance;
3701 if ( theCommandID == SMESHOp::OpBoundingBox )
3702 page = SMESHGUI_MeasureDlg::BoundingBox;
3703 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3704 page = SMESHGUI_MeasureDlg::Length;
3705 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3706 page = SMESHGUI_MeasureDlg::Area;
3707 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3708 page = SMESHGUI_MeasureDlg::Volume;
3710 EmitSignalDeactivateDialog();
3711 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3715 case SMESHOp::OpSortChild:
3721 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3722 //updateObjBrowser();
3726 //=============================================================================
3730 //=============================================================================
3731 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3736 //=============================================================================
3740 //=============================================================================
3741 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3746 //=============================================================================
3750 //=============================================================================
3751 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3756 //=============================================================================
3757 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3758 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3760 //=============================================================================
3761 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3762 SUIT_ViewWindow* wnd )
3764 if(theIO->hasEntry()){
3765 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3766 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3770 //=======================================================================
3771 // function : createSMESHAction
3773 //=======================================================================
3774 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3775 const int key, const bool toggle, const QString& shortcutAction )
3778 QWidget* parent = application()->desktop();
3779 SUIT_ResourceMgr* resMgr = resourceMgr();
3781 if ( !icon_id.isEmpty() )
3782 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3784 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3785 if ( !pix.isNull() )
3786 icon = QIcon( pix );
3788 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3789 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3790 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3792 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3793 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3796 //=======================================================================
3797 // function : createPopupItem
3799 //=======================================================================
3800 void SMESHGUI::createPopupItem( const int id,
3801 const QString& clients,
3802 const QString& types,
3803 const QString& theRule,
3806 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3807 popupMgr()->insert( action( id ), pId, 0 );
3809 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3810 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3811 QString rule = "(%1) and (%2) and (%3)";
3812 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3813 if( clients.isEmpty() )
3814 rule = rule.arg( QString( "true" ) );
3816 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3817 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3820 bool cont = myRules.contains( id );
3822 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3824 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3825 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3828 //=======================================================================
3829 // function : initialize
3831 //=======================================================================
3832 void SMESHGUI::initialize( CAM_Application* app )
3834 SalomeApp_Module::initialize( app );
3836 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3838 /* Automatic Update flag */
3839 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3841 // ----- create actions --------------
3843 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3844 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3845 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3846 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3848 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3850 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3851 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3852 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3853 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3854 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3856 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3858 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3859 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3861 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3862 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3863 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3864 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3866 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3868 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3869 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3870 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3871 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3872 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3873 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3875 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3877 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3878 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3879 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3880 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3881 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3882 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3883 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3884 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3885 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3886 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3887 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3888 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3889 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3890 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3891 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3892 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3893 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3894 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3895 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3896 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3897 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3898 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3899 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3900 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3901 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3902 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3903 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3904 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3905 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3906 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3907 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3908 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3909 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3911 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3912 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3913 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3914 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3915 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3916 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3917 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3918 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3919 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3920 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3921 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3922 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3923 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
3924 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3925 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3926 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3927 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3928 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3929 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3930 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3931 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3932 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3933 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3934 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3935 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3936 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3937 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3938 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3939 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3941 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3942 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3943 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3944 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3945 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3946 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3947 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3948 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3949 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3950 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3951 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3952 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3953 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3954 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3955 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3956 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3957 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3958 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3959 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3960 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3961 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3962 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3963 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3964 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
3965 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3966 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3968 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3969 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3970 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3971 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3973 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3974 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3976 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3977 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3978 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3979 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3980 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
3981 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3982 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3983 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3984 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3985 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3986 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3987 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3988 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3989 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3990 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3991 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3992 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3993 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3994 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3995 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3996 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3997 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3998 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3999 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4000 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4002 createSMESHAction( SMESHOp::OpReset, "RESET" );
4003 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4004 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4005 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4006 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4007 #ifndef DISABLE_PLOT2DVIEWER
4008 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4010 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4011 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4012 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4013 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4014 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4015 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4016 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4017 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4018 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4019 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4020 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4021 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4022 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4024 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4025 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4027 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4028 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4029 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4030 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4031 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4032 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4033 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4034 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4035 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4037 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4038 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4039 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4040 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4041 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4043 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4044 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4045 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4047 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4049 QList<int> aCtrlActions;
4050 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4051 << SMESHOp::OpNodeConnectivityNb // node controls
4052 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4053 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4054 << SMESHOp::OpDeflection2D
4055 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4056 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4057 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4058 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4059 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4060 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4061 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4062 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4063 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4064 aCtrlGroup->setExclusive( true );
4065 for( int i = 0; i < aCtrlActions.size(); i++ )
4066 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4068 // ----- create menu --------------
4069 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4070 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4071 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4072 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4073 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4074 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4075 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4076 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4078 createMenu( separator(), fileId );
4080 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4081 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4082 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4083 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4084 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4085 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4086 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4087 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4088 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4089 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4090 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4091 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4092 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4094 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4095 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4096 createMenu( SMESHOp::OpImportMED, importId, -1 );
4097 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4099 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4101 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4102 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4103 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4104 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4105 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4106 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4108 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4110 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4111 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4112 createMenu( separator(), fileId, 10 );
4114 createMenu( SMESHOp::OpDelete, editId, -1 );
4116 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4118 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4119 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4120 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4121 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4122 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4123 createMenu( separator(), meshId, -1 );
4124 createMenu( SMESHOp::OpCompute, meshId, -1 );
4125 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4126 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4127 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4128 createMenu( separator(), meshId, -1 );
4129 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4130 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4131 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4132 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4133 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4134 createMenu( separator(), meshId, -1 );
4135 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4136 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4137 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4138 createMenu( separator(), meshId, -1 );
4139 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4140 createMenu( separator(), meshId, -1 );
4141 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4142 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4143 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4144 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4145 createMenu( separator(), meshId, -1 );
4147 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4148 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4149 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4150 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4151 createMenu( SMESHOp::OpLength, edgeId, -1 );
4152 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4153 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4154 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4155 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4156 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4157 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4158 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4159 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4160 createMenu( SMESHOp::OpArea, faceId, -1 );
4161 createMenu( SMESHOp::OpTaper, faceId, -1 );
4162 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4163 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4164 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4165 createMenu( SMESHOp::OpSkew, faceId, -1 );
4166 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4167 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4168 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4169 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4170 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4171 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4172 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4173 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4174 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4175 createMenu( separator(), ctrlId, -1 );
4176 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4177 createMenu( separator(), ctrlId, -1 );
4178 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4180 createMenu( SMESHOp::OpNode, addId, -1 );
4181 createMenu( SMESHOp::OpElem0D, addId, -1 );
4182 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4183 createMenu( SMESHOp::OpBall, addId, -1 );
4184 createMenu( SMESHOp::OpEdge, addId, -1 );
4185 createMenu( SMESHOp::OpTriangle, addId, -1 );
4186 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4187 createMenu( SMESHOp::OpPolygon, addId, -1 );
4188 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4189 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4190 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4191 createMenu( SMESHOp::OpPyramid, addId, -1 );
4192 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4193 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4194 createMenu( separator(), addId, -1 );
4195 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4196 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4197 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4198 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4199 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4200 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4201 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4202 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4203 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4204 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4205 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4206 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4208 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4209 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4210 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4211 createMenu( separator(), removeId, -1 );
4212 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4213 createMenu( separator(), removeId, -1 );
4214 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4216 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4217 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4219 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4220 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4221 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4222 createMenu( SMESHOp::OpRotation, transfId, -1 );
4223 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4224 createMenu( SMESHOp::OpScale, transfId, -1 );
4225 createMenu( SMESHOp::OpOffset, transfId, -1 );
4226 createMenu( SMESHOp::OpSewing, transfId, -1 );
4227 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4229 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4230 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4231 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4232 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4233 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4234 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4235 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4236 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4237 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4238 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4239 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4240 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4241 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4242 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4243 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4244 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4246 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4247 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4248 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4249 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4250 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4251 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4253 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4254 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4255 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4256 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4258 // ----- create toolbars --------------
4259 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4260 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4261 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4262 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4263 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4264 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4265 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4266 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4267 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4268 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4269 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4270 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4271 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4272 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4273 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4275 createTool( SMESHOp::OpCreateMesh, meshTb );
4276 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4277 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4278 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4279 createTool( SMESHOp::OpCopyMesh, meshTb );
4280 createTool( separator(), meshTb );
4281 createTool( SMESHOp::OpCompute, meshTb );
4282 createTool( SMESHOp::OpPreCompute, meshTb );
4283 createTool( SMESHOp::OpEvaluate, meshTb );
4284 createTool( SMESHOp::OpMeshOrder, meshTb );
4286 createTool( SMESHOp::OpCreateGroup, groupTb );
4287 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4288 createTool( SMESHOp::OpConstructGroup, groupTb );
4289 createTool( SMESHOp::OpEditGroup, groupTb );
4291 createTool( SMESHOp::OpMeshInformation, info );
4292 //createTool( SMESHOp::OpStdInfo, meshTb );
4293 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4294 createTool( SMESHOp::OpFindElementByPoint, info );
4296 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4297 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4298 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4300 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4301 createTool( SMESHOp::OpLength, ctrl1dTb );
4302 createTool( SMESHOp::OpConnection, ctrl1dTb );
4303 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4305 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4306 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4307 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4308 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4309 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4310 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4311 createTool( SMESHOp::OpArea, ctrl2dTb );
4312 createTool( SMESHOp::OpTaper, ctrl2dTb );
4313 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4314 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4315 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4316 createTool( SMESHOp::OpSkew, ctrl2dTb );
4317 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4318 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4319 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4321 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4322 createTool( SMESHOp::OpVolume, ctrl3dTb );
4323 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4324 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4325 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4326 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4328 createTool( SMESHOp::OpNode, addElemTb );
4329 createTool( SMESHOp::OpElem0D, addElemTb );
4330 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4331 createTool( SMESHOp::OpBall, addElemTb );
4332 createTool( SMESHOp::OpEdge, addElemTb );
4333 createTool( SMESHOp::OpTriangle, addElemTb );
4334 createTool( SMESHOp::OpQuadrangle, addElemTb );
4335 createTool( SMESHOp::OpPolygon, addElemTb );
4336 createTool( SMESHOp::OpTetrahedron, addElemTb );
4337 createTool( SMESHOp::OpHexahedron, addElemTb );
4338 createTool( SMESHOp::OpPentahedron, addElemTb );
4339 createTool( SMESHOp::OpPyramid, addElemTb );
4340 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4341 createTool( SMESHOp::OpPolyhedron, addElemTb );
4343 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4344 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4345 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4346 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4347 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4348 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4349 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4350 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4351 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4352 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4353 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4354 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4356 createTool( SMESHOp::OpRemoveNodes, remTb );
4357 createTool( SMESHOp::OpRemoveElements, remTb );
4358 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4359 createTool( SMESHOp::OpClearMesh, remTb );
4361 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4362 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4364 createTool( SMESHOp::OpMergeNodes, transformTb );
4365 createTool( SMESHOp::OpMergeElements, transformTb );
4366 createTool( SMESHOp::OpTranslation, transformTb );
4367 createTool( SMESHOp::OpRotation, transformTb );
4368 createTool( SMESHOp::OpSymmetry, transformTb );
4369 createTool( SMESHOp::OpScale, transformTb );
4370 createTool( SMESHOp::OpOffset, transformTb );
4371 createTool( SMESHOp::OpSewing, transformTb );
4372 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4374 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4375 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4376 createTool( SMESHOp::OpExtrusion, modifyTb );
4377 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4378 createTool( SMESHOp::OpRevolution, modifyTb );
4379 createTool( SMESHOp::OpOrientation, modifyTb );
4380 createTool( SMESHOp::OpReorientFaces, modifyTb );
4381 createTool( SMESHOp::OpMoveNode, modifyTb );
4382 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4383 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4384 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4385 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4386 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4387 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4388 createTool( SMESHOp::OpSmoothing, modifyTb );
4389 createTool( SMESHOp::OpPatternMapping, modifyTb );
4391 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4393 createTool( SMESHOp::OpUpdate, dispModeTb );
4395 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4396 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4400 OB = "'ObjectBrowser'",
4401 View = "'" + SVTK_Viewer::Type() + "'",
4403 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4404 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4405 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4406 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4407 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4408 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4409 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4410 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4411 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4412 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4413 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4414 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4416 mesh_part = mesh + " " + subMesh + " " + group,
4417 mesh_group = mesh + " " + group,
4418 mesh_submesh = mesh + " " + subMesh,
4419 hyp_alg = hypo + " " + algo;
4421 // popup for object browser
4423 isInvisible("not( isVisible )"),
4424 isEmpty("numberOfNodes = 0"),
4425 isNotEmpty("numberOfNodes <> 0"),
4427 // has nodes, edges, etc in VISIBLE! actor
4428 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4429 hasElems("(count( elemTypes ) > 0)"),
4430 hasDifferentElems("(count( elemTypes ) > 1)"),
4431 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4432 hasBalls("({'BallElem'} in elemTypes)"),
4433 hasElems0d("({'Elem0d'} in elemTypes)"),
4434 hasEdges("({'Edge'} in elemTypes)"),
4435 hasFaces("({'Face'} in elemTypes)"),
4436 hasVolumes("({'Volume'} in elemTypes)"),
4437 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4439 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4440 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4441 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4442 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4443 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4444 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4446 popupMgr()->insert( separator(), -1, 0 );
4447 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4448 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4449 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4450 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4451 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4452 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4453 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4454 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4455 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4456 popupMgr()->insert( separator(), -1, 0 );
4457 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4458 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4459 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4460 popupMgr()->insert( separator(), -1, 0 );
4461 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4462 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4463 popupMgr()->insert( separator(), -1, 0 );
4464 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4465 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4466 popupMgr()->insert( separator(), -1, 0 );
4467 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4468 //popupMgr()->insert( separator(), -1, 0 );
4470 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4471 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4472 QString only_one_2D = only_one_non_empty + " && dim>1";
4474 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4475 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4476 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4477 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4479 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4481 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4482 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4483 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4484 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4485 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4487 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4488 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4489 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4490 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4492 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4494 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4495 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4496 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4497 popupMgr()->insert( separator(), -1, 0 );
4500 createPopupItem( SMESHOp::OpEditGroup, View, group );
4501 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4502 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4504 popupMgr()->insert( separator(), -1, 0 );
4505 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4506 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4507 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4508 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4509 popupMgr()->insert( separator(), -1, 0 );
4511 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4512 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4513 popupMgr()->insert( separator(), -1, 0 );
4515 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4516 QString aType = QString( "%1type in {%2}" ).arg( lc );
4517 aType = aType.arg( mesh_part );
4518 QString aMeshInVTK = aClient + "&&" + aType;
4520 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4521 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4522 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4524 //-------------------------------------------------
4526 //-------------------------------------------------
4527 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4529 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4530 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4531 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4533 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4534 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4535 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4537 popupMgr()->insert( separator(), -1, -1 );
4539 //-------------------------------------------------
4541 //-------------------------------------------------
4542 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4544 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4545 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4546 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4548 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4549 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4550 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4552 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4553 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4554 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4556 popupMgr()->insert( separator(), anId, -1 );
4558 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4559 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4560 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4562 //-------------------------------------------------
4564 //-------------------------------------------------
4565 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4567 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4569 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4570 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4571 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4573 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4574 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4575 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4577 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4578 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4579 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4581 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4582 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4583 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4585 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4586 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4587 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4589 popupMgr()->insert( separator(), anId, -1 );
4591 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4592 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4594 popupMgr()->insert( separator(), anId, -1 );
4596 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4597 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4600 //-------------------------------------------------
4601 // Representation of the 2D Quadratic elements
4602 //-------------------------------------------------
4603 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4604 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4605 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4606 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4608 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4609 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4610 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4612 //-------------------------------------------------
4613 // Orientation of faces
4614 //-------------------------------------------------
4615 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4616 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4617 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4619 //-------------------------------------------------
4621 //-------------------------------------------------
4622 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4623 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4625 //-------------------------------------------------
4627 //-------------------------------------------------
4628 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4629 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4631 //-------------------------------------------------
4633 //-------------------------------------------------
4635 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4636 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4637 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4638 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4640 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4642 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4643 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4645 popupMgr()->insert( separator(), anId, -1 );
4647 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4649 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4650 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4651 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4653 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4654 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4655 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4657 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4658 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4659 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4661 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4663 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4664 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4665 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4667 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4668 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4669 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4671 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4672 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4673 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4674 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4675 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4676 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4678 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4680 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4681 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4682 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4684 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4685 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4686 QtxPopupMgr::VisibleRule );
4687 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4689 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4690 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4691 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4693 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4694 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4695 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4697 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4698 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4699 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4701 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4702 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4703 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4705 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4706 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4707 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4709 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4710 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4711 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4713 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4714 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4715 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4717 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4718 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4719 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4721 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4722 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4723 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4725 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4726 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4727 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4729 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4730 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4731 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4733 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4734 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4735 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4737 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4738 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4739 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4741 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4743 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4744 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4745 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4747 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4748 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4749 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4751 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4752 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4753 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4755 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4756 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4757 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4759 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4760 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4761 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4763 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4764 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4765 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4767 popupMgr()->insert( separator(), anId, -1 );
4769 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4770 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4771 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4772 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4773 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4775 popupMgr()->insert( separator(), anId, -1 );
4777 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4779 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4780 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4782 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4783 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4784 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4786 #ifndef DISABLE_PLOT2DVIEWER
4787 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4788 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4791 //-------------------------------------------------
4793 //-------------------------------------------------
4794 popupMgr()->insert( separator(), -1, -1 );
4795 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4796 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4797 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4798 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4800 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4801 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4803 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4804 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4806 popupMgr()->insert( separator(), -1, -1 );
4808 //-------------------------------------------------
4810 //-------------------------------------------------
4811 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4812 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4814 popupMgr()->insert( separator(), -1, -1 );
4816 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4817 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4818 popupMgr()->insert( separator(), -1, -1 );
4820 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4821 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4823 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4824 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4827 //================================================================================
4829 * \brief Return true if SMESH or GEOM objects are selected.
4830 * Is called form LightApp_Module::activateModule() which clear selection if
4831 * not isSelectionCompatible()
4833 //================================================================================
4835 bool SMESHGUI::isSelectionCompatible()
4837 bool isCompatible = true;
4838 SALOME_ListIO selected;
4839 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4840 Sel->selectedObjects( selected );
4842 SALOME_ListIteratorOfListIO It( selected );
4843 for ( ; isCompatible && It.More(); It.Next())
4845 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4846 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4848 return isCompatible;
4852 bool SMESHGUI::reusableOperation( const int id )
4854 // compute, evaluate and precompute are not reusable operations
4855 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4858 bool SMESHGUI::activateModule( SUIT_Study* study )
4860 bool res = SalomeApp_Module::activateModule( study );
4862 setMenuShown( true );
4863 setToolShown( true );
4865 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4866 PyGILState_STATE gstate = PyGILState_Ensure();
4867 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4868 if ( !pluginsmanager ) {
4872 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4877 PyGILState_Release(gstate);
4878 // end of SMESH plugins loading
4880 // Reset actions accelerator keys
4881 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4883 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4884 GetSMESHGen()->UpdateStudy();
4886 // get all view currently opened in the study and connect their signals to
4887 // the corresponding slots of the class.
4888 SUIT_Desktop* aDesk = study->application()->desktop();
4890 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4891 SUIT_ViewWindow* wnd;
4892 foreach ( wnd, wndList )
4896 Py_XDECREF(pluginsmanager);
4900 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4902 setMenuShown( false );
4903 setToolShown( false );
4905 EmitSignalCloseAllDialogs();
4907 // Unset actions accelerator keys
4908 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4910 return SalomeApp_Module::deactivateModule( study );
4913 void SMESHGUI::studyClosed( SUIT_Study* s )
4917 SMESH::RemoveVisuData();
4918 SalomeApp_Module::studyClosed( s );
4921 void SMESHGUI::OnGUIEvent()
4923 const QObject* obj = sender();
4924 if ( !obj || !obj->inherits( "QAction" ) )
4926 int id = actionId((QAction*)obj);
4931 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4933 if ( CORBA::is_nil( myComponentSMESH ) )
4935 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4936 return aGUI.myComponentSMESH;
4938 return myComponentSMESH;
4941 QString SMESHGUI::engineIOR() const
4943 CORBA::ORB_var anORB = getApp()->orb();
4944 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4945 return QString( anIOR.in() );
4948 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4950 SalomeApp_Module::contextMenuPopup( client, menu, title );
4952 selectionMgr()->selectedObjects( lst );
4953 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4954 Handle(SALOME_InteractiveObject) io = lst.First();
4955 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4956 _PTR(Study) study = appStudy->studyDS();
4957 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4959 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4960 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4961 aName.remove( (aName.length() - 1), 1 );
4967 LightApp_Selection* SMESHGUI::createSelection() const
4969 return new SMESHGUI_Selection();
4972 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4974 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4975 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4976 #ifndef DISABLE_PYCONSOLE
4977 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4981 void SMESHGUI::viewManagers( QStringList& list ) const
4983 list.append( SVTK_Viewer::Type() );
4986 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4988 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4989 SMESH::UpdateSelectionProp( this );
4991 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4992 for(int i = 0; i < aViews.count() ; i++){
4993 SUIT_ViewWindow *sf = aViews[i];
4996 EmitSignalActivatedViewManager();
5000 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5002 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5003 myClippingPlaneInfoMap.erase( theViewManager );
5006 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5008 theActor->AddObserver( SMESH::DeleteActorEvent,
5009 myEventCallbackCommand.GetPointer(),
5013 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5014 unsigned long theEvent,
5015 void* theClientData,
5018 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5019 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5020 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5021 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5022 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5023 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5024 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5025 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5026 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5027 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5028 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5029 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5030 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5031 if( anActor == *anIter3 ) {
5032 anActorList.erase( anIter3 );
5043 void SMESHGUI::createPreferences()
5045 // General tab ------------------------------------------------------------------------
5046 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5048 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5049 setPreferenceProperty( autoUpdate, "columns", 2 );
5050 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5051 setPreferenceProperty( lim, "min", 0 );
5052 setPreferenceProperty( lim, "max", 100000000 );
5053 setPreferenceProperty( lim, "step", 1000 );
5054 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5055 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5057 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5058 setPreferenceProperty( dispgroup, "columns", 2 );
5059 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5061 modes.append( tr("MEN_WIRE") );
5062 modes.append( tr("MEN_SHADE") );
5063 modes.append( tr("MEN_NODES") );
5064 modes.append( tr("MEN_SHRINK") );
5065 QList<QVariant> indices;
5066 indices.append( 0 );
5067 indices.append( 1 );
5068 indices.append( 2 );
5069 indices.append( 3 );
5070 setPreferenceProperty( dispmode, "strings", modes );
5071 setPreferenceProperty( dispmode, "indexes", indices );
5073 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5074 setPreferenceProperty( arcgroup, "columns", 2 );
5075 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5076 QStringList quadraticModes;
5077 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5078 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5080 indices.append( 0 );
5081 indices.append( 1 );
5082 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5083 setPreferenceProperty( quadraticmode, "indexes", indices );
5085 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5086 "SMESH", "max_angle" );
5087 setPreferenceProperty( maxAngle, "min", 1 );
5088 setPreferenceProperty( maxAngle, "max", 90 );
5090 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5091 setPreferenceProperty( qaGroup, "columns", 2 );
5092 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5093 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5094 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5095 setPreferenceProperty( prec, "min", 0 );
5096 setPreferenceProperty( prec, "max", 100 );
5097 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5098 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5099 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5100 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5101 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5104 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5105 setPreferenceProperty( exportgroup, "columns", 2 );
5106 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5107 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5108 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5110 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5111 setPreferenceProperty( computeGroup, "columns", 2 );
5112 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5114 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5115 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5116 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5118 indices.append( 0 );
5119 indices.append( 1 );
5120 indices.append( 2 );
5121 setPreferenceProperty( notifyMode, "strings", modes );
5122 setPreferenceProperty( notifyMode, "indexes", indices );
5124 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5125 setPreferenceProperty( infoGroup, "columns", 2 );
5126 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5128 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5129 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5131 indices.append( 0 );
5132 indices.append( 1 );
5133 setPreferenceProperty( elemInfo, "strings", modes );
5134 setPreferenceProperty( elemInfo, "indexes", indices );
5135 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5136 setPreferenceProperty( nodesLim, "min", 0 );
5137 setPreferenceProperty( nodesLim, "max", 10000000 );
5138 setPreferenceProperty( nodesLim, "step", 10000 );
5139 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5140 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5141 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5142 setPreferenceProperty( ctrlLim, "min", 0 );
5143 setPreferenceProperty( ctrlLim, "max", 10000000 );
5144 setPreferenceProperty( ctrlLim, "step", 1000 );
5145 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5146 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5147 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5148 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5149 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5151 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5152 setPreferenceProperty( segGroup, "columns", 2 );
5153 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5154 "SMESH", "segmentation" );
5155 setPreferenceProperty( segLen, "min", 1 );
5156 setPreferenceProperty( segLen, "max", 10000000 );
5157 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5158 "SMESH", "nb_segments_per_edge" );
5159 setPreferenceProperty( nbSeg, "min", 1 );
5160 setPreferenceProperty( nbSeg, "max", 10000000 );
5162 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5163 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5164 "SMESH", "forget_mesh_on_hyp_modif" );
5167 // Quantities with individual precision settings
5168 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5169 setPreferenceProperty( precGroup, "columns", 2 );
5171 const int nbQuantities = 6;
5172 int precs[nbQuantities], ii = 0;
5173 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5174 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5175 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5176 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5177 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5178 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5179 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5180 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5181 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5182 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5183 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5184 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5186 // Set property for precision value for spinboxes
5187 for ( ii = 0; ii < nbQuantities; ii++ ){
5188 setPreferenceProperty( precs[ii], "min", -14 );
5189 setPreferenceProperty( precs[ii], "max", 14 );
5190 setPreferenceProperty( precs[ii], "precision", 2 );
5193 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5194 setPreferenceProperty( previewGroup, "columns", 2 );
5195 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5196 setPreferenceProperty( chunkSize, "min", 1 );
5197 setPreferenceProperty( chunkSize, "max", 1000 );
5198 setPreferenceProperty( chunkSize, "step", 50 );
5200 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5201 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5203 // Mesh tab ------------------------------------------------------------------------
5204 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5205 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5206 setPreferenceProperty( nodeGroup, "columns", 3 );
5208 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5210 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5212 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5213 QList<QVariant> aMarkerTypeIndicesList;
5214 QList<QVariant> aMarkerTypeIconsList;
5215 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5216 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5217 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5218 aMarkerTypeIndicesList << i;
5219 aMarkerTypeIconsList << pixmap;
5221 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5222 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5224 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5226 QList<QVariant> aMarkerScaleIndicesList;
5227 QStringList aMarkerScaleValuesList;
5228 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5229 aMarkerScaleIndicesList << i;
5230 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5231 aMarkerScaleValuesList << QString::number( i );
5233 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5234 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5236 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5237 //setPreferenceProperty( elemGroup, "columns", 2 );
5239 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5240 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5241 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5242 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5243 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5244 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5245 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5246 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5247 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5250 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5251 setPreferenceProperty( grpGroup, "columns", 2 );
5253 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5254 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5256 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5257 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5258 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5259 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5260 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5261 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5262 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5263 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5264 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5265 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5266 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5267 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5268 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5269 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5271 setPreferenceProperty( size0d, "min", 1 );
5272 setPreferenceProperty( size0d, "max", 10 );
5274 // setPreferenceProperty( ballSize, "min", 1 );
5275 // setPreferenceProperty( ballSize, "max", 10 );
5277 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5278 setPreferenceProperty( ballDiameter, "max", 1e9 );
5279 setPreferenceProperty( ballDiameter, "step", 0.1 );
5281 setPreferenceProperty( ballScale, "min", 1e-2 );
5282 setPreferenceProperty( ballScale, "max", 1e7 );
5283 setPreferenceProperty( ballScale, "step", 0.5 );
5285 setPreferenceProperty( elemW, "min", 1 );
5286 setPreferenceProperty( elemW, "max", 5 );
5288 setPreferenceProperty( outW, "min", 1 );
5289 setPreferenceProperty( outW, "max", 5 );
5291 setPreferenceProperty( shrink, "min", 0 );
5292 setPreferenceProperty( shrink, "max", 100 );
5294 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5295 setPreferenceProperty( numGroup, "columns", 2 );
5297 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5298 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5300 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5301 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5303 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5304 setPreferenceProperty( orientGroup, "columns", 1 );
5306 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5307 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5309 setPreferenceProperty( orientScale, "min", 0.05 );
5310 setPreferenceProperty( orientScale, "max", 0.5 );
5311 setPreferenceProperty( orientScale, "step", 0.05 );
5313 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5315 // Selection tab ------------------------------------------------------------------------
5316 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5318 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5319 setPreferenceProperty( selGroup, "columns", 2 );
5321 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5322 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5324 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5325 setPreferenceProperty( preGroup, "columns", 2 );
5327 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5329 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5330 setPreferenceProperty( precSelGroup, "columns", 2 );
5332 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5333 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5334 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5336 // Scalar Bar tab ------------------------------------------------------------------------
5337 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5338 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5339 setPreferenceProperty( fontGr, "columns", 2 );
5341 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5342 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5344 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5345 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5347 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5348 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5350 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5351 setPreferenceProperty( numcol, "min", 2 );
5352 setPreferenceProperty( numcol, "max", 256 );
5354 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5355 setPreferenceProperty( numlab, "min", 2 );
5356 setPreferenceProperty( numlab, "max", 65 );
5358 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5359 setPreferenceProperty( orientGr, "columns", 2 );
5360 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5361 QStringList orients;
5362 orients.append( tr( "SMESH_VERTICAL" ) );
5363 orients.append( tr( "SMESH_HORIZONTAL" ) );
5364 indices.clear(); indices.append( 0 ); indices.append( 1 );
5365 setPreferenceProperty( orient, "strings", orients );
5366 setPreferenceProperty( orient, "indexes", indices );
5368 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5369 setPreferenceProperty( posVSizeGr, "columns", 2 );
5370 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5371 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5372 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5373 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5374 setPreferenceProperty( xv, "step", 0.1 );
5375 setPreferenceProperty( xv, "min", 0.0 );
5376 setPreferenceProperty( xv, "max", 1.0 );
5377 setPreferenceProperty( yv, "step", 0.1 );
5378 setPreferenceProperty( yv, "min", 0.0 );
5379 setPreferenceProperty( yv, "max", 1.0 );
5380 setPreferenceProperty( wv, "step", 0.1 );
5381 setPreferenceProperty( wv, "min", 0.0 );
5382 setPreferenceProperty( wv, "max", 1.0 );
5383 setPreferenceProperty( hv, "min", 0.0 );
5384 setPreferenceProperty( hv, "max", 1.0 );
5385 setPreferenceProperty( hv, "step", 0.1 );
5387 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5388 setPreferenceProperty( posHSizeGr, "columns", 2 );
5389 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5390 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5391 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5392 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5393 setPreferenceProperty( xv, "min", 0.0 );
5394 setPreferenceProperty( xv, "max", 1.0 );
5395 setPreferenceProperty( xv, "step", 0.1 );
5396 setPreferenceProperty( xh, "min", 0.0 );
5397 setPreferenceProperty( xh, "max", 1.0 );
5398 setPreferenceProperty( xh, "step", 0.1 );
5399 setPreferenceProperty( yh, "min", 0.0 );
5400 setPreferenceProperty( yh, "max", 1.0 );
5401 setPreferenceProperty( yh, "step", 0.1 );
5402 setPreferenceProperty( wh, "min", 0.0 );
5403 setPreferenceProperty( wh, "max", 1.0 );
5404 setPreferenceProperty( wh, "step", 0.1 );
5405 setPreferenceProperty( hh, "min", 0.0 );
5406 setPreferenceProperty( hh, "max", 1.0 );
5407 setPreferenceProperty( hh, "step", 0.1 );
5409 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5410 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5411 setPreferenceProperty( distributionGr, "columns", 3 );
5413 types.append( tr( "SMESH_MONOCOLOR" ) );
5414 types.append( tr( "SMESH_MULTICOLOR" ) );
5415 indices.clear(); indices.append( 0 ); indices.append( 1 );
5416 setPreferenceProperty( coloringType, "strings", types );
5417 setPreferenceProperty( coloringType, "indexes", indices );
5418 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5422 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5424 if ( sect=="SMESH" ) {
5425 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5426 float aTol = 1.00000009999999;
5427 std::string aWarning;
5428 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5430 if ( name== "selection_object_color" ||
5431 name=="selection_element_color" ||
5432 name== "highlight_color" ||
5433 name=="selection_precision_node" ||
5434 name=="selection_precision_element" ||
5435 name=="selection_precision_object" )
5437 SMESH::UpdateSelectionProp( this );
5439 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5441 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5442 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5443 if ( sbX1+sbW > aTol ) {
5444 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5447 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5448 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5451 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5453 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5454 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5455 if ( sbY1 + sbH > aTol ) {
5456 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5457 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5458 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5461 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5463 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5464 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5465 if ( sbX1 + sbW > aTol ) {
5466 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5469 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5470 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5473 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5475 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5476 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5477 if ( sbY1 + sbH > aTol ) {
5478 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5481 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5482 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5485 else if ( name == "segmentation" )
5487 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5488 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5490 else if ( name == "nb_segments_per_edge" )
5492 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5493 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5495 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5497 QString val = aResourceMgr->stringValue( "SMESH", name );
5498 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5500 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5502 SMESH::UpdateFontProp( this );
5504 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5506 SMESH::UpdateFontProp( this );
5509 if ( aWarning.size() != 0 ) {
5510 aWarning += "The default values are applied instead.";
5511 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5512 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5513 QObject::tr(aWarning.c_str()));
5518 //================================================================================
5520 * \brief Update something in accordance with update flags
5521 * \param theFlags - update flags
5523 * Update viewer or/and object browser etc. in accordance with update flags ( see
5524 * LightApp_UpdateFlags enumeration ).
5526 //================================================================================
5527 void SMESHGUI::update( const int flags )
5529 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5530 SMESH::UpdateView();
5532 SalomeApp_Module::update( flags );
5535 //================================================================================
5537 * \brief Set default selection mode
5539 * SLOT called when operation committed. Sets default selection mode
5541 //================================================================================
5542 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5544 SVTK_ViewWindow* vtkWnd =
5545 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5547 vtkWnd->SetSelectionMode( ActorSelection );
5550 //================================================================================
5552 * \brief Set default selection mode
5554 * SLOT called when operation aborted. Sets default selection mode
5556 //================================================================================
5557 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5559 SVTK_ViewWindow* vtkWnd =
5560 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5562 vtkWnd->SetSelectionMode( ActorSelection );
5565 //================================================================================
5567 * \brief Creates operation with given identifier
5568 * \param id - identifier of operation to be started
5569 * \return Pointer on created operation or NULL if operation is not created
5571 * Virtual method redefined from the base class creates operation with given id.
5572 * It is called called automatically from startOperation method of base class.
5574 //================================================================================
5575 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5577 LightApp_Operation* op = 0;
5578 // to do : create operation here
5581 case SMESHOp::OpSplitBiQuadratic:
5582 op = new SMESHGUI_SplitBiQuadOp();
5584 case SMESHOp::OpConvertMeshToQuadratic:
5585 op = new SMESHGUI_ConvToQuadOp();
5587 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5588 op = new SMESHGUI_Make2DFrom3DOp();
5590 case SMESHOp::OpReorientFaces:
5591 op = new SMESHGUI_ReorientFacesOp();
5593 case SMESHOp::OpCreateMesh:
5594 op = new SMESHGUI_MeshOp( true, true );
5596 case SMESHOp::OpCreateSubMesh:
5597 op = new SMESHGUI_MeshOp( true, false );
5599 case SMESHOp::OpEditMeshOrSubMesh:
5600 case SMESHOp::OpEditMesh:
5601 case SMESHOp::OpEditSubMesh:
5602 op = new SMESHGUI_MeshOp( false );
5604 case SMESHOp::OpCompute:
5605 case SMESHOp::OpComputeSubMesh:
5606 op = new SMESHGUI_ComputeOp();
5608 case SMESHOp::OpPreCompute:
5609 op = new SMESHGUI_PrecomputeOp();
5611 case SMESHOp::OpEvaluate:
5612 op = new SMESHGUI_EvaluateOp();
5614 case SMESHOp::OpMeshOrder:
5615 op = new SMESHGUI_MeshOrderOp();
5617 case SMESHOp::OpCreateGeometryGroup:
5618 op = new SMESHGUI_GroupOnShapeOp();
5620 case SMESHOp::OpFindElementByPoint:
5621 op = new SMESHGUI_FindElemByPointOp();
5623 case SMESHOp::OpMoveNode: // Make mesh pass through point
5624 op = new SMESHGUI_MakeNodeAtPointOp();
5626 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5627 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5634 op = SalomeApp_Module::createOperation( id );
5638 //================================================================================
5640 * \brief Stops current operations and starts a given one
5641 * \param id - The id of the operation to start
5643 //================================================================================
5645 void SMESHGUI::switchToOperation(int id)
5647 activeStudy()->abortAllOperations();
5648 startOperation( id );
5651 LightApp_Displayer* SMESHGUI::displayer()
5654 myDisplayer = new SMESHGUI_Displayer( getApp() );
5658 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5661 int aTolerance = 64;
5662 int anIterations = 0;
5668 if( anIterations % aPeriod == 0 )
5671 if( aTolerance < 1 )
5675 aHue = (int)( 360.0 * rand() / RAND_MAX );
5678 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5679 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5680 for( ; it != itEnd; ++it )
5682 SALOMEDS::Color anAutoColor = *it;
5683 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5686 aQColor.getHsv( &h, &s, &v );
5687 if( abs( h - aHue ) < aTolerance )
5699 aColor.setHsv( aHue, 255, 255 );
5701 SALOMEDS::Color aSColor;
5702 aSColor.R = aColor.redF();
5703 aSColor.G = aColor.greenF();
5704 aSColor.B = aColor.blueF();
5709 const char* gSeparator = "_"; // character used to separate parameter names
5710 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5711 const char* gPathSep = "|"; // character used to separate paths
5714 * \brief Store visual parameters
5716 * This method is called just before the study document is saved.
5717 * Store visual parameters in AttributeParameter attribue(s)
5719 void SMESHGUI::storeVisualParameters (int savePoint)
5722 Kernel_Utils::Localizer loc;
5724 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5725 if (!appStudy || !appStudy->studyDS())
5727 _PTR(Study) studyDS = appStudy->studyDS();
5729 // componentName is used for encoding of entries when storing them in IParameters
5730 std::string componentName = myComponentSMESH->ComponentDataType();
5731 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5732 //if (!aSComponent) return;
5735 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5736 componentName.c_str(),
5738 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5740 // store custom markers
5741 if( !myMarkerMap.empty() )
5743 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5744 for( ; anIter != myMarkerMap.end(); anIter++ )
5746 int anId = anIter->first;
5747 VTK::MarkerData aMarkerData = anIter->second;
5748 std::string aMarkerFileName = aMarkerData.first;
5749 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5750 if( aMarkerTexture.size() < 3 )
5751 continue; // should contain at least width, height and the first value
5753 QString aPropertyName( "texture" );
5754 aPropertyName += gSeparator;
5755 aPropertyName += QString::number( anId );
5757 QString aPropertyValue = aMarkerFileName.c_str();
5758 aPropertyValue += gPathSep;
5760 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5761 ushort aWidth = *aTextureIter++;
5762 ushort aHeight = *aTextureIter++;
5763 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5764 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5765 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5766 aPropertyValue += QString::number( *aTextureIter );
5768 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5772 // viewers counters are used for storing view_numbers in IParameters
5775 // main cycle to store parameters of displayed objects
5776 QList<SUIT_ViewManager*> lst;
5777 QList<SUIT_ViewManager*>::Iterator it;
5778 getApp()->viewManagers(lst);
5779 for (it = lst.begin(); it != lst.end(); it++)
5781 SUIT_ViewManager* vman = *it;
5782 QString vType = vman->getType();
5784 // saving VTK actors properties
5785 if (vType == SVTK_Viewer::Type())
5787 // store the clipping planes attached to the view manager
5788 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5789 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5790 if( anIter != myClippingPlaneInfoMap.end() )
5791 aClippingPlaneInfoList = anIter->second;
5793 if( !aClippingPlaneInfoList.empty() ) {
5794 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5795 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5797 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5798 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5800 QString aPropertyName( "ClippingPlane" );
5801 aPropertyName += gSeparator;
5802 aPropertyName += QString::number( vtkViewers );
5803 aPropertyName += gSeparator;
5804 aPropertyName += QString::number( anId );
5806 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5807 aPropertyValue += gDigitsSep;
5808 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5809 aPropertyValue += gDigitsSep;
5810 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5811 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5812 aPropertyValue += gDigitsSep;
5813 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5814 aPropertyValue += gDigitsSep;
5815 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5816 aPropertyValue += gDigitsSep;
5817 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5818 aPropertyValue += gDigitsSep;
5819 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5820 aPropertyValue += gDigitsSep;
5821 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5822 aPropertyValue += gDigitsSep;
5823 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5825 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5826 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5827 aPropertyValue += gDigitsSep;
5828 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5829 aPropertyValue += gDigitsSep;
5830 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5831 aPropertyValue += gDigitsSep;
5832 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5835 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5839 QVector<SUIT_ViewWindow*> views = vman->getViews();
5840 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5842 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5844 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5845 vtkActorCollection* allActors = aCopy.GetActors();
5846 allActors->InitTraversal();
5847 while (vtkActor* actor = allActors->GetNextActor())
5849 if (actor->GetVisibility()) // store only visible actors
5851 SMESH_Actor* aSmeshActor = 0;
5852 if (actor->IsA("SMESH_Actor"))
5853 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5854 if (aSmeshActor && aSmeshActor->hasIO())
5856 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5859 // entry is "encoded" = it does NOT contain component address,
5860 // since it is a subject to change on next component loading
5861 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5863 std::string param, vtkParam = vType.toLatin1().data();
5864 vtkParam += gSeparator;
5865 vtkParam += QString::number(vtkViewers).toLatin1().data();
5866 vtkParam += gSeparator;
5869 param = vtkParam + "Visibility";
5870 ip->setParameter(entry, param, "On");
5873 param = vtkParam + "Representation";
5874 ip->setParameter(entry, param, QString::number
5875 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5878 param = vtkParam + "IsShrunk";
5879 ip->setParameter(entry, param, QString::number
5880 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5882 // Displayed entities
5883 unsigned int aMode = aSmeshActor->GetEntityMode();
5884 bool isE = aMode & SMESH_Actor::eEdges;
5885 bool isF = aMode & SMESH_Actor::eFaces;
5886 bool isV = aMode & SMESH_Actor::eVolumes;
5887 bool is0d = aMode & SMESH_Actor::e0DElements;
5888 bool isB = aMode & SMESH_Actor::eBallElem;
5890 QString modeStr ("e");
5891 modeStr += gDigitsSep; modeStr += QString::number(isE);
5892 modeStr += gDigitsSep; modeStr += "f";
5893 modeStr += gDigitsSep; modeStr += QString::number(isF);
5894 modeStr += gDigitsSep; modeStr += "v";
5895 modeStr += gDigitsSep; modeStr += QString::number(isV);
5896 modeStr += gDigitsSep; modeStr += "0d";
5897 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5898 modeStr += gDigitsSep; modeStr += "b";
5899 modeStr += gDigitsSep; modeStr += QString::number(isB);
5901 param = vtkParam + "Entities";
5902 ip->setParameter(entry, param, modeStr.toLatin1().data());
5908 aSmeshActor->GetSufaceColor(r, g, b, delta);
5909 QStringList colorStr;
5910 colorStr << "surface";
5911 colorStr << QString::number(r);
5912 colorStr << QString::number(g);
5913 colorStr << QString::number(b);
5915 colorStr << "backsurface";
5916 colorStr << QString::number(delta);
5918 aSmeshActor->GetVolumeColor(r, g, b, delta);
5919 colorStr << "volume";
5920 colorStr << QString::number(r);
5921 colorStr << QString::number(g);
5922 colorStr << QString::number(b);
5923 colorStr << QString::number(delta);
5925 aSmeshActor->GetEdgeColor(r, g, b);
5927 colorStr << QString::number(r);
5928 colorStr << QString::number(g);
5929 colorStr << QString::number(b);
5931 aSmeshActor->GetNodeColor(r, g, b);
5933 colorStr << QString::number(r);
5934 colorStr << QString::number(g);
5935 colorStr << QString::number(b);
5937 aSmeshActor->GetOutlineColor(r, g, b);
5938 colorStr << "outline";
5939 colorStr << QString::number(r);
5940 colorStr << QString::number(g);
5941 colorStr << QString::number(b);
5943 aSmeshActor->Get0DColor(r, g, b);
5944 colorStr << "elem0d";
5945 colorStr << QString::number(r);
5946 colorStr << QString::number(g);
5947 colorStr << QString::number(b);
5949 aSmeshActor->GetBallColor(r, g, b);
5951 colorStr << QString::number(r);
5952 colorStr << QString::number(g);
5953 colorStr << QString::number(b);
5955 aSmeshActor->GetFacesOrientationColor(r, g, b);
5956 colorStr << "orientation";
5957 colorStr << QString::number(r);
5958 colorStr << QString::number(g);
5959 colorStr << QString::number(b);
5961 param = vtkParam + "Colors";
5962 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5965 QStringList sizeStr;
5967 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5968 sizeStr << "outline";
5969 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5970 sizeStr << "elem0d";
5971 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5973 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5974 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5975 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5976 sizeStr << "shrink";
5977 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5978 sizeStr << "orientation";
5979 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5980 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5982 param = vtkParam + "Sizes";
5983 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5988 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5989 if( aMarkerType == VTK::MT_USER ) {
5990 markerStr += "custom";
5991 markerStr += gDigitsSep;
5992 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5996 markerStr += gDigitsSep;
5997 markerStr += QString::number( (int)aMarkerType );
5998 markerStr += gDigitsSep;
5999 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6002 param = vtkParam + "PointMarker";
6003 ip->setParameter(entry, param, markerStr.toLatin1().data());
6006 param = vtkParam + "Opacity";
6007 ip->setParameter(entry, param,
6008 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6011 param = vtkParam + "ClippingPlane";
6013 if( !aClippingPlaneInfoList.empty() ) {
6014 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6015 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6017 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6018 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6019 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6020 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6021 if( aSmeshActor == *anIter2 ) {
6022 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6023 QString::number( anId ).toLatin1().constData() );
6030 ip->setParameter( entry, param, "Off" );
6031 } // if (io->hasEntry())
6032 } // SMESH_Actor && hasIO
6034 } // while.. actors traversal
6038 } // if (SVTK view model)
6039 } // for (viewManagers)
6042 // data structures for clipping planes processing
6046 bool isOpenGLClipping;
6047 vtkIdType RelativeOrientation;
6050 int AbsoluteOrientation;
6051 double X, Y, Z, Dx, Dy, Dz;
6053 typedef std::list<TPlaneData> TPlaneDataList;
6054 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6056 typedef std::list<vtkActor*> TActorList;
6059 TActorList ActorList;
6060 SUIT_ViewManager* ViewManager;
6062 typedef std::list<TPlaneInfo> TPlaneInfoList;
6063 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6066 * \brief Restore visual parameters
6068 * This method is called after the study document is opened.
6069 * Restore visual parameters from AttributeParameter attribue(s)
6071 void SMESHGUI::restoreVisualParameters (int savePoint)
6074 Kernel_Utils::Localizer loc;
6076 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6077 if (!appStudy || !appStudy->studyDS())
6079 _PTR(Study) studyDS = appStudy->studyDS();
6081 // componentName is used for encoding of entries when storing them in IParameters
6082 std::string componentName = myComponentSMESH->ComponentDataType();
6083 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6084 //if (!aSComponent) return;
6087 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6088 componentName.c_str(),
6090 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6092 // restore custom markers and map of clipping planes
6093 TPlaneDataMap aPlaneDataMap;
6095 std::vector<std::string> properties = ip->getProperties();
6096 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6098 std::string property = *propIt;
6099 QString aPropertyName( property.c_str() );
6100 QString aPropertyValue( ip->getProperty( property ).c_str() );
6102 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6103 if( aPropertyNameList.isEmpty() )
6106 QString aPropertyType = aPropertyNameList[0];
6107 if( aPropertyType == "texture" )
6109 if( aPropertyNameList.size() != 2 )
6113 int anId = aPropertyNameList[1].toInt( &ok );
6114 if( !ok || anId < 1 )
6117 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6118 if( aPropertyValueList.size() != 2 )
6121 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6122 QString aMarkerTextureString = aPropertyValueList[1];
6123 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6124 if( aMarkerTextureStringList.size() != 3 )
6128 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6133 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6137 VTK::MarkerTexture aMarkerTexture;
6138 aMarkerTexture.push_back( aWidth );
6139 aMarkerTexture.push_back( aHeight );
6141 QString aMarkerTextureData = aMarkerTextureStringList[2];
6142 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6144 QChar aChar = aMarkerTextureData.at( i );
6145 if( aChar.isDigit() )
6146 aMarkerTexture.push_back( aChar.digitValue() );
6149 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6151 else if( aPropertyType == "ClippingPlane" )
6153 if( aPropertyNameList.size() != 3 )
6157 int aViewId = aPropertyNameList[1].toInt( &ok );
6158 if( !ok || aViewId < 0 )
6162 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6163 if( !ok || aClippingPlaneId < 0 )
6166 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6167 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6170 TPlaneData aPlaneData;
6171 aPlaneData.AbsoluteOrientation = false;
6172 aPlaneData.RelativeOrientation = 0;
6173 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6174 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6175 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6177 aPlaneData.Id = aClippingPlaneId;
6180 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6185 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6189 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6192 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6197 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6202 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6207 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6212 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6217 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6222 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6226 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6228 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6233 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6238 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6243 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6248 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6249 aPlaneDataList.push_back( aPlaneData );
6253 TPlaneInfoMap aPlaneInfoMap;
6255 std::vector<std::string> entries = ip->getEntries();
6257 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6259 // entry is a normal entry - it should be "decoded" (setting base address of component)
6260 QString entry (ip->decodeEntry(*entIt).c_str());
6262 // Check that the entry corresponds to a real object in the Study
6263 // as the object may be deleted or modified after the visual state is saved.
6264 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6265 if (!so) continue; //Skip the not existent entry
6267 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6268 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6270 std::vector<std::string>::iterator namesIt = paramNames.begin();
6271 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6273 // actors are stored in a map after displaying of them for
6274 // quicker access in the future: map < viewID to actor >
6275 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6277 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6279 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6280 // '_' is used as separator and should not be used in viewer type or parameter names.
6281 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6282 if (lst.size() != 3)
6285 QString viewerTypStr = lst[0];
6286 QString viewIndexStr = lst[1];
6287 QString paramNameStr = lst[2];
6290 int viewIndex = viewIndexStr.toUInt(&ok);
6291 if (!ok) // bad conversion of view index to integer
6295 if (viewerTypStr == SVTK_Viewer::Type())
6297 SMESH_Actor* aSmeshActor = 0;
6298 if (vtkActors.IsBound(viewIndex))
6299 aSmeshActor = vtkActors.Find(viewIndex);
6301 QList<SUIT_ViewManager*> lst;
6302 getApp()->viewManagers(viewerTypStr, lst);
6304 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6305 SUIT_ViewManager* vman = NULL;
6306 if (viewIndex >= 0 && viewIndex < lst.count())
6307 vman = lst.at(viewIndex);
6309 if (paramNameStr == "Visibility")
6311 if (!aSmeshActor && displayer() && vman)
6313 SUIT_ViewModel* vmodel = vman->getViewModel();
6314 // SVTK view model can be casted to SALOME_View
6315 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6317 // store displayed actor in a temporary map for quicker
6318 // access later when restoring other parameters
6319 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6320 vtkRenderer* Renderer = vtkView->getRenderer();
6321 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6322 vtkActorCollection* theActors = aCopy.GetActors();
6323 theActors->InitTraversal();
6324 bool isFound = false;
6325 vtkActor *ac = theActors->GetNextActor();
6326 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6327 if (ac->IsA("SMESH_Actor")) {
6328 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6329 if (aGeomAc->hasIO()) {
6330 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6331 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6333 vtkActors.Bind(viewIndex, aGeomAc);
6339 } // if (paramNameStr == "Visibility")
6342 // the rest properties "work" with SMESH_Actor
6345 QString val ((*valuesIt).c_str());
6348 if (paramNameStr == "Representation") {
6349 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6352 else if (paramNameStr == "IsShrunk") {
6354 if (!aSmeshActor->IsShrunk())
6355 aSmeshActor->SetShrink();
6358 if (aSmeshActor->IsShrunk())
6359 aSmeshActor->UnShrink();
6362 // Displayed entities
6363 else if (paramNameStr == "Entities") {
6364 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6365 int aEntityMode = SMESH_Actor::eAllEntity;
6366 for ( int i = 0; i < mode.count(); i+=2 ) {
6367 if ( i < mode.count()-1 ) {
6368 QString type = mode[i];
6369 bool val = mode[i+1].toInt();
6370 if ( type == "e" && !val )
6371 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6372 else if ( type == "f" && !val )
6373 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6374 else if ( type == "v" && !val )
6375 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6376 else if ( type == "0d" && !val )
6377 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6378 else if ( type == "b" && !val )
6379 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6382 aSmeshActor->SetEntityMode( aEntityMode );
6385 else if (paramNameStr == "Colors") {
6386 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6393 QColor outlineColor;
6394 QColor orientationColor;
6400 // below lines are required to get default values for delta coefficients
6401 // of backface color for faces and color of reversed volumes
6402 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6403 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6404 for ( int i = 0; i < colors.count(); i++ ) {
6405 QString type = colors[i];
6406 if ( type == "surface" ) {
6407 // face color is set by 3 values r:g:b, where
6408 // - r,g,b - is rgb color components
6409 if ( i+1 >= colors.count() ) break; // format error
6410 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6411 if ( i+2 >= colors.count() ) break; // format error
6412 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6413 if ( i+3 >= colors.count() ) break; // format error
6414 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6415 faceColor.setRgbF( r, g, b );
6418 else if ( type == "backsurface" ) {
6419 // backface color can be defined in several ways
6420 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6421 // - in latest versions, it is set as delta coefficient
6422 bool rgbOk = false, deltaOk;
6423 if ( i+1 >= colors.count() ) break; // format error
6424 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6425 int delta = colors[i+1].toInt( &deltaOk );
6427 if ( i+1 < colors.count() ) // index is shifted to 1
6428 g = colors[i+1].toDouble( &rgbOk );
6429 if ( rgbOk ) i++; // shift index
6430 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6431 b = colors[i+1].toDouble( &rgbOk );
6433 // - as currently there's no way to set directly backsurface color as it was before,
6434 // we ignore old dump where r,g,b triple was set
6435 // - also we check that delta parameter is set properly
6436 if ( !rgbOk && deltaOk )
6439 else if ( type == "volume" ) {
6440 // volume color is set by 4 values r:g:b:delta, where
6441 // - r,g,b - is a normal volume rgb color components
6442 // - delta - is a reversed volume color delta coefficient
6443 if ( i+1 >= colors.count() ) break; // format error
6444 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6445 if ( i+2 >= colors.count() ) break; // format error
6446 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6447 if ( i+3 >= colors.count() ) break; // format error
6448 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6449 if ( i+4 >= colors.count() ) break; // format error
6450 int delta = colors[i+4].toInt( &bOk );
6451 if ( !bOk ) break; // format error
6452 volumeColor.setRgbF( r, g, b );
6456 else if ( type == "edge" ) {
6457 // edge color is set by 3 values r:g:b, where
6458 // - r,g,b - is rgb color components
6459 if ( i+1 >= colors.count() ) break; // format error
6460 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6461 if ( i+2 >= colors.count() ) break; // format error
6462 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6463 if ( i+3 >= colors.count() ) break; // format error
6464 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6465 edgeColor.setRgbF( r, g, b );
6468 else if ( type == "node" ) {
6469 // node color is set by 3 values r:g:b, where
6470 // - r,g,b - is rgb color components
6471 if ( i+1 >= colors.count() ) break; // format error
6472 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6473 if ( i+2 >= colors.count() ) break; // format error
6474 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6475 if ( i+3 >= colors.count() ) break; // format error
6476 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6477 nodeColor.setRgbF( r, g, b );
6480 else if ( type == "elem0d" ) {
6481 // 0d element color is set by 3 values r:g:b, where
6482 // - r,g,b - is rgb color components
6483 if ( i+1 >= colors.count() ) break; // format error
6484 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6485 if ( i+2 >= colors.count() ) break; // format error
6486 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6487 if ( i+3 >= colors.count() ) break; // format error
6488 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6489 elem0dColor.setRgbF( r, g, b );
6492 else if ( type == "ball" ) {
6493 // ball color is set by 3 values r:g:b, where
6494 // - r,g,b - is rgb color components
6495 if ( i+1 >= colors.count() ) break; // format error
6496 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6497 if ( i+2 >= colors.count() ) break; // format error
6498 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6499 if ( i+3 >= colors.count() ) break; // format error
6500 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6501 ballColor.setRgbF( r, g, b );
6504 else if ( type == "outline" ) {
6505 // outline color is set by 3 values r:g:b, where
6506 // - r,g,b - is rgb color components
6507 if ( i+1 >= colors.count() ) break; // format error
6508 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6509 if ( i+2 >= colors.count() ) break; // format error
6510 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6511 if ( i+3 >= colors.count() ) break; // format error
6512 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6513 outlineColor.setRgbF( r, g, b );
6516 else if ( type == "orientation" ) {
6517 // orientation color is set by 3 values r:g:b, where
6518 // - r,g,b - is rgb color components
6519 if ( i+1 >= colors.count() ) break; // format error
6520 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6521 if ( i+2 >= colors.count() ) break; // format error
6522 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6523 if ( i+3 >= colors.count() ) break; // format error
6524 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6525 orientationColor.setRgbF( r, g, b );
6530 if ( nodeColor.isValid() )
6531 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6533 if ( edgeColor.isValid() )
6534 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6536 if ( faceColor.isValid() )
6537 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6539 if ( volumeColor.isValid() )
6540 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6541 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6542 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6544 if ( elem0dColor.isValid() )
6545 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6547 if ( ballColor.isValid() )
6548 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6550 if ( outlineColor.isValid() )
6551 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6552 // orientation color
6553 if ( orientationColor.isValid() )
6554 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6557 else if (paramNameStr == "Sizes") {
6558 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6561 int outlineWidth = -1;
6562 int elem0dSize = -1;
6563 //int ballSize = -1;
6564 double ballDiameter = -1.0;
6565 double ballScale = -1.0;
6566 double shrinkSize = -1;
6567 double orientationSize = -1;
6568 bool orientation3d = false;
6569 for ( int i = 0; i < sizes.count(); i++ ) {
6570 QString type = sizes[i];
6571 if ( type == "line" ) {
6572 // line (wireframe) width is given as single integer value
6573 if ( i+1 >= sizes.count() ) break; // format error
6574 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6578 if ( type == "outline" ) {
6579 // outline width is given as single integer value
6580 if ( i+1 >= sizes.count() ) break; // format error
6581 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6585 else if ( type == "elem0d" ) {
6586 // 0d element size is given as single integer value
6587 if ( i+1 >= sizes.count() ) break; // format error
6588 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6592 else if ( type == "ball" ) {
6593 // balls are specified by two values: size:scale, where
6594 // - size - is a integer value specifying size
6595 // - scale - is a double value specifying scale factor
6596 if ( i+1 >= sizes.count() ) break; // format error
6597 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6598 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6599 if ( i+2 >= sizes.count() ) break; // format error
6600 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6606 else if ( type == "shrink" ) {
6607 // shrink factor is given as single floating point value
6608 if ( i+1 >= sizes.count() ) break; // format error
6609 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6613 else if ( type == "orientation" ) {
6614 // orientation vectors are specified by two values size:3d, where
6615 // - size - is a floating point value specifying scale factor
6616 // - 3d - is a boolean
6617 if ( i+1 >= sizes.count() ) break; // format error
6618 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6619 if ( i+2 >= sizes.count() ) break; // format error
6620 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6621 orientationSize = v1;
6622 orientation3d = (bool)v2;
6626 // line (wireframe) width
6627 if ( lineWidth > 0 )
6628 aSmeshActor->SetLineWidth( lineWidth );
6630 if ( outlineWidth > 0 )
6631 aSmeshActor->SetOutlineWidth( outlineWidth );
6632 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6633 aSmeshActor->SetOutlineWidth( lineWidth );
6635 if ( elem0dSize > 0 )
6636 aSmeshActor->Set0DSize( elem0dSize );
6638 /*if ( ballSize > 0 )
6639 aSmeshActor->SetBallSize( ballSize );*/
6641 if ( ballDiameter > 0 )
6642 aSmeshActor->SetBallSize( ballDiameter );
6644 if ( ballScale > 0.0 )
6645 aSmeshActor->SetBallScale( ballScale );
6647 if ( shrinkSize > 0 )
6648 aSmeshActor->SetShrinkFactor( shrinkSize );
6649 // orientation vectors
6650 if ( orientationSize > 0 ) {
6651 aSmeshActor->SetFacesOrientationScale( orientationSize );
6652 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6656 else if (paramNameStr == "PointMarker") {
6657 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6658 if( data.count() >= 2 ) {
6660 int aParam1 = data[1].toInt( &ok );
6662 if( data[0] == "std" && data.count() == 3 ) {
6663 int aParam2 = data[2].toInt( &ok );
6664 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6666 else if( data[0] == "custom" ) {
6667 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6668 if( markerIt != myMarkerMap.end() ) {
6669 VTK::MarkerData aMarkerData = markerIt->second;
6670 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6677 else if (paramNameStr == "Opacity") {
6678 aSmeshActor->SetOpacity(val.toFloat());
6681 else if (paramNameStr.startsWith("ClippingPlane")) {
6682 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6683 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6684 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6685 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6686 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6687 // new format - val looks like "Off" or "0" (plane id)
6688 // (note: in new format "Off" value is used only for consistency,
6689 // so it is processed together with values in old format)
6690 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6691 if( anIsOldFormat ) {
6692 if (paramNameStr == "ClippingPlane1" || val == "Off")
6693 aSmeshActor->RemoveAllClippingPlanes();
6695 QList<SUIT_ViewManager*> lst;
6696 getApp()->viewManagers(viewerTypStr, lst);
6697 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6698 if (viewIndex >= 0 && viewIndex < lst.count()) {
6699 SUIT_ViewManager* vman = lst.at(viewIndex);
6700 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6702 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6704 SMESH::TActorList anActorList;
6705 anActorList.push_back( aSmeshActor );
6706 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6707 aPlane->myViewWindow = vtkView;
6708 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6709 aPlane->PlaneMode = aMode;
6710 bool isOpenGLClipping = ( bool )vals[1].toInt();
6711 aPlane->IsOpenGLClipping = isOpenGLClipping;
6712 if ( aMode == SMESH::Absolute ) {
6713 aPlane->myAbsoluteOrientation = vals[2].toInt();
6714 aPlane->X = vals[3].toFloat();
6715 aPlane->Y = vals[4].toFloat();
6716 aPlane->Z = vals[5].toFloat();
6717 aPlane->Dx = vals[6].toFloat();
6718 aPlane->Dy = vals[7].toFloat();
6719 aPlane->Dz = vals[8].toFloat();
6721 else if ( aMode == SMESH::Relative ) {
6722 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6723 aPlane->myDistance = vals[3].toFloat();
6724 aPlane->myAngle[0] = vals[4].toFloat();
6725 aPlane->myAngle[1] = vals[5].toFloat();
6729 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6730 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6731 aClippingPlaneInfo.Plane = aPlane;
6732 aClippingPlaneInfo.ActorList = anActorList;
6733 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6741 int aPlaneId = val.toInt( &ok );
6742 if( ok && aPlaneId >= 0 ) {
6743 bool anIsDefinedPlane = false;
6744 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6745 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6746 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6747 TPlaneInfo& aPlaneInfo = *anIter;
6748 if( aPlaneInfo.PlaneId == aPlaneId ) {
6749 aPlaneInfo.ActorList.push_back( aSmeshActor );
6750 anIsDefinedPlane = true;
6754 if( !anIsDefinedPlane ) {
6755 TPlaneInfo aPlaneInfo;
6756 aPlaneInfo.PlaneId = aPlaneId;
6757 aPlaneInfo.ActorList.push_back( aSmeshActor );
6758 aPlaneInfo.ViewManager = vman;
6760 // to make the list sorted by plane id
6761 anIter = aPlaneInfoList.begin();
6762 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6763 const TPlaneInfo& aPlaneInfoRef = *anIter;
6764 if( aPlaneInfoRef.PlaneId > aPlaneId )
6767 aPlaneInfoList.insert( anIter, aPlaneInfo );
6772 } // if (aSmeshActor)
6773 } // other parameters than Visibility
6775 } // for names/parameters iterator
6776 } // for entries iterator
6778 // take into account planes with empty list of actors referred to them
6779 QList<SUIT_ViewManager*> aVMList;
6780 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6782 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6783 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6784 int aViewId = aPlaneDataIter->first;
6785 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6786 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6788 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6790 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6791 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6792 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6793 const TPlaneData& aPlaneData = *anIter2;
6794 int aPlaneId = aPlaneData.Id;
6796 bool anIsFound = false;
6797 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6798 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6799 const TPlaneInfo& aPlaneInfo = *anIter3;
6800 if( aPlaneInfo.PlaneId == aPlaneId ) {
6807 TPlaneInfo aPlaneInfo; // ActorList field is empty
6808 aPlaneInfo.PlaneId = aPlaneId;
6809 aPlaneInfo.ViewManager = aViewManager;
6811 // to make the list sorted by plane id
6812 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6813 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6814 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6815 if( aPlaneInfoRef.PlaneId > aPlaneId )
6818 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6824 // add clipping planes to actors according to the restored parameters
6825 // and update the clipping plane map
6826 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6827 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6828 int aViewId = anIter1->first;
6829 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6831 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6832 if( anIter2 == aPlaneDataMap.end() )
6834 const TPlaneDataList& aPlaneDataList = anIter2->second;
6836 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6837 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6838 const TPlaneInfo& aPlaneInfo = *anIter3;
6839 int aPlaneId = aPlaneInfo.PlaneId;
6840 const TActorList& anActorList = aPlaneInfo.ActorList;
6841 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6845 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6849 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6851 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6852 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6853 const TPlaneData& aPlaneData = *anIter4;
6854 if( aPlaneData.Id == aPlaneId ) {
6855 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6856 aPlane->myViewWindow = aViewWindow;
6857 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6858 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6859 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6860 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6861 aPlane->X = aPlaneData.X;
6862 aPlane->Y = aPlaneData.Y;
6863 aPlane->Z = aPlaneData.Z;
6864 aPlane->Dx = aPlaneData.Dx;
6865 aPlane->Dy = aPlaneData.Dy;
6866 aPlane->Dz = aPlaneData.Dz;
6868 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6869 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6870 aPlane->myDistance = aPlaneData.Distance;
6871 aPlane->myAngle[0] = aPlaneData.Angle[0];
6872 aPlane->myAngle[1] = aPlaneData.Angle[1];
6875 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6876 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6877 aClippingPlaneInfo.Plane = aPlane;
6878 aClippingPlaneInfo.ActorList = anActorList;
6879 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6890 // update all VTK views
6891 QList<SUIT_ViewManager*> lst;
6892 getApp()->viewManagers(lst);
6893 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6894 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6895 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6896 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6897 // set OpenGL clipping planes
6898 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6899 vtkActorCollection* anAllActors = aCopy.GetActors();
6900 anAllActors->InitTraversal();
6901 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6902 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6903 anActor->SetOpenGLClippingPlane();
6905 vtkView->getRenderer()->ResetCameraClippingRange();
6912 \brief Adds preferences for dfont of VTK viewer
6914 \param pIf group identifier
6915 \param param parameter
6916 \return identifier of preferences
6918 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6920 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6922 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6925 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6926 fam.append( tr( "SMESH_FONT_COURIER" ) );
6927 fam.append( tr( "SMESH_FONT_TIMES" ) );
6929 setPreferenceProperty( tfont, "fonts", fam );
6931 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6932 if ( needSize ) f = f | QtxFontEdit::Size;
6933 setPreferenceProperty( tfont, "features", f );
6939 \brief Actions after hypothesis edition
6940 Updates object browser after hypothesis edition
6942 void SMESHGUI::onHypothesisEdit( int result )
6945 SMESHGUI::Modified();
6946 updateObjBrowser( true );
6950 \brief Actions after choosing menu of control modes
6951 Updates control mode actions according to current selection
6953 void SMESHGUI::onUpdateControlActions()
6955 SALOME_ListIO selected;
6956 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6957 aSel->selectedObjects( selected );
6959 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6960 if ( selected.Extent() ) {
6961 if ( selected.First()->hasEntry() ) {
6962 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6963 aControl = anActor->GetControlMode();
6964 SALOME_ListIteratorOfListIO it(selected);
6965 for ( it.Next(); it.More(); it.Next() ) {
6966 Handle(SALOME_InteractiveObject) anIO = it.Value();
6967 if ( anIO->hasEntry() ) {
6968 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6969 if ( aControl != anActor->GetControlMode() ) {
6970 aControl = SMESH_Actor::eNone;
6980 int anAction = ActionToControl( aControl, true );
6982 action( anAction )->setChecked( true );
6984 QMenu* send = (QMenu*)sender();
6985 QList<QAction*> actions = send->actions();
6986 for ( int i = 0; i < actions.size(); i++ )
6987 actions[i]->setChecked( false );
6993 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6994 \param pview view being closed
6996 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6997 #ifndef DISABLE_PLOT2DVIEWER
6998 //Crear all Plot2d Viewers if need.
6999 SMESH::ClearPlot2Viewers(pview);
7001 EmitSignalCloseView();
7004 void SMESHGUI::message( const QString& msg )
7007 QStringList data = msg.split("/");
7008 if ( data.count() > 0 ) {
7009 if ( data.first() == "mesh_loading" ) {
7011 QString entry = data.count() > 1 ? data[1] : QString();
7012 if ( entry.isEmpty() )
7015 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7017 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7020 name = SMESH::fromUtf8(obj->GetName());
7021 if ( name.isEmpty() )
7024 if ( data.last() == "stop" )
7025 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7027 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7028 QApplication::processEvents();
7034 \brief Connects or disconnects signals about activating and cloning view on the module slots
7035 \param pview view which is connected/disconnected
7037 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7041 SUIT_ViewManager* viewMgr = pview->getViewManager();
7043 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7044 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7046 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7047 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7052 \brief Return \c true if object can be renamed
7054 bool SMESHGUI::renameAllowed( const QString& entry) const {
7055 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7059 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7063 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7068 if(appStudy->isComponent(entry) || obj->isReference())
7071 // check type to prevent renaming of inappropriate objects
7072 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7073 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7074 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7075 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7076 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7077 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7084 Rename object by entry.
7085 \param entry entry of the object
7086 \param name new name of the object
7087 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7089 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7091 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7095 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7100 _PTR(Study) aStudy = appStudy->studyDS();
7105 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7107 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7112 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7113 _PTR(GenericAttribute) anAttr;
7114 _PTR(AttributeName) aName;
7116 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7118 // check type to prevent renaming of inappropriate objects
7119 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7120 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7121 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7122 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7123 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7124 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7125 if ( !name.isEmpty() ) {
7126 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7128 // update name of group object and its actor
7129 Handle(SALOME_InteractiveObject) IObject =
7130 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7132 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7133 if( !aGroupObject->_is_nil() ) {
7134 aGroupObject->SetName( qPrintable(name) );
7135 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7136 anActor->setName( qUtf8Printable(name) );
7146 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7148 static QList<QColor> colors;
7150 if ( colors.isEmpty() ) {
7152 for (int s = 0; s < 2 ; s++)
7154 for (int v = 100; v >= 40; v = v - 20)
7156 for (int h = 0; h < 359 ; h = h + 60)
7158 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7163 static int currentColor = randomize( colors.size() );
7165 SALOMEDS::Color color;
7166 color.R = (double)colors[currentColor].red() / 255.0;
7167 color.G = (double)colors[currentColor].green() / 255.0;
7168 color.B = (double)colors[currentColor].blue() / 255.0;
7170 currentColor = (currentColor+1) % colors.count();