1 // Copyright (C) 2007-2020 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_AdaptDlg.h"
34 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
35 #include "SMESHGUI_AddMeshElementDlg.h"
36 #include "SMESHGUI_AddQuadraticElementDlg.h"
37 #include "SMESHGUI_BuildCompoundDlg.h"
38 #include "SMESHGUI_ClippingDlg.h"
39 #include "SMESHGUI_ComputeDlg.h"
40 #include "SMESHGUI_ConvToQuadOp.h"
41 #include "SMESHGUI_CopyMeshDlg.h"
42 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
43 #include "SMESHGUI_DeleteGroupDlg.h"
44 #include "SMESHGUI_DisplayEntitiesDlg.h"
45 #include "SMESHGUI_Displayer.h"
46 #include "SMESHGUI_DuplicateNodesDlg.h"
47 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
48 #include "SMESHGUI_ExtrusionDlg.h"
49 #include "SMESHGUI_FaceGroupsSeparatedByEdgesDlg.h"
50 #include "SMESHGUI_FieldSelectorWdg.h"
51 #include "SMESHGUI_FileInfoDlg.h"
52 #include "SMESHGUI_FileValidator.h"
53 #include "SMESHGUI_FilterDlg.h"
54 #include "SMESHGUI_FilterLibraryDlg.h"
55 #include "SMESHGUI_FilterUtils.h"
56 #include "SMESHGUI_FindElemByPointDlg.h"
57 #include "SMESHGUI_GEOMGenUtils.h"
58 #include "SMESHGUI_GroupDlg.h"
59 #include "SMESHGUI_GroupOnShapeDlg.h"
60 #include "SMESHGUI_GroupOpDlg.h"
61 #include "SMESHGUI_GroupUtils.h"
62 #include "SMESHGUI_Hypotheses.h"
63 #include "SMESHGUI_HypothesesUtils.h"
64 #include "SMESHGUI_Make2DFrom3DOp.h"
65 #include "SMESHGUI_MakeNodeAtPointDlg.h"
66 #include "SMESHGUI_Measurements.h"
67 #include "SMESHGUI_MergeDlg.h"
68 #include "SMESHGUI_MeshInfo.h"
69 #include "SMESHGUI_MeshOp.h"
70 #include "SMESHGUI_MeshOrderOp.h"
71 #include "SMESHGUI_MeshPatternDlg.h"
72 #include "SMESHGUI_MeshUtils.h"
73 #include "SMESHGUI_MultiEditDlg.h"
74 #include "SMESHGUI_NodesDlg.h"
75 #include "SMESHGUI_OffsetDlg.h"
76 #include "SMESHGUI_Operations.h"
77 #include "SMESHGUI_PatternUtils.h"
78 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
79 #include "SMESHGUI_PropertiesDlg.h"
80 #include "SMESHGUI_RemoveElementsDlg.h"
81 #include "SMESHGUI_RemoveNodesDlg.h"
82 #include "SMESHGUI_RenumberingDlg.h"
83 #include "SMESHGUI_ReorientFacesDlg.h"
84 #include "SMESHGUI_RevolutionDlg.h"
85 #include "SMESHGUI_RotationDlg.h"
86 #include "SMESHGUI_ScaleDlg.h"
87 #include "SMESHGUI_Selection.h"
88 #include "SMESHGUI_SewingDlg.h"
89 #include "SMESHGUI_SingleEditDlg.h"
90 #include "SMESHGUI_SmoothingDlg.h"
91 #include "SMESHGUI_SpinBox.h"
92 #include "SMESHGUI_SplitBiQuad.h"
93 #include "SMESHGUI_SymmetryDlg.h"
94 #include "SMESHGUI_TranslationDlg.h"
95 #include "SMESHGUI_TransparencyDlg.h"
96 #include "SMESHGUI_Utils.h"
97 #include "SMESHGUI_VTKUtils.h"
99 #include "SMESH_version.h"
101 #include "SMESH_Actor.h"
102 #include "SMESH_ActorUtils.h"
103 #include "SMESH_Client.hxx"
104 #include "SMESH_Comment.hxx"
105 #include "SMESH_ControlsDef.hxx"
106 #include "SMESH_ScalarBarActor.h"
107 #include "SMESH_TypeFilter.hxx"
109 // SALOME GUI includes
110 #include <LightApp_DataOwner.h>
111 #include <LightApp_NameDlg.h>
112 #include <LightApp_Preferences.h>
113 #include <LightApp_SelectionMgr.h>
114 #include <LightApp_UpdateFlags.h>
115 #include <QtxFontEdit.h>
116 #include <QtxPopupMgr.h>
117 #include <QtxInfoPanel.h>
118 #include <SALOME_ListIO.hxx>
119 #include <SUIT_Desktop.h>
120 #include <SUIT_FileDlg.h>
121 #include <SUIT_MessageBox.h>
122 #include <SUIT_OverrideCursor.h>
123 #include <SUIT_ResourceMgr.h>
124 #include <SUIT_Session.h>
125 #include <SVTK_Renderer.h>
126 #include <SVTK_ViewManager.h>
127 #include <SVTK_ViewModel.h>
128 #include <SVTK_ViewWindow.h>
129 #include <SalomeApp_Application.h>
130 #include <SalomeApp_CheckFileDlg.h>
131 #include <SalomeApp_DataObject.h>
132 #include <SalomeApp_Study.h>
133 #include <SalomeApp_Tools.h>
134 #include <VTKViewer_Algorithm.h>
136 #ifndef DISABLE_PLOT2DVIEWER
137 #include <SPlot2d_ViewModel.h>
138 #include <SPlot2d_Histogram.h>
142 #include <SALOMEconfig.h>
143 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
144 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
145 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
146 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
149 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
150 #include <QApplication>
152 #include <QDialogButtonBox>
156 #include <QTextStream>
160 #include <boost/shared_ptr.hpp>
163 #include <vtkCallbackCommand.h>
164 #include <vtkCamera.h>
165 #include <vtkLookupTable.h>
166 #include <vtkPlane.h>
167 #include <vtkRenderer.h>
169 // SALOME KERNEL includes
170 #include <SALOMEDSClient_ClientFactory.hxx>
171 #include <SALOMEDSClient_IParameters.hxx>
172 #include <SALOMEDSClient_SComponent.hxx>
173 #include <SALOMEDSClient_StudyBuilder.hxx>
174 #include <SALOMEDS_Study.hxx>
175 #include <SALOMEDS_SObject.hxx>
176 #include "utilities.h"
177 #include <SALOME_LifeCycleCORBA.hxx>
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 )
497 if ( dontShowCheckBox.checkState() == Qt::Checked && resMgr )
498 resMgr->setValue( "SMESH", "show_warning", false);
501 QString aMeshName = anIObject->getName();
503 // check for name duplications
504 if ( !hasDuplicatedMeshNames )
505 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
506 if( aMeshName == (*aMeshIter).second ) {
507 hasDuplicatedMeshNames = true;
512 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
515 if( hasDuplicatedMeshNames && isMED ) {
516 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
517 QObject::tr("SMESH_WRN_WARNING"),
518 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
519 QObject::tr("SMESH_BUT_YES"),
520 QObject::tr("SMESH_BUT_NO"), 0, 1);
525 aMeshIter = aMeshList.begin();
526 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
527 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
528 QString aMeshName = (*aMeshIter).second;
530 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
532 // check for equal group names within each mesh
533 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
534 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
535 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
536 int aRet = SUIT_MessageBox::warning
537 (SMESHGUI::desktop(),
538 QObject::tr("SMESH_WRN_WARNING"),
539 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
540 QObject::tr("SMESH_BUT_YES"),
541 QObject::tr("SMESH_BUT_NO"), 0, 1);
548 // Warn the user about presence of not supported elements
550 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
554 notSupportedElemTypes.push_back( SMESH::Entity_0D );
555 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
560 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
561 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
562 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
563 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
564 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
565 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
566 notSupportedElemTypes.push_back( SMESH::Entity_0D );
567 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
572 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
573 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
574 notSupportedElemTypes.push_back( SMESH::Entity_0D );
575 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
580 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
585 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
586 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
587 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
588 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
589 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
590 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
591 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
592 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
597 notSupportedElemTypes.push_back( SMESH::Entity_0D );
598 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
599 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
600 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
601 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
602 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
603 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
604 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
605 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
606 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
608 if ( ! notSupportedElemTypes.empty() )
610 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
611 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
612 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
613 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
615 if ( !presentNotSupported.empty() )
618 const char* typeMsg[] = {
619 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
620 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
621 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
622 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
623 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
624 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
625 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
626 "SMESH_BIQUADRATIC_PENTAHEDRONS",
627 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
629 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
630 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
631 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
633 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
634 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
635 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
636 if ( iType != presentNotSupported.size() - 1 )
637 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
639 int aRet = SUIT_MessageBox::warning
640 (SMESHGUI::desktop(),
641 QObject::tr("SMESH_WRN_WARNING"),
642 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
643 QObject::tr("SMESH_BUT_YES"),
644 QObject::tr("SMESH_BUT_NO"), 0, 1);
649 // Get parameters of export operation
652 int aFormat =-1; // for MED version used for write
653 bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
655 // Init the parameters with the default values
656 bool aIsASCII_STL = true;
657 bool toCreateGroups = false;
659 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
660 bool toOverwrite = true;
661 bool toFindOutDim = true;
662 double zTol = resMgr ? resMgr->doubleValue( "SMESH", "med_ztolerance", 0. ) : 0.;
664 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
665 QString anInitialPath = "";
666 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
667 anInitialPath = QDir::currentPath();
669 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
671 // Get a file name to write in and additional options
672 if ( isUNV || isDAT || isGMF ) // Export w/o options
675 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
677 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
679 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
680 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
681 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
682 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
683 anInitialPath + QString("/") + aMeshName,
684 aFilter, aTitle, false);
686 else if ( isCGNS )// Export to CGNS
688 const char* theByTypeResource = "cgns_group_elems_by_type";
689 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
691 QStringList checkBoxes;
692 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
694 SalomeApp_CheckFileDlg* fd =
695 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
696 fd->setWindowTitle( aTitle );
697 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
698 if ( !anInitialPath.isEmpty() )
699 fd->setDirectory( anInitialPath );
700 fd->selectFile(aMeshName);
701 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
702 fd->setValidator( fv );
703 fd->SetChecked( toCreateGroups, 0 );
706 aFilename = fd->selectedFile();
707 toOverwrite = fv->isOverwrite(aFilename);
708 toCreateGroups = fd->IsChecked(0);
709 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
713 else if ( isSTL ) // Export to STL
715 QMap<QString, int> aFilterMap;
716 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
717 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
720 QMap<QString, int>::const_iterator it = aFilterMap.begin();
721 for ( ; it != aFilterMap.end(); ++it )
722 filters.push_back( it.key() );
724 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
725 fd->setWindowTitle( aTitle );
726 fd->setNameFilters( filters );
727 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
728 if ( !anInitialPath.isEmpty() )
729 fd->setDirectory( anInitialPath );
730 fd->selectFile(aMeshName);
734 aFilename = fd->selectedFile();
735 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
740 else if ( isMED || isSAUV ) // Export to MED or SAUV
742 int defaultVersion = 0;
743 QMap<QString, int> aFilterMap;
745 //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
746 //QString vmed (aMesh->GetVersionString(-1, 2));
747 SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
748 if ( mvok->length() > 0)
749 defaultVersion = mvok[0]; // the current version to set the default filter on it
750 for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
752 QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
753 MESSAGE("MED version: " << vs.toStdString());
754 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
758 aFilterMap.insert("All files (*)", -1 );
759 aFilterMap.insert("SAUV files (*.sauv)", defaultVersion ); // 0 = default filter (defaultVersion)
760 aFilterMap.insert("SAUV files (*.sauve)", -1 );
763 QMap<QString, int>::const_iterator it = aFilterMap.begin();
764 QString aDefaultFilter = it.key();
765 for ( ; it != aFilterMap.end(); ++it ) {
766 filters.push_back( it.key() );
767 if (it.value() == defaultVersion) // explicit default for MED = current MED version
768 aDefaultFilter = it.key();
770 QStringList checkBoxes;
771 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
773 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
774 QList< QWidget* > wdgList;
775 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
776 wdgList.append( fieldSelWdg );
778 QWidget* zTolWdg = new QWidget();
779 QCheckBox* zTolCheck = new QCheckBox( QObject::tr( "SMESH_ZTOLERANCE" ), zTolWdg );
780 SMESHGUI_SpinBox* zTolSpin = new SMESHGUI_SpinBox( zTolWdg );
781 QHBoxLayout* zTolLayout = new QHBoxLayout( zTolWdg );
782 zTolLayout->addWidget( zTolCheck );
783 zTolLayout->addWidget( zTolSpin );
784 zTolLayout->setMargin( 0 );
785 zTolSpin->RangeStepAndValidator( 0, 1e+100, 1., "length_precision" );
786 zTolSpin->setValue( zTol );
787 QObject::connect( zTolCheck, SIGNAL( toggled(bool)), zTolSpin, SLOT( setEnabled(bool)));
788 zTolCheck->setChecked( resMgr->booleanValue( "SMESH", "enable_ztolerance", false ));
789 zTolSpin ->setEnabled( zTolCheck->isChecked() );
790 wdgList.append( zTolWdg );
792 SalomeApp_CheckFileDlg* fd =
793 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
794 fd->setWindowTitle( aTitle );
795 fd->setNameFilters( filters );
796 fd->selectNameFilter( aDefaultFilter );
797 fd->SetChecked( toCreateGroups, 0 );
798 fd->SetChecked( toFindOutDim, 1 );
799 if ( !anInitialPath.isEmpty() )
800 fd->setDirectory( anInitialPath );
801 fd->selectFile(aMeshName);
804 QListView *lview = fd->findChild<QListView*>("listView");
806 lview->setMinimumHeight(200);
808 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
810 tview->setMinimumHeight(200);
813 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
814 fd->setValidator( fv );
819 //MESSAGE("******* Loop on file dialog ***********");
822 aFilename = fd->selectedFile();
824 aFilename = QString::null;
827 aFormat = aFilterMap[fd->selectedNameFilter()];
828 //MESSAGE("selected version: " << aFormat << " file: " << aFilename.toUtf8().constData());
829 toOverwrite = fv->isOverwrite(aFilename);
830 //MESSAGE("toOverwrite:" << toOverwrite);
832 if ( !aFilename.isEmpty() ) {
834 // append is only possible if the existing file format is compatible
835 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
836 MESSAGE("Append check, isVersionOk:" << isVersionOk);
837 if ( !isVersionOk ) {
838 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
839 QObject::tr("SMESH_WRN_WARNING"),
840 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
841 QObject::tr("SMESH_BUT_YES"),
842 QObject::tr("SMESH_BUT_NO"), 0, 1);
846 //MESSAGE("incompatible MED file version for add, overwrite accepted");
852 //MESSAGE("incompatible MED file version for add, overwrite refused");
855 QStringList aMeshNamesCollisionList;
856 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
857 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
858 QString anExistingMeshName( aMeshNames[ i ] );
859 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
860 QString anExportMeshName = (*aMeshIter).second;
861 if( anExportMeshName == anExistingMeshName ) {
862 aMeshNamesCollisionList.append( anExportMeshName );
867 if( !aMeshNamesCollisionList.isEmpty() ) {
869 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
870 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
871 QObject::tr("SMESH_WRN_WARNING"),
872 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
873 QObject::tr("SMESH_BUT_YES"),
874 QObject::tr("SMESH_BUT_NO"),
875 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
876 MESSAGE("answer collision name " << aRet);
887 toCreateGroups = fd->IsChecked(0);
888 toFindOutDim = fd->IsChecked(1);
889 zTol = zTolCheck->isChecked() ? zTolSpin->value() : -1;
890 fieldSelWdg->GetSelectedFields();
891 if ( resMgr ) resMgr->setValue( "SMESH", "enable_ztolerance", zTolCheck->isChecked() );
893 if ( !fieldSelWdg->parent() )
895 if ( !zTolWdg->parent() )
906 if ( !aFilename.isEmpty() ) {
907 // Check whether the file already exists and delete it if yes
908 QFile aFile( aFilename );
909 if ( aFile.exists() && toOverwrite )
911 SUIT_OverrideCursor wc;
914 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
915 // bool Renumber = false;
916 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
918 // Renumber= resMgr->booleanValue("renumbering");
920 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
921 // aMeshEditor->RenumberNodes();
922 // aMeshEditor->RenumberElements();
923 // if ( SMESHGUI::automaticUpdate() )
924 // SMESH::UpdateView();
926 if ( isMED && isOkToWrite)
928 MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
929 aMeshIter = aMeshList.begin();
930 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
932 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
933 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
934 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
935 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
936 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
937 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ) && zTol < 0 )
938 aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
939 toOverwrite && aMeshIndex == 0, toFindOutDim );
941 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
942 toCreateGroups, aFormat,
943 toOverwrite && aMeshIndex == 0, toFindOutDim,
944 fields, geoAssFields.toLatin1().data(), zTol );
949 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
951 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
952 if( !aMeshItem->_is_nil() )
953 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
958 if ( aMeshOrGroup->_is_equivalent( aMesh ))
959 aMesh->ExportDAT( aFilename.toUtf8().data() );
961 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
965 if ( aMeshOrGroup->_is_equivalent( aMesh ))
966 aMesh->ExportUNV( aFilename.toUtf8().data() );
968 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
972 if ( aMeshOrGroup->_is_equivalent( aMesh ))
973 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
975 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
979 aMeshIter = aMeshList.begin();
980 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
982 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
983 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
984 aMeshItem->ExportCGNS( aMeshOrGroup,
985 aFilename.toUtf8().data(),
986 toOverwrite && aMeshIndex == 0,
992 toCreateGroups = true;
993 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
996 catch (const SALOME::SALOME_Exception& S_ex){
998 SUIT_MessageBox::warning(SMESHGUI::desktop(),
999 QObject::tr("SMESH_WRN_WARNING"),
1000 QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
1006 inline void InverseEntityMode(unsigned int& theOutputMode,
1007 unsigned int theMode)
1009 bool anIsNotPresent = ~theOutputMode & theMode;
1011 theOutputMode |= theMode;
1013 theOutputMode &= ~theMode;
1016 void SetDisplayEntity(int theCommandID)
1018 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1019 SALOME_ListIO selected;
1021 aSel->selectedObjects( selected );
1023 if ( selected.Extent() >= 1 ) {
1024 SUIT_OverrideCursor wc;
1025 SALOME_ListIteratorOfListIO It( selected );
1026 for( ; It.More(); It.Next()){
1027 Handle(SALOME_InteractiveObject) IObject = It.Value();
1028 if(IObject->hasEntry()){
1029 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1030 unsigned int aMode = anActor->GetEntityMode();
1031 switch(theCommandID){
1032 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1033 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1034 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1035 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1036 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1037 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1040 anActor->SetEntityMode(aMode);
1049 SalomeApp_Application* app =
1050 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1054 LightApp_SelectionMgr* aSel = app->selectionMgr();
1055 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1056 if ( !aSel || !appStudy )
1059 SALOME_ListIO selected;
1060 aSel->selectedObjects( selected );
1061 if ( selected.IsEmpty() )
1064 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1066 _PTR(Study) aStudy = appStudy->studyDS();
1067 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1068 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1069 if ( aMainObject->_is_nil() )
1072 SUIT_OverrideCursor wc;
1074 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1076 QList<SALOMEDS::Color> aReservedColors;
1078 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1079 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1081 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1083 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1084 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1085 #else // old algorithm for auto-colors
1086 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1087 aReservedColors.append( aColor );
1088 #endif // SIMPLE_AUTOCOLOR
1089 aGroupObject->SetColor( aColor );
1091 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1092 if ( aGroupSObject ) {
1095 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1096 switch ( aGroupObject->GetType ()) {
1098 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1100 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1102 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1104 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1106 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1107 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1110 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1111 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1117 SMESH::RepaintCurrentView();
1120 void OverallMeshQuality()
1122 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1123 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1124 SALOME_ListIO selected;
1126 aSel->selectedObjects( selected );
1128 if ( selected.IsEmpty() ) return;
1129 SALOME_ListIteratorOfListIO It( selected );
1130 for ( ; It.More(); It.Next() ) {
1131 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1132 ctrlDlg->showInfo( It.Value() );
1137 QString functorToString( SMESH::Controls::FunctorPtr f )
1139 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1140 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1141 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1142 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1143 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1144 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1145 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1146 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1147 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1148 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1149 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1150 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1151 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1152 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1153 type = QObject::tr( "WARP_ELEMENTS" );
1154 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1155 type = QObject::tr( "TAPER_ELEMENTS" );
1156 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1157 type = QObject::tr( "SKEW_ELEMENTS" );
1158 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1159 type = QObject::tr( "AREA_ELEMENTS" );
1160 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1161 type = QObject::tr( "LENGTH_EDGES" );
1162 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1163 type = QObject::tr( "LENGTH2D_EDGES" );
1164 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1165 type = QObject::tr( "DEFLECTION2D_FACES" );
1166 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1167 type = QObject::tr( "MULTI_BORDERS" );
1168 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1169 type = QObject::tr( "MULTI2D_BORDERS" );
1170 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1171 type = QObject::tr( "FREE_NODES" );
1172 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1173 type = QObject::tr( "FREE_EDGES" );
1174 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1175 type = QObject::tr( "FREE_BORDERS" );
1176 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1177 type = QObject::tr( "FREE_FACES" );
1178 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1179 type = QObject::tr( "BARE_BORDER_VOLUME" );
1180 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1181 type = QObject::tr( "BARE_BORDER_FACE" );
1182 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1183 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1184 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1185 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1186 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1187 type = QObject::tr( "EQUAL_NODE" );
1188 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1189 type = QObject::tr( "EQUAL_EDGE" );
1190 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1191 type = QObject::tr( "EQUAL_FACE" );
1192 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1193 type = QObject::tr( "EQUAL_VOLUME" );
1194 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1195 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1199 void SaveDistribution()
1201 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1202 SALOME_ListIO selected;
1204 aSel->selectedObjects( selected );
1206 if ( selected.Extent() == 1 ) {
1207 Handle(SALOME_InteractiveObject) anIO = selected.First();
1208 if ( anIO->hasEntry() ) {
1209 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1211 anActor->GetScalarBarActor() &&
1212 anActor->GetControlMode() != SMESH_Actor::eNone )
1214 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1215 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1216 if ( aScalarBarActor && aFunctor ) {
1217 SMESH::Controls::NumericalFunctor* aNumFun =
1218 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1220 std::vector<int> elements;
1221 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1222 if ( mesh->_is_nil() ) {
1223 SMESH::SMESH_IDSource_var idSource =
1224 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1225 if ( !idSource->_is_nil() )
1227 SMESH::long_array_var ids = idSource->GetIDs();
1228 elements.resize( ids->length() );
1229 for ( unsigned i = 0; i < elements.size(); ++i )
1230 elements[i] = ids[i];
1233 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1234 vtkLookupTable* lookupTable =
1235 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1236 double * minmax = lookupTable->GetRange();
1237 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1238 std::vector<int> nbEvents;
1239 std::vector<double> funValues;
1240 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1241 elements, minmax, isLogarithmic );
1242 QString anInitialPath = "";
1243 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1244 anInitialPath = QDir::currentPath();
1245 QString aMeshName = anIO->getName();
1247 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1248 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1249 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1250 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1251 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1254 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1256 if ( !aFilename.isEmpty() ) {
1257 QFile f( aFilename );
1258 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1259 QTextStream out( &f );
1260 out << "# Mesh: " << aMeshName << endl;
1261 out << "# Control: " << functorToString( aFunctor ) << endl;
1263 out.setFieldWidth( 10 );
1264 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1265 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1276 void ShowElement( int theCommandID )
1278 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1279 SALOME_ListIO selected;
1281 aSel->selectedObjects( selected );
1283 if ( selected.Extent() == 1 ) {
1284 Handle(SALOME_InteractiveObject) anIO = selected.First();
1285 if ( anIO->hasEntry() ) {
1286 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1288 anActor->GetScalarBarActor() &&
1289 anActor->GetControlMode() != SMESH_Actor::eNone )
1291 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1292 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1293 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1295 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1296 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1303 #ifndef DISABLE_PLOT2DVIEWER
1304 void PlotDistribution()
1306 SalomeApp_Application* app =
1307 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1311 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1312 SALOME_ListIO selected;
1314 aSel->selectedObjects( selected );
1316 if ( selected.Extent() == 1 ) {
1317 Handle(SALOME_InteractiveObject) anIO = selected.First();
1318 if ( anIO->hasEntry() ) {
1319 //Find Actor by entry before getting Plot2d viewer,
1320 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1321 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1323 SUIT_ViewManager* aViewManager =
1324 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1328 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1332 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1336 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1338 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1339 QString functorName = functorToString( anActor->GetFunctor());
1340 QString aHistogramName("%1 : %2");
1341 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1342 aHistogram->setName(aHistogramName);
1343 aHistogram->setHorTitle(functorName);
1344 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1345 aPlot->displayObject(aHistogram, true);
1350 #endif //DISABLE_PLOT2DVIEWER
1352 void DisableAutoColor()
1354 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1355 SALOME_ListIO selected;
1357 aSel->selectedObjects( selected );
1359 if ( selected.Extent() ) {
1360 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1361 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1362 if ( !aMesh->_is_nil() ) {
1363 aMesh->SetAutoColor( false );
1370 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1371 SALOME_ListIO selected;
1373 aSel->selectedObjects( selected );
1374 if ( selected.Extent() )
1376 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1377 _PTR(Study) aStudy = SMESH::getStudy();
1378 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1380 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1381 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1388 // Break link with Shaper model
1389 void breakShaperLink()
1391 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1392 SALOME_ListIO selected;
1394 aSel->selectedObjects(selected);
1395 if (selected.Extent()) {
1396 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1397 _PTR(Study) aStudy = SMESH::getStudy();
1398 std::string aEntry = anIObject->getEntry();
1399 _PTR(SObject) aSObj = aStudy->FindObjectID(aEntry);
1401 std::string aName = aSObj->GetName();
1402 QMessageBox::StandardButton aRes = SUIT_MessageBox::warning(SMESHGUI::desktop(),
1403 QObject::tr("SMESH_WRN_WARNING"),
1404 QObject::tr("MSG_BREAK_SHAPER_LINK").arg(aName.c_str()),
1405 SUIT_MessageBox::Yes | SUIT_MessageBox::No, SUIT_MessageBox::No);
1406 if (aRes == SUIT_MessageBox::Yes) {
1407 SUIT_DataOwnerPtrList aList;
1408 aSel->selected(aList, "ObjectBrowser", true);
1409 SUIT_DataOwner* aOwn = aList.first();
1410 LightApp_DataOwner* sowner = dynamic_cast<LightApp_DataOwner*>(aOwn);
1411 QString aREntry = sowner->entry();
1413 static GEOM::GEOM_Gen_var geomGen;
1414 if (CORBA::is_nil(geomGen)) {
1415 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>
1416 (SUIT_Session::session()->activeApplication());
1418 SALOME_LifeCycleCORBA* ls = new SALOME_LifeCycleCORBA(app->namingService());
1419 Engines::EngineComponent_var comp =
1420 ls->FindOrLoad_Component("FactoryServer", "SHAPERSTUDY");
1421 geomGen = GEOM::GEOM_Gen::_narrow(comp);
1424 if (!CORBA::is_nil(geomGen))
1426 geomGen->BreakLink(aREntry.toStdString().c_str());
1427 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1429 // remove actors whose objects are removed by BreakLink()
1430 QList<SUIT_ViewWindow*> wndList = SMESHGUI::desktop()->windows();
1431 SUIT_ViewWindow* wnd;
1432 foreach(wnd, wndList)
1433 SMESH::UpdateActorsAfterUpdateStudy(wnd);
1441 //================================================================================
1443 * \brief Return true if a mesh icon == ICON_SMESH_TREE_GEOM_MODIF
1444 * which means that the mesh can't be modified. It should be either re-computed
1445 * or breakShaperLink()'ed. Warn the user about it.
1447 //================================================================================
1449 bool warnOnGeomModif()
1451 SALOME_ListIO selected;
1452 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1453 aSel->selectedObjects(selected,"",/*convertReferences=*/false);
1455 SALOME_ListIteratorOfListIO It( selected );
1456 for ( ; It.More(); It.Next() )
1458 Handle(SALOME_InteractiveObject) io = It.Value();
1459 if ( !io->hasEntry() ) continue;
1460 _PTR(SObject) so = SMESH::getStudy()->FindObjectID( io->getEntry() );
1461 SMESH::SMESH_Mesh_var mesh;
1462 while ( mesh->_is_nil() && so && so->GetID() != "0:" )
1464 CORBA::Object_var obj = SMESH::SObjectToObject( so );
1465 SMESH::SMESH_IDSource_var isrc = SMESH::SMESH_IDSource::_narrow( obj );
1466 if ( isrc->_is_nil() )
1467 so = so->GetFather();
1469 mesh = isrc->GetMesh();
1471 if ( mesh->_is_nil() ) continue;
1472 so = SMESH::FindSObject( mesh );
1473 if ( !so ) continue;
1474 _PTR(GenericAttribute) attr;
1475 so->FindAttribute( attr, "AttributePixMap" );
1476 _PTR(AttributePixMap) pixmap = attr;
1477 if ( !pixmap ) continue;
1479 if ( pixmap->GetPixMap() == "ICON_SMESH_TREE_GEOM_MODIF" )
1481 SUIT_MessageBox::warning(SMESHGUI::desktop(),
1482 QObject::tr("SMESH_WRN_WARNING"),
1483 QObject::tr("MSG_WARN_ON_GEOM_MODIF"));
1490 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1492 SALOME_ListIO selected;
1493 SalomeApp_Application* app =
1494 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1498 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1499 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1500 if ( !aSel || !appStudy )
1503 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1504 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1505 aModule->EmitSignalDeactivateDialog();
1506 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1507 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1512 aSel->selectedObjects( selected );
1514 if ( selected.Extent() >= 1 )
1516 switch ( theCommandID ) {
1517 case SMESHOp::OpTransparency:
1519 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1520 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1523 case SMESHOp::OpProperties:
1526 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1527 QColor orientationColor, outlineColor, volumeColor;
1528 int deltaF = 0, deltaV = 0;
1531 double ballScale = 1.0;
1533 int outlineWidth = 1;
1534 double shrinkCoef = 0.0;
1535 double orientationScale = 0.0;
1536 bool orientation3d = false;
1537 VTK::MarkerType markerType = VTK::MT_NONE;
1538 VTK::MarkerScale markerScale = VTK::MS_NONE;
1540 bool hasNodes = false;
1541 int presentEntities = 0;
1542 bool firstTime = true;
1544 SALOME_ListIteratorOfListIO It( selected );
1545 for ( ; It.More(); It.Next() ) {
1546 Handle(SALOME_InteractiveObject) IObject = It.Value();
1547 if ( !IObject->hasEntry() ) continue;
1548 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1549 if ( !anActor || !anActor->GetObject() ) continue;
1552 // nodes: color, marker
1553 anActor->GetNodeColor( color[0], color[1], color[2] );
1554 nodeColor.setRgbF( color[0], color[1], color[2] );
1555 markerType = anActor->GetMarkerType();
1556 markerScale = anActor->GetMarkerScale();
1557 markerId = anActor->GetMarkerTexture();
1558 // edges: color, width
1559 anActor->GetEdgeColor( color[0], color[1], color[2] );
1560 edgeColor.setRgbF( color[0], color[1], color[2] );
1561 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1562 // faces: front color, back color (delta)
1563 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1564 faceColor.setRgbF( color[0], color[1], color[2] );
1565 // faces: front color, back color (delta)
1566 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1567 volumeColor.setRgbF( color[0], color[1], color[2] );
1568 // 0d elements: color, size
1569 anActor->Get0DColor( color[0], color[1], color[2] );
1570 elem0dColor.setRgbF( color[0], color[1], color[2] );
1571 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1572 // balls: color, size
1573 anActor->GetBallColor( color[0], color[1], color[2] );
1574 ballColor.setRgbF( color[0], color[1], color[2] );
1575 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1576 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1578 anActor->GetOutlineColor( color[0], color[1], color[2] );
1579 outlineColor.setRgbF( color[0], color[1], color[2] );
1580 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1581 // orientation vectors: color, scale, 3d flag
1582 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1583 orientationColor.setRgbF( color[0], color[1], color[2] );
1584 orientationScale = anActor->GetFacesOrientationScale();
1585 orientation3d = anActor->GetFacesOrientation3DVectors();
1587 shrinkCoef = anActor->GetShrinkFactor();
1590 firstTime = false; // we only take properties from first object (for performance reasons)
1593 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1594 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1595 presentEntities = presentEntities | SMESH_Actor::eEdges;
1596 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1597 presentEntities = presentEntities | SMESH_Actor::eFaces;
1598 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1599 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1600 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1601 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1602 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1603 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1605 // as we know that all types of elements are present, we can exit the loop
1606 if ( presentEntities == SMESH_Actor::eAllEntity )
1610 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1611 // nodes: color, marker
1612 dlg.setNodeColor( nodeColor );
1613 if( markerType != VTK::MT_USER )
1614 dlg.setNodeMarker( markerType, markerScale );
1616 dlg.setNodeCustomMarker( markerId );
1617 // edges: color, line width
1618 dlg.setEdgeColor( edgeColor );
1619 dlg.setEdgeWidth( edgeWidth );
1620 // faces: front color, back color
1621 dlg.setFaceColor( faceColor, deltaF );
1622 // volumes: normal color, reversed color
1623 dlg.setVolumeColor( volumeColor, deltaV );
1624 // outlines: color, line width
1625 dlg.setOutlineColor( outlineColor );
1626 dlg.setOutlineWidth( outlineWidth );
1627 // 0d elements: color, size
1628 dlg.setElem0dColor( elem0dColor );
1629 dlg.setElem0dSize( elem0dSize );
1630 // balls: color, size
1631 dlg.setBallColor( ballColor );
1632 //dlg.setBallSize( ballSize );
1633 dlg.setBallScale( ballScale );
1634 // orientation: color, scale, 3d flag
1635 dlg.setOrientationColor( orientationColor );
1636 dlg.setOrientationSize( int( orientationScale * 100. ) );
1637 dlg.setOrientation3d( orientation3d );
1638 // shrink: scale factor
1639 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1640 // hide unused controls
1641 dlg.showControls( presentEntities, hasNodes );
1644 nodeColor = dlg.nodeColor();
1645 markerType = dlg.nodeMarkerType();
1646 markerScale = dlg.nodeMarkerScale();
1647 markerId = dlg.nodeMarkerId();
1648 edgeColor = dlg.edgeColor();
1649 edgeWidth = dlg.edgeWidth();
1650 faceColor = dlg.faceColor();
1651 deltaF = dlg.faceColorDelta();
1652 volumeColor = dlg.volumeColor();
1653 deltaV = dlg.volumeColorDelta();
1654 outlineColor = dlg.outlineColor();
1655 outlineWidth = dlg.outlineWidth();
1656 elem0dColor = dlg.elem0dColor();
1657 elem0dSize = dlg.elem0dSize();
1658 ballColor = dlg.ballColor();
1659 // ballSize = dlg.ballSize();
1660 ballScale = dlg.ballScale();
1661 orientationColor = dlg.orientationColor();
1662 orientationScale = dlg.orientationSize() / 100.;
1663 orientation3d = dlg.orientation3d();
1664 shrinkCoef = dlg.shrinkCoef() / 100.;
1666 // store point markers that might be changed by the user
1667 theMarkerMap = dlg.customMarkers();
1669 // set properties from dialog box to the presentations
1670 SALOME_ListIteratorOfListIO It( selected );
1671 for ( ; It.More(); It.Next() ) {
1672 Handle(SALOME_InteractiveObject) IObject = It.Value();
1673 if ( !IObject->hasEntry() ) continue;
1674 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1675 if ( !anActor ) continue;
1677 // nodes: color, marker
1678 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1679 if ( markerType != VTK::MT_USER ) {
1680 anActor->SetMarkerStd( markerType, markerScale );
1683 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1684 if ( iter != theMarkerMap.end() )
1685 anActor->SetMarkerTexture( markerId, iter->second.second );
1687 // volumes: normal color, reversed color (delta)
1688 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1689 // faces: front color, back color (delta)
1690 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1691 // edges: color, width
1692 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1693 anActor->SetLineWidth( edgeWidth );
1695 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1696 anActor->SetOutlineWidth( outlineWidth );
1697 // 0D elements: color, size
1698 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1699 anActor->Set0DSize( elem0dSize );
1700 // balls: color, size
1701 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1702 // anActor->SetBallSize( ballSize );
1703 anActor->SetBallScale( ballScale );
1704 // orientation: color, scale, 3d flag
1705 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1706 anActor->SetFacesOrientationScale( orientationScale );
1707 anActor->SetFacesOrientation3DVectors( orientation3d );
1709 anActor->SetShrinkFactor( shrinkCoef );
1711 // for groups, set also proper color
1712 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1713 if ( !aGroupObject->_is_nil() ) {
1714 SMESH::ElementType anElementType = aGroupObject->GetType();
1716 switch( anElementType ) {
1718 aColor = nodeColor; break;
1720 aColor = edgeColor; break;
1722 aColor = faceColor; break;
1724 aColor = volumeColor; break;
1726 aColor = elem0dColor; break;
1728 aColor = ballColor; break;
1732 if ( aColor.isValid() ) {
1733 SALOMEDS::Color aGroupColor;
1734 aGroupColor.R = aColor.redF();
1735 aGroupColor.G = aColor.greenF();
1736 aGroupColor.B = aColor.blueF();
1737 aGroupObject->SetColor( aGroupColor );
1739 } // if ( !aGroupObject->_is_nil() )
1740 } // for ( ; It.More(); It.Next() )
1741 SMESH::RepaintCurrentView();
1742 } // if ( dlg.exec() )
1744 } // case SMESHOp::OpProperties:
1745 } // switch(theCommandID)
1746 SUIT_OverrideCursor wc;
1747 SALOME_ListIteratorOfListIO It( selected );
1748 for( ; It.More(); It.Next()){
1749 Handle(SALOME_InteractiveObject) IObject = It.Value();
1750 if(IObject->hasEntry()){
1751 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1752 switch(theCommandID){
1753 case SMESHOp::OpDMWireframe:
1754 anActor->SetRepresentation(SMESH_Actor::eEdge);
1756 case SMESHOp::OpDMShading:
1757 anActor->SetRepresentation(SMESH_Actor::eSurface);
1759 case SMESHOp::OpDMShrink:
1760 if(anActor->IsShrunk())
1761 anActor->UnShrink();
1763 anActor->SetShrink();
1765 case SMESHOp::OpDMNodes:
1766 anActor->SetRepresentation(SMESH_Actor::ePoint);
1768 case SMESHOp::OpRepresentationLines:
1769 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1770 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1772 case SMESHOp::OpRepresentationArcs:
1773 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1774 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1780 SMESH::RepaintCurrentView();
1784 int ActionToControl( int theID, bool theReversed )
1786 NCollection_DoubleMap<int,int> ActionControl;
1787 ActionControl.Bind( 0, SMESH_Actor::eNone );
1788 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1789 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1790 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1791 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1792 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1793 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1794 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1795 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1796 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1797 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1798 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1799 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1800 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1801 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1802 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1803 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1804 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1805 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1806 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1807 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1808 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1809 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1810 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1811 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1812 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1813 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1814 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1815 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1818 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1819 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1822 void Control( int theCommandID )
1824 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1825 _PTR(Study) aStudy = SMESH::getStudy();
1827 SALOME_ListIO selected;
1828 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1829 aSel->selectedObjects( selected );
1831 if ( !selected.IsEmpty() ) {
1832 SALOME_ListIteratorOfListIO It(selected);
1833 for ( ; It.More(); It.Next())
1835 Handle(SALOME_InteractiveObject) anIO = It.Value();
1836 if ( !anIO.IsNull() ) {
1837 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1839 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1840 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1841 if ( !anIDSrc->_is_nil() ) {
1842 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1843 if (( !anActor && selected.Extent() == 1 ) &&
1844 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1846 anActor->SetControlMode( aControl );
1847 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1848 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1852 if ( anActor->GetControlMode() != aControl )
1853 anActor->SetControlMode( aControl );
1854 QString functorName = functorToString( anActor->GetFunctor() );
1855 int anEntitiesCount = anActor->GetNumberControlEntities();
1856 if (anEntitiesCount >= 0)
1857 functorName = functorName + ": " + QString::number(anEntitiesCount);
1858 anActor->GetScalarBarActor()->SetTitle( functorName.toUtf8().constData() );
1859 SMESH::RepaintCurrentView();
1860 #ifndef DISABLE_PLOT2DVIEWER
1861 if ( anActor->GetPlot2Histogram() ) {
1862 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1863 QString aHistogramName("%1 : %2");
1864 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1865 aHistogram->setName( aHistogramName );
1866 aHistogram->setHorTitle( functorName );
1867 SMESH::ProcessIn2DViewers( anActor );
1879 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1880 SMESH::MeshObjectType theType,
1881 const QString theInTypeName,
1882 QString & theOutTypeName)
1884 SMESH_TypeFilter aTypeFilter( theType );
1886 if ( !theIO.IsNull() )
1888 entry = theIO->getEntry();
1889 LightApp_DataOwner owner( entry );
1890 if ( aTypeFilter.isOk( &owner )) {
1891 theOutTypeName = theInTypeName;
1899 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1901 _PTR(Study) aStudy = SMESH::getStudy();
1902 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1904 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1905 CORBA::String_var anID = aSComp->GetID().c_str();
1906 if ( !strcmp(anID.in(),theIO->getEntry()) )
1912 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1913 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1914 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1915 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1916 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1924 // QString CheckHomogeneousSelection()
1926 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1927 // SALOME_ListIO selected;
1929 // aSel->selectedObjects( selected );
1931 // QString RefType = CheckTypeObject(selected.First());
1932 // SALOME_ListIteratorOfListIO It(selected);
1933 // for ( ; It.More(); It.Next())
1935 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1936 // QString Type = CheckTypeObject(IObject);
1937 // if ( Type.compare(RefType) != 0 )
1938 // return "Heterogeneous Selection";
1944 uint randomize( uint size )
1946 static bool initialized = false;
1947 if ( !initialized ) {
1948 qsrand( QDateTime::currentDateTime().toTime_t() );
1952 v = uint( (double)( v ) / RAND_MAX * size );
1953 v = qMax( uint(0), qMin ( v, size-1 ) );
1959 void SMESHGUI::OnEditDelete()
1961 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1962 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1963 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1965 _PTR(Study) aStudy = SMESH::getStudy();
1966 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1967 _PTR(GenericAttribute) anAttr;
1968 _PTR(AttributeIOR) anIOR;
1970 const int objectCountLimit = 30; // PAL23599
1971 int objectCount = 0;
1973 QString aParentComponent = QString::null;
1975 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1977 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1978 if ( anIO.IsNull() ) continue;
1980 QString father = "unknown", name;
1982 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1984 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1985 // check if object is reference
1986 _PTR(SObject) aRefSObj;
1987 if ( aSO->ReferencedObject( aRefSObj ) ) {
1988 name = QString::fromStdString ( aRefSObj->GetName() );
1989 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1992 name = anIO->getName();
1995 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
1996 aNameList.append("\n - ");
1997 aNameList.append( name );
2000 if( aParentComponent.isNull() )
2001 aParentComponent = father;
2002 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
2003 aParentComponent = "";
2005 if ( objectCount >= objectCountLimit )
2006 aNameList.append("\n - ...");
2008 if ( objectCount == 0 )
2009 return; // No Valid Objects Selected
2011 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
2012 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2013 QObject::tr("ERR_ERROR"),
2014 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
2017 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
2018 if (SUIT_MessageBox::warning
2019 (SMESHGUI::desktop(),
2020 QObject::tr("SMESH_WRN_WARNING"),
2021 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
2022 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
2023 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
2026 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2028 // Put one level of sub-objects of the selected SO's into a list
2029 // in order to get objects inside folders like "Assigned Algorithms"
2030 std::list< _PTR(SObject) > listSO;
2031 SALOME_ListIteratorOfListIO It(selected);
2032 for( ; It.More(); It.Next()) // loop on selected IO's
2034 Handle(SALOME_InteractiveObject) IObject = It.Value();
2035 if(IObject->hasEntry()) {
2036 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
2038 // disable removal of "SMESH" component object
2039 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
2041 if ( engineIOR() == anIOR->Value().c_str() )
2044 //Check the referenced object
2045 _PTR(SObject) aRefSObject;
2046 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
2047 aSO = aRefSObject; // Delete main Object instead of reference
2049 listSO.push_back( aSO );
2051 _PTR(ChildIterator) it = aStudy->NewChildIterator( aSO );
2052 for (it->InitEx(false); it->More(); it->Next())
2053 listSO.push_back( it->Value() );
2056 // Check if none of objects to delete is referred from outside
2057 std::list< _PTR(SObject) >::reverse_iterator ritSO;
2058 std::vector< _PTR(SObject) > subSO;
2059 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2061 _PTR(SObject) SO = *ritSO;
2062 if ( !SO ) continue;
2064 int nbChildren = SO->GetLastChildTag();
2066 subSO.reserve( 1 + nbChildren );
2067 subSO.push_back( SO );
2068 if ( nbChildren > 0 )
2070 _PTR(ChildIterator) it = aStudy->NewChildIterator( SO );
2071 for ( it->InitEx( true ); it->More(); it->Next() )
2072 subSO.push_back( it->Value() );
2074 for ( size_t i = 0; i < subSO.size(); ++i )
2076 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( subSO[i] );
2077 for ( size_t j = 0; j < aReferences.size(); j++ ) {
2078 _PTR(SComponent) aComponent = aReferences[j]->GetFatherComponent();
2079 std::string type = aComponent->ComponentDataType();
2080 if ( type != "SMESH" )
2082 SUIT_MessageBox::warning( anApp->desktop(),
2083 QObject::tr("WRN_WARNING"),
2084 QObject::tr("DEP_OBJECT") );
2085 return; // outside SMESH, there is an object depending on a SMESH object
2091 // Treat SO's in the list starting from the back
2092 aStudyBuilder->NewCommand(); // There is a transaction
2093 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2095 _PTR(SObject) SO = *ritSO;
2096 if ( !SO ) continue;
2097 std::string anEntry = SO->GetID();
2099 /** Erase graphical object and remove all its data **/
2100 if ( SO->FindAttribute( anAttr, "AttributeIOR" )) {
2101 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
2103 /** Remove an object from data structures **/
2104 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
2105 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
2106 if ( !aGroup->_is_nil() ) { // DELETE GROUP
2107 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
2108 aMesh->RemoveGroup( aGroup );
2110 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
2111 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2112 aMesh->RemoveSubMesh( aSubMesh );
2115 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2116 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2117 QString objType = CheckTypeObject(IObject);
2118 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2119 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2120 aStudyBuilder->RemoveObjectWithChildren( SO );
2122 else {// default action: remove SObject from the study
2123 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2124 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2126 aStudyBuilder->RemoveObjectWithChildren( SO );
2130 } /* listSO back loop */
2132 aStudyBuilder->CommitCommand();
2134 /* Clear any previous selection */
2136 aSel->setSelectedObjects( l1 );
2138 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2142 SMESHGUI_EXPORT CAM_Module* createModule()
2144 return new SMESHGUI();
2147 SMESHGUI_EXPORT char* getModuleVersion() {
2148 return (char*)SMESH_VERSION_STR;
2152 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2154 //=============================================================================
2158 //=============================================================================
2159 SMESHGUI::SMESHGUI() :
2160 SalomeApp_Module( "SMESH" )
2162 if ( CORBA::is_nil( myComponentSMESH ) )
2164 CORBA::Boolean anIsEmbeddedMode;
2165 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2166 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2168 // 0019923: EDF 765 SMESH : default values of hypothesis
2169 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2170 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2171 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2172 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2173 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2175 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2176 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2177 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2179 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2180 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2184 myActiveDialogBox = 0;
2185 myFilterLibraryDlg = 0;
2189 myEventCallbackCommand = vtkCallbackCommand::New();
2190 myEventCallbackCommand->Delete();
2191 myEventCallbackCommand->SetClientData( this );
2192 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2195 /* load resources for all available meshers */
2196 SMESH::InitAvailableHypotheses();
2199 //=============================================================================
2203 //=============================================================================
2204 SMESHGUI::~SMESHGUI()
2208 //=============================================================================
2212 //=============================================================================
2213 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2215 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2217 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2222 //=============================================================================
2226 //=============================================================================
2227 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2229 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2233 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2234 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2235 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2236 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2237 return autoUpdate && !exceeded;
2240 //=============================================================================
2244 //=============================================================================
2245 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2246 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2248 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2252 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2253 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2254 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2256 SMESH::long_array_var info = theMesh->GetMeshInfo();
2257 long nbOdElems = info[SMDSEntity_0D];
2258 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2259 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2260 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2261 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2262 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2263 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2264 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2265 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2266 info[SMDSEntity_Polyhedra] +
2267 info[SMDSEntity_Hexagonal_Prism];
2268 long nbBalls = info[SMDSEntity_Ball];
2270 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2271 *nbElements = requestedSize;
2273 *entities = SMESH_Actor::eAllEntity;
2276 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2278 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2280 if ( incrementalLimit ) {
2283 if ( nbOdElems > 0 ) {
2284 if ( total + nbOdElems > updateLimit ) {
2285 *entities = *entities & ~SMESH_Actor::e0DElements;
2286 *hidden = *hidden | SMESH_Actor::e0DElements;
2293 if ( nbEdges > 0 ) {
2294 if ( total + nbEdges > updateLimit ) {
2295 *entities = *entities & ~SMESH_Actor::eEdges;
2296 *hidden = *hidden | SMESH_Actor::eEdges;
2303 if ( nbFaces > 0 ) {
2304 if ( total + nbFaces > updateLimit ) {
2305 *entities = *entities & ~SMESH_Actor::eFaces;
2306 *hidden = *hidden | SMESH_Actor::eFaces;
2313 if ( nbVolumes > 0 ) {
2314 if ( total + nbVolumes > updateLimit ) {
2315 *entities = *entities & ~SMESH_Actor::eVolumes;
2316 *hidden = *hidden | SMESH_Actor::eVolumes;
2323 if ( nbBalls > 0 ) {
2324 if ( total + nbBalls > updateLimit ) {
2325 *entities = *entities & ~SMESH_Actor::eBallElem;
2326 *hidden = *hidden | SMESH_Actor::eBallElem;
2334 return autoUpdate && !exceeded;
2337 //=============================================================================
2341 //=============================================================================
2342 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2344 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2347 //=============================================================================
2351 //=============================================================================
2352 SMESHGUI* SMESHGUI::GetSMESHGUI()
2354 SMESHGUI* smeshMod = 0;
2355 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2358 CAM_Module* module = app->module( "Mesh" );
2359 smeshMod = dynamic_cast<SMESHGUI*>( module );
2367 Standard_EXPORT SMESHGUI* GetComponentGUI()
2369 return SMESHGUI::GetSMESHGUI();
2373 //=============================================================================
2377 //=============================================================================
2378 void SMESHGUI::SetState(int aState)
2383 //=============================================================================
2387 //=============================================================================
2388 void SMESHGUI::ResetState()
2393 //=============================================================================
2397 //=============================================================================
2398 void SMESHGUI::EmitSignalDeactivateDialog()
2400 emit SignalDeactivateActiveDialog();
2403 //=============================================================================
2407 //=============================================================================
2408 void SMESHGUI::EmitSignalStudyFrameChanged()
2410 emit SignalStudyFrameChanged();
2413 //=============================================================================
2417 //=============================================================================
2418 void SMESHGUI::EmitSignalCloseAllDialogs()
2420 emit SignalCloseAllDialogs();
2423 //=============================================================================
2427 //=============================================================================
2428 void SMESHGUI::EmitSignalVisibilityChanged()
2430 emit SignalVisibilityChanged();
2433 //=============================================================================
2437 //=============================================================================
2438 void SMESHGUI::EmitSignalCloseView()
2440 emit SignalCloseView();
2443 //=============================================================================
2447 //=============================================================================
2448 void SMESHGUI::EmitSignalActivatedViewManager()
2450 emit SignalActivatedViewManager();
2453 //=============================================================================
2457 //=============================================================================
2458 QDialog *SMESHGUI::GetActiveDialogBox()
2460 return myActiveDialogBox;
2463 //=============================================================================
2467 //=============================================================================
2468 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2470 myActiveDialogBox = (QDialog *) aDlg;
2474 //=============================================================================
2478 //=============================================================================
2479 SUIT_Desktop* SMESHGUI::desktop()
2481 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2483 return app->desktop();
2488 //=============================================================================
2492 //=============================================================================
2493 SalomeApp_Study* SMESHGUI::activeStudy()
2495 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2497 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2502 //=============================================================================
2506 //=============================================================================
2507 void SMESHGUI::Modified( bool theIsUpdateActions )
2509 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2510 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2511 appStudy->Modified();
2512 if( theIsUpdateActions )
2513 app->updateActions();
2518 //=============================================================================
2522 //=============================================================================
2523 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2525 /* Here the position is on the bottom right corner - 10 */
2526 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2528 SUIT_Desktop *PP = desktop();
2529 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2530 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2535 * \brief Verifies whether study of operation is locked
2536 * \param theMess - specifies whether message box must be shown if study is locked
2537 * \return State of study.
2539 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2540 * is locked when corresponding message box appears
2542 bool SMESHGUI::isStudyLocked( bool theMessage )
2544 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2547 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2548 QObject::tr( "WRN_WARNING" ),
2549 QObject::tr( "WRN_STUDY_LOCKED" ) );
2555 //=============================================================================
2559 //=============================================================================
2560 bool SMESHGUI::OnGUIEvent( int theCommandID )
2562 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2566 SUIT_ResourceMgr* mgr = resourceMgr();
2570 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2571 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2573 //QAction* act = action( theCommandID );
2575 switch (theCommandID) {
2576 case SMESHOp::OpDelete:
2577 if(isStudyLocked()) break;
2580 case SMESHOp::OpImportDAT:
2581 case SMESHOp::OpImportUNV:
2582 case SMESHOp::OpImportMED:
2583 case SMESHOp::OpImportSTL:
2584 case SMESHOp::OpImportCGNS:
2585 case SMESHOp::OpImportSAUV:
2586 case SMESHOp::OpImportGMF:
2587 case SMESHOp::OpPopupImportDAT:
2588 case SMESHOp::OpPopupImportUNV:
2589 case SMESHOp::OpPopupImportMED:
2590 case SMESHOp::OpPopupImportSTL:
2591 case SMESHOp::OpPopupImportCGNS:
2592 case SMESHOp::OpPopupImportSAUV:
2593 case SMESHOp::OpPopupImportGMF:
2595 if(isStudyLocked()) break;
2596 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2600 case SMESHOp::OpFileInformation:
2602 SALOME_ListIO selected;
2603 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2605 aSel->selectedObjects( selected );
2606 if( selected.Extent() )
2608 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2609 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2610 if ( !aMesh->_is_nil() )
2612 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2618 case SMESHOp::OpExportDAT:
2619 case SMESHOp::OpExportMED:
2620 case SMESHOp::OpExportUNV:
2621 case SMESHOp::OpExportSTL:
2622 case SMESHOp::OpExportCGNS:
2623 case SMESHOp::OpExportSAUV:
2624 case SMESHOp::OpExportGMF:
2625 case SMESHOp::OpPopupExportDAT:
2626 case SMESHOp::OpPopupExportMED:
2627 case SMESHOp::OpPopupExportUNV:
2628 case SMESHOp::OpPopupExportSTL:
2629 case SMESHOp::OpPopupExportCGNS:
2630 case SMESHOp::OpPopupExportSAUV:
2631 case SMESHOp::OpPopupExportGMF:
2633 ::ExportMeshToFile(theCommandID);
2637 case SMESHOp::OpReset: // SCALAR BAR
2639 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2640 SALOME_ListIO selected;
2642 aSel->selectedObjects( selected );
2644 SALOME_ListIteratorOfListIO it(selected);
2645 for( ; it.More(); it.Next()) {
2646 Handle(SALOME_InteractiveObject) anIO = it.Value();
2647 if( anIO->hasEntry() ) {
2648 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2649 anActor->SetControlMode( SMESH_Actor::eNone );
2650 #ifndef DISABLE_PLOT2DVIEWER
2651 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2653 anActor->UpdateFilter();
2657 SMESH::UpdateView();
2660 case SMESHOp::OpScalarBarProperties:
2662 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2665 case SMESHOp::OpShowScalarBar:
2667 // show/hide scalar bar
2668 ::ShowElement(theCommandID);
2671 case SMESHOp::OpSaveDistribution:
2673 // dump control distribution data to the text file
2674 ::SaveDistribution();
2678 case SMESHOp::OpShowDistribution:
2680 // show/hide distribution
2681 ::ShowElement(theCommandID);
2685 #ifndef DISABLE_PLOT2DVIEWER
2686 case SMESHOp::OpPlotDistribution:
2688 // plot distribution
2689 ::PlotDistribution();
2695 case SMESHOp::OpAutoColor:
2699 case SMESHOp::OpDisableAutoColor:
2700 ::DisableAutoColor();
2703 case SMESHOp::OpClipping:
2704 case SMESHOp::OpTransparency:
2705 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2708 case SMESHOp::OpDMWireframe:
2709 case SMESHOp::OpDMShading:
2710 case SMESHOp::OpDMNodes:
2711 case SMESHOp::OpDMShrink:
2712 ::SetDisplayMode(theCommandID, myMarkerMap);
2715 //2D quadratic representation
2716 case SMESHOp::OpRepresentationLines:
2717 case SMESHOp::OpRepresentationArcs:
2718 ::SetDisplayMode(theCommandID, myMarkerMap);
2722 case SMESHOp::OpDE0DElements:
2723 case SMESHOp::OpDEEdges:
2724 case SMESHOp::OpDEFaces:
2725 case SMESHOp::OpDEVolumes:
2726 case SMESHOp::OpDEBalls:
2727 case SMESHOp::OpDEAllEntity:
2728 ::SetDisplayEntity(theCommandID);
2731 // Choose entities to be displayed
2732 case SMESHOp::OpDEChoose:
2734 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2738 case SMESHOp::OpOrientationOnFaces:
2740 SUIT_OverrideCursor wc;
2741 LightApp_SelectionMgr* mgr = selectionMgr();
2742 SALOME_ListIO selected; mgr->selectedObjects( selected );
2744 SALOME_ListIteratorOfListIO it(selected);
2745 for( ; it.More(); it.Next()) {
2746 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2747 if(anIObject->hasEntry()) {
2748 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2749 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2756 case SMESHOp::OpUpdate:
2758 if(isStudyLocked()) break;
2759 SUIT_OverrideCursor wc;
2762 SMESH::UpdateView();
2764 catch (std::bad_alloc&) { // PAL16774 (Crash after display of many groups)
2765 SMESH::OnVisuException();
2767 catch (...) { // PAL16774 (Crash after display of many groups)
2768 SMESH::OnVisuException();
2772 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2773 aSel->selectedObjects( l );
2774 aSel->setSelectedObjects( l );
2778 case SMESHOp::OpHide:
2779 case SMESHOp::OpShow:
2780 case SMESHOp::OpShowOnly:
2782 SUIT_OverrideCursor wc;
2783 SMESH::EDisplaing anAction;
2784 switch (theCommandID) {
2785 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2786 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2787 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2790 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2791 SALOME_ListIO sel_objects, to_process;
2793 aSel->selectedObjects( sel_objects );
2795 if ( theCommandID==SMESHOp::OpShowOnly )
2797 //MESSAGE("anAction = SMESH::eDisplayOnly");
2798 startOperation( myEraseAll );
2801 extractContainers( sel_objects, to_process );
2806 SALOME_ListIteratorOfListIO It( to_process );
2807 for ( ; It.More(); It.Next())
2809 Handle(SALOME_InteractiveObject) IOS = It.Value();
2810 if ( IOS->hasEntry() )
2812 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2813 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2814 break; // PAL16774 (Crash after display of many groups)
2816 if (anAction == SMESH::eDisplayOnly)
2817 anAction = SMESH::eDisplay;
2822 // PAL13338 + PAL15161 -->
2823 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2824 SMESH::UpdateView();
2825 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2827 // PAL13338 + PAL15161 <--
2829 catch (...) { // PAL16774 (Crash after display of many groups)
2830 SMESH::OnVisuException();
2833 if (anAction == SMESH::eErase) {
2835 aSel->setSelectedObjects( l1 );
2838 aSel->setSelectedObjects( to_process );
2840 if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2841 ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2842 vtkwnd->GetRenderer()->AdjustActors();
2847 case SMESHOp::OpNode:
2849 if(isStudyLocked()) break;
2852 EmitSignalDeactivateDialog();
2854 ( new SMESHGUI_NodesDlg( this ) )->show();
2857 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2862 case SMESHOp::OpEditMeshOrSubMesh:
2863 case SMESHOp::OpEditMesh:
2864 case SMESHOp::OpEditSubMesh:
2865 case SMESHOp::OpMeshOrder:
2866 case SMESHOp::OpCreateSubMesh:
2867 if ( warnOnGeomModif() )
2868 break; // action forbidden as geometry modified
2870 case SMESHOp::OpCreateMesh:
2871 case SMESHOp::OpCompute:
2872 case SMESHOp::OpComputeSubMesh:
2873 case SMESHOp::OpPreCompute:
2874 case SMESHOp::OpEvaluate:
2875 case SMESHOp::OpShowErrors:
2876 startOperation( theCommandID );
2878 case SMESHOp::OpRecompute:
2880 if ( isStudyLocked() )
2882 SALOME_ListIO selected;
2883 if ( LightApp_SelectionMgr *sel = selectionMgr() )
2884 sel->selectedObjects( selected );
2885 if ( selected.Extent() == 1 ) {
2886 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO( selected.First() );
2887 if ( !aMesh->_is_nil() )
2889 startOperation( SMESHOp::OpCompute );
2893 case SMESHOp::OpCopyMesh:
2895 if (isStudyLocked()) break;
2896 EmitSignalDeactivateDialog();
2897 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2900 case SMESHOp::OpBuildCompoundMesh:
2902 if (isStudyLocked()) break;
2903 EmitSignalDeactivateDialog();
2904 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2908 case SMESHOp::OpDiagonalInversion:
2909 case SMESHOp::OpUnionOfTwoTriangle:
2913 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2917 if ( isStudyLocked() )
2919 if ( warnOnGeomModif() )
2920 break; // action forbidden as geometry modified
2922 /*Standard_Boolean aRes;
2923 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2924 if ( aMesh->_is_nil() )
2926 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2927 tr( "SMESH_BAD_SELECTION" ) );
2931 EmitSignalDeactivateDialog();
2932 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2933 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2935 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2938 case SMESHOp::OpOrientation:
2939 case SMESHOp::OpUnionOfTriangles:
2940 case SMESHOp::OpCuttingOfQuadrangles:
2941 case SMESHOp::OpSplitVolumes:
2945 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2949 if ( isStudyLocked() )
2951 if ( warnOnGeomModif() )
2952 break; // action forbidden as geometry modified
2954 EmitSignalDeactivateDialog();
2955 SMESHGUI_MultiEditDlg* aDlg = NULL;
2956 if ( theCommandID == SMESHOp::OpOrientation )
2957 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2958 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2959 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2960 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2961 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2963 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2968 case SMESHOp::OpSmoothing:
2970 if(isStudyLocked()) break;
2971 if ( warnOnGeomModif() )
2972 break; // action forbidden as geometry modified
2974 EmitSignalDeactivateDialog();
2975 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2978 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2982 case SMESHOp::OpExtrusion:
2984 if (isStudyLocked()) break;
2985 if ( warnOnGeomModif() )
2986 break; // action forbidden as geometry modified
2988 EmitSignalDeactivateDialog();
2989 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2991 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2995 case SMESHOp::OpExtrusionAlongAPath:
2997 if (isStudyLocked()) break;
2998 if ( warnOnGeomModif() )
2999 break; // action forbidden as geometry modified
3001 EmitSignalDeactivateDialog();
3002 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
3004 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3008 case SMESHOp::OpRevolution:
3010 if(isStudyLocked()) break;
3011 if ( warnOnGeomModif() )
3012 break; // action forbidden as geometry modified
3014 EmitSignalDeactivateDialog();
3015 ( new SMESHGUI_RevolutionDlg( this ) )->show();
3018 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3022 case SMESHOp::OpPatternMapping:
3024 if ( isStudyLocked() )
3026 if ( warnOnGeomModif() )
3027 break; // action forbidden as geometry modified
3030 EmitSignalDeactivateDialog();
3031 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
3034 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3038 // Adaptation - begin
3039 case SMESHOp::OpMGAdapt:
3041 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3042 SMESHGUI_AdaptDlg *objet = new SMESHGUI_AdaptDlg( this, theCommandID, aMesh);
3045 case SMESHOp::OpSplitBiQuadratic:
3046 case SMESHOp::OpConvertMeshToQuadratic:
3047 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3048 case SMESHOp::OpReorientFaces:
3049 case SMESHOp::OpCreateGeometryGroup:
3051 if ( warnOnGeomModif() )
3052 break; // action forbidden as geometry modified
3053 startOperation( theCommandID );
3056 case SMESHOp::OpCreateGroup:
3060 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3064 if(isStudyLocked()) break;
3065 if ( warnOnGeomModif() )
3066 break; // action forbidden as geometry modified
3067 EmitSignalDeactivateDialog();
3068 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3070 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3071 SALOME_ListIO selected;
3073 aSel->selectedObjects( selected );
3075 int nbSel = selected.Extent();
3077 // check if mesh is selected
3078 aMesh = SMESH::GetMeshByIO( selected.First() );
3080 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3085 case SMESHOp::OpConstructGroup:
3089 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3093 if(isStudyLocked()) break;
3094 if ( warnOnGeomModif() )
3095 break; // action forbidden as geometry modified
3096 EmitSignalDeactivateDialog();
3098 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3099 SALOME_ListIO selected;
3101 aSel->selectedObjects( selected );
3103 int nbSel = selected.Extent();
3105 // check if submesh is selected
3106 Handle(SALOME_InteractiveObject) IObject = selected.First();
3107 if (IObject->hasEntry()) {
3108 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3110 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3111 if (!aSubMesh->_is_nil()) {
3113 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3114 // get submesh elements list by types
3115 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3116 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3117 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3118 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3119 // create group for each type o elements
3120 QString aName = IObject->getName();
3121 QStringList anEntryList;
3122 if (aNodes->length() > 0) {
3123 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3124 aGroup->Add(aNodes.inout());
3125 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3126 anEntryList.append( aSObject->GetID().c_str() );
3128 if (aEdges->length() > 0) {
3129 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3130 aGroup->Add(aEdges.inout());
3131 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3132 anEntryList.append( aSObject->GetID().c_str() );
3134 if (aFaces->length() > 0) {
3135 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3136 aGroup->Add(aFaces.inout());
3137 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3138 anEntryList.append( aSObject->GetID().c_str() );
3140 if (aVolumes->length() > 0) {
3141 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3142 aGroup->Add(aVolumes.inout());
3143 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3144 anEntryList.append( aSObject->GetID().c_str() );
3147 anApp->browseObjects( anEntryList );
3149 catch(const SALOME::SALOME_Exception & S_ex){
3150 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3157 SUIT_MessageBox::warning(desktop(),
3158 tr("SMESH_WRN_WARNING"),
3159 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3164 case SMESHOp::OpEditGroup:
3168 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3172 if(isStudyLocked()) break;
3173 if ( warnOnGeomModif() )
3174 break; // action forbidden as geometry modified
3175 EmitSignalDeactivateDialog();
3177 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3178 SALOME_ListIO selected;
3180 aSel->selectedObjects( selected );
3182 SALOME_ListIteratorOfListIO It (selected);
3183 int nbSelectedGroups = 0;
3184 for ( ; It.More(); It.Next() )
3186 SMESH::SMESH_GroupBase_var aGroup =
3187 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3188 if (!aGroup->_is_nil()) {
3190 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3194 if (nbSelectedGroups == 0)
3196 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3202 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3204 if(isStudyLocked()) break;
3205 if (myState == 800) {
3206 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3207 if (aDlg) aDlg->onAdd();
3212 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3214 if(isStudyLocked()) break;
3215 if (myState == 800) {
3216 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3217 if (aDlg) aDlg->onRemove();
3222 case SMESHOp::OpEditGeomGroupAsGroup:
3226 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3230 if(isStudyLocked()) break;
3231 EmitSignalDeactivateDialog();
3233 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3234 SALOME_ListIO selected;
3236 aSel->selectedObjects( selected );
3238 SALOME_ListIteratorOfListIO It (selected);
3239 for ( ; It.More(); It.Next() )
3241 SMESH::SMESH_GroupOnGeom_var aGroup =
3242 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3243 if (!aGroup->_is_nil()) {
3244 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3249 SMESH::SMESH_GroupOnFilter_var aGroup =
3250 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3251 if (!aGroup->_is_nil()) {
3252 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3260 case SMESHOp::OpUnionGroups:
3261 case SMESHOp::OpIntersectGroups:
3262 case SMESHOp::OpCutGroups:
3266 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3270 if ( isStudyLocked() )
3272 if ( warnOnGeomModif() )
3273 break; // action forbidden as geometry modified
3275 EmitSignalDeactivateDialog();
3277 SMESHGUI_GroupOpDlg* aDlg = 0;
3278 if ( theCommandID == SMESHOp::OpUnionGroups )
3279 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3280 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3281 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3283 aDlg = new SMESHGUI_CutGroupsDlg( this );
3290 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3292 if ( isStudyLocked() )
3294 if ( warnOnGeomModif() )
3295 break; // action forbidden as geometry modified
3297 EmitSignalDeactivateDialog();
3298 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3304 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3306 if ( isStudyLocked() )
3308 if ( warnOnGeomModif() )
3309 break; // action forbidden as geometry modified
3311 EmitSignalDeactivateDialog();
3312 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3318 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3322 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3326 if ( isStudyLocked() )
3329 EmitSignalDeactivateDialog();
3331 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3335 case SMESHOp::OpMeshInformation:
3336 case SMESHOp::OpWhatIs:
3338 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3339 EmitSignalDeactivateDialog();
3340 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3341 SALOME_ListIO selected;
3343 aSel->selectedObjects( selected );
3345 if ( selected.Extent() > 1 ) { // a dlg for each IO
3346 SALOME_ListIteratorOfListIO It( selected );
3347 for ( ; It.More(); It.Next() ) {
3348 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3349 dlg->showInfo( It.Value() );
3354 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3360 case SMESHOp::OpFindElementByPoint:
3362 startOperation( theCommandID );
3366 case SMESHOp::OpEditHypothesis:
3368 if(isStudyLocked()) break;
3369 if ( warnOnGeomModif() )
3370 break; // action forbidden as geometry modified
3372 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3373 SALOME_ListIO selected;
3375 aSel->selectedObjects( selected );
3377 int nbSel = selected.Extent();
3380 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3381 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3383 if ( !aHypothesis->_is_nil() )
3385 SMESHGUI_GenericHypothesisCreator* aCreator =
3386 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3389 // set geometry of mesh and sub-mesh to aCreator
3390 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3391 if ( selected.Extent() == 1 )
3393 QString subGeomID, meshGeomID;
3394 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3395 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3397 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3398 aCreator->setShapeEntry( subGeomID );
3399 aCreator->setMainShapeEntry( meshGeomID );
3403 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3413 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3415 if(isStudyLocked()) break;
3416 if ( warnOnGeomModif() )
3417 break; // action forbidden as geometry modified
3418 SUIT_OverrideCursor wc;
3420 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3421 SALOME_ListIO selected;
3423 aSel->selectedObjects( selected, QString::null, false );
3425 SALOME_ListIteratorOfListIO It(selected);
3426 for (int i = 0; It.More(); It.Next(), i++) {
3427 Handle(SALOME_InteractiveObject) IObject = It.Value();
3428 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3431 aSel->setSelectedObjects( l1 );
3436 case SMESHOp::OpElem0D:
3437 case SMESHOp::OpBall:
3438 case SMESHOp::OpEdge:
3439 case SMESHOp::OpTriangle:
3440 case SMESHOp::OpQuadrangle:
3441 case SMESHOp::OpPolygon:
3442 case SMESHOp::OpTetrahedron:
3443 case SMESHOp::OpHexahedron:
3444 case SMESHOp::OpPentahedron:
3445 case SMESHOp::OpPyramid:
3446 case SMESHOp::OpHexagonalPrism:
3448 if(isStudyLocked()) break;
3449 if ( warnOnGeomModif() )
3450 break; // action forbidden as geometry modified
3452 EmitSignalDeactivateDialog();
3453 SMDSAbs_EntityType type = SMDSEntity_Edge;
3454 switch (theCommandID) {
3455 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3456 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3457 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3458 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3459 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3460 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3461 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3462 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3463 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3464 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3467 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3470 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3474 case SMESHOp::OpPolyhedron:
3476 if(isStudyLocked()) break;
3477 if ( warnOnGeomModif() )
3478 break; // action forbidden as geometry modified
3480 EmitSignalDeactivateDialog();
3481 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3484 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3488 case SMESHOp::OpQuadraticEdge:
3489 case SMESHOp::OpQuadraticTriangle:
3490 case SMESHOp::OpBiQuadraticTriangle:
3491 case SMESHOp::OpQuadraticQuadrangle:
3492 case SMESHOp::OpBiQuadraticQuadrangle:
3493 case SMESHOp::OpQuadraticPolygon:
3494 case SMESHOp::OpQuadraticTetrahedron:
3495 case SMESHOp::OpQuadraticPyramid:
3496 case SMESHOp::OpQuadraticPentahedron:
3497 case SMESHOp::OpBiQuadraticPentahedron:
3498 case SMESHOp::OpQuadraticHexahedron:
3499 case SMESHOp::OpTriQuadraticHexahedron:
3501 if(isStudyLocked()) break;
3502 if ( warnOnGeomModif() )
3503 break; // action forbidden as geometry modified
3505 EmitSignalDeactivateDialog();
3506 SMDSAbs_EntityType type = SMDSEntity_Last;
3508 switch (theCommandID) {
3509 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3510 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3511 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3512 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3513 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3514 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3515 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3516 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3517 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3518 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3519 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3520 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3523 if ( type != SMDSEntity_Last )
3524 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3527 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3528 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3532 case SMESHOp::OpRemoveNodes:
3534 if(isStudyLocked()) break;
3535 if ( warnOnGeomModif() )
3536 break; // action forbidden as geometry modified
3538 EmitSignalDeactivateDialog();
3539 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3542 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3543 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3547 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3549 if(isStudyLocked()) break;
3550 if ( warnOnGeomModif() )
3551 break; // action forbidden as geometry modified
3553 EmitSignalDeactivateDialog();
3554 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3558 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3559 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3563 case SMESHOp::OpClearMesh: {
3565 if(isStudyLocked()) break;
3566 if ( warnOnGeomModif() )
3567 break; // action forbidden as geometry modified
3569 SALOME_ListIO selected;
3570 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3571 aSel->selectedObjects( selected );
3573 SUIT_OverrideCursor wc;
3574 SALOME_ListIteratorOfListIO It (selected);
3575 for ( ; It.More(); It.Next() )
3577 Handle(SALOME_InteractiveObject) IOS = It.Value();
3578 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3579 if ( aMesh->_is_nil()) continue;
3582 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3583 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3584 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3585 // hide groups and submeshes
3586 _PTR(ChildIterator) anIter =
3587 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3588 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3590 _PTR(SObject) so = anIter->Value();
3591 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3594 catch (const SALOME::SALOME_Exception& S_ex){
3596 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3600 SMESH::UpdateView();
3604 case SMESHOp::OpRemoveOrphanNodes:
3606 if(isStudyLocked()) break;
3607 if ( warnOnGeomModif() )
3608 break; // action forbidden as geometry modified
3609 SALOME_ListIO selected;
3610 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3611 aSel->selectedObjects( selected );
3612 if ( selected.Extent() == 1 ) {
3613 Handle(SALOME_InteractiveObject) anIO = selected.First();
3614 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3615 if ( !aMesh->_is_nil() ) {
3616 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3617 tr( "SMESH_WARNING" ),
3618 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3619 SUIT_MessageBox::Yes |
3620 SUIT_MessageBox::No,
3621 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3624 SUIT_OverrideCursor wc;
3625 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3626 int removed = aMeshEditor->RemoveOrphanNodes();
3627 SUIT_MessageBox::information(SMESHGUI::desktop(),
3628 tr("SMESH_INFORMATION"),
3629 tr("NB_NODES_REMOVED").arg(removed));
3630 if ( removed > 0 ) {
3631 SMESH::UpdateView();
3632 SMESHGUI::Modified();
3635 catch (const SALOME::SALOME_Exception& S_ex) {
3636 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3645 case SMESHOp::OpRenumberingNodes:
3647 if(isStudyLocked()) break;
3648 if ( warnOnGeomModif() )
3649 break; // action forbidden as geometry modified
3651 EmitSignalDeactivateDialog();
3652 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3656 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3657 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3661 case SMESHOp::OpRenumberingElements:
3663 if(isStudyLocked()) break;
3664 if ( warnOnGeomModif() )
3665 break; // action forbidden as geometry modified
3667 EmitSignalDeactivateDialog();
3668 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3672 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3673 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3677 case SMESHOp::OpTranslation:
3679 if(isStudyLocked()) break;
3680 if ( warnOnGeomModif() )
3681 break; // action forbidden as geometry modified
3683 EmitSignalDeactivateDialog();
3684 ( new SMESHGUI_TranslationDlg( this ) )->show();
3687 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3688 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3692 case SMESHOp::OpRotation:
3694 if(isStudyLocked()) break;
3695 if ( warnOnGeomModif() )
3696 break; // action forbidden as geometry modified
3698 EmitSignalDeactivateDialog();
3699 ( new SMESHGUI_RotationDlg( this ) )->show();
3702 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3703 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3707 case SMESHOp::OpSymmetry:
3709 if(isStudyLocked()) break;
3710 if ( warnOnGeomModif() )
3711 break; // action forbidden as geometry modified
3713 EmitSignalDeactivateDialog();
3714 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3717 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3718 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3722 case SMESHOp::OpScale:
3724 if(isStudyLocked()) break;
3725 if ( warnOnGeomModif() )
3726 break; // action forbidden as geometry modified
3728 EmitSignalDeactivateDialog();
3729 ( new SMESHGUI_ScaleDlg( this ) )->show();
3732 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3733 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3738 case SMESHOp::OpOffset:
3740 if(isStudyLocked()) break;
3741 if ( warnOnGeomModif() )
3742 break; // action forbidden as geometry modified
3744 EmitSignalDeactivateDialog();
3745 ( new SMESHGUI_OffsetDlg( this ) )->show();
3748 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3749 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3754 case SMESHOp::OpSewing:
3756 if(isStudyLocked()) break;
3757 if ( warnOnGeomModif() )
3758 break; // action forbidden as geometry modified
3760 EmitSignalDeactivateDialog();
3761 ( new SMESHGUI_SewingDlg( this ) )->show();
3764 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3765 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3769 case SMESHOp::OpMergeNodes:
3771 if(isStudyLocked()) break;
3772 if ( warnOnGeomModif() )
3773 break; // action forbidden as geometry modified
3775 EmitSignalDeactivateDialog();
3776 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3779 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3780 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3784 case SMESHOp::OpMergeElements:
3786 if (isStudyLocked()) break;
3787 if ( warnOnGeomModif() )
3788 break; // action forbidden as geometry modified
3790 EmitSignalDeactivateDialog();
3791 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3793 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3794 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3799 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3800 if ( warnOnGeomModif() )
3801 break; // action forbidden as geometry modified
3802 startOperation( SMESHOp::OpMoveNode );
3805 case SMESHOp::OpDuplicateNodes:
3807 if(isStudyLocked()) break;
3808 if ( warnOnGeomModif() )
3809 break; // action forbidden as geometry modified
3811 EmitSignalDeactivateDialog();
3812 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3815 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3816 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3821 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3822 if ( warnOnGeomModif() )
3823 break; // action forbidden as geometry modified
3824 startOperation( SMESHOp::OpElem0DOnElemNodes );
3827 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3829 static QList<int> aTypes;
3830 if ( aTypes.isEmpty() )
3832 aTypes.append( SMESH::NODE );
3833 aTypes.append( SMESH::EDGE );
3834 aTypes.append( SMESH::FACE );
3835 aTypes.append( SMESH::VOLUME );
3837 if (!myFilterLibraryDlg)
3838 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3839 else if (myFilterLibraryDlg->isHidden())
3840 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3841 myFilterLibraryDlg->raise();
3845 case SMESHOp::OpFreeNode:
3846 case SMESHOp::OpEqualNode:
3847 case SMESHOp::OpNodeConnectivityNb:
3848 case SMESHOp::OpFreeEdge:
3849 case SMESHOp::OpFreeBorder:
3850 case SMESHOp::OpLength:
3851 case SMESHOp::OpConnection:
3852 case SMESHOp::OpEqualEdge:
3853 case SMESHOp::OpFreeFace:
3854 case SMESHOp::OpBareBorderFace:
3855 case SMESHOp::OpOverConstrainedFace:
3856 case SMESHOp::OpLength2D:
3857 case SMESHOp::OpDeflection2D:
3858 case SMESHOp::OpConnection2D:
3859 case SMESHOp::OpArea:
3860 case SMESHOp::OpTaper:
3861 case SMESHOp::OpAspectRatio:
3862 case SMESHOp::OpMinimumAngle:
3863 case SMESHOp::OpWarpingAngle:
3864 case SMESHOp::OpSkew:
3865 case SMESHOp::OpMaxElementLength2D:
3866 case SMESHOp::OpEqualFace:
3867 case SMESHOp::OpAspectRatio3D:
3868 case SMESHOp::OpVolume:
3869 case SMESHOp::OpMaxElementLength3D:
3870 case SMESHOp::OpBareBorderVolume:
3871 case SMESHOp::OpOverConstrainedVolume:
3872 case SMESHOp::OpEqualVolume:
3875 LightApp_SelectionMgr* mgr = selectionMgr();
3876 SALOME_ListIO selected; mgr->selectedObjects( selected );
3878 if( !selected.IsEmpty() ) {
3879 SUIT_OverrideCursor wc;
3880 ::Control( theCommandID );
3883 SUIT_MessageBox::warning(desktop(),
3884 tr( "SMESH_WRN_WARNING" ),
3885 tr( "SMESH_BAD_SELECTION" ) );
3889 SUIT_MessageBox::warning(desktop(),
3890 tr( "SMESH_WRN_WARNING" ),
3891 tr( "NOT_A_VTK_VIEWER" ) );
3894 case SMESHOp::OpOverallMeshQuality:
3895 OverallMeshQuality();
3897 case SMESHOp::OpNumberingNodes:
3899 SUIT_OverrideCursor wc;
3900 LightApp_SelectionMgr* mgr = selectionMgr();
3901 SALOME_ListIO selected; mgr->selectedObjects( selected );
3903 SALOME_ListIteratorOfListIO it(selected);
3904 for( ; it.More(); it.Next()) {
3905 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3906 if(anIObject->hasEntry()) {
3907 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3908 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3914 case SMESHOp::OpNumberingElements:
3916 SUIT_OverrideCursor wc;
3917 LightApp_SelectionMgr* mgr = selectionMgr();
3918 SALOME_ListIO selected; mgr->selectedObjects( selected );
3920 SALOME_ListIteratorOfListIO it(selected);
3921 for( ; it.More(); it.Next()) {
3922 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3923 if(anIObject->hasEntry())
3924 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3925 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3930 case SMESHOp::OpPropertiesLength:
3931 case SMESHOp::OpPropertiesArea:
3932 case SMESHOp::OpPropertiesVolume:
3933 case SMESHOp::OpMinimumDistance:
3934 case SMESHOp::OpBoundingBox:
3935 case SMESHOp::OpAngle:
3937 int page = SMESHGUI_MeasureDlg::MinDistance;
3938 if ( theCommandID == SMESHOp::OpBoundingBox )
3939 page = SMESHGUI_MeasureDlg::BoundingBox;
3940 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3941 page = SMESHGUI_MeasureDlg::Length;
3942 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3943 page = SMESHGUI_MeasureDlg::Area;
3944 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3945 page = SMESHGUI_MeasureDlg::Volume;
3946 else if ( theCommandID == SMESHOp::OpAngle )
3947 page = SMESHGUI_MeasureDlg::Angle;
3949 EmitSignalDeactivateDialog();
3950 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3954 case SMESHOp::OpSortChild:
3957 case SMESHOp::OpBreakLink:
3958 ::breakShaperLink();
3963 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3964 //updateObjBrowser();
3968 //=============================================================================
3972 //=============================================================================
3973 bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3978 //=============================================================================
3982 //=============================================================================
3983 bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3988 //=============================================================================
3992 //=============================================================================
3993 bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3998 //=============================================================================
3999 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
4000 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
4002 //=============================================================================
4003 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
4004 SUIT_ViewWindow* wnd )
4006 if(theIO->hasEntry()){
4007 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
4008 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
4012 //=======================================================================
4013 // function : createSMESHAction
4015 //=======================================================================
4016 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
4017 const int key, const bool toggle, const QString& shortcutAction )
4020 QWidget* parent = application()->desktop();
4021 SUIT_ResourceMgr* resMgr = resourceMgr();
4023 if ( !icon_id.isEmpty() )
4024 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4026 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICON_%1" ).arg( po_id ).toLatin1().data() ), false );
4027 if ( !pix.isNull() )
4028 icon = QIcon( pix );
4030 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4031 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4032 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4034 createAction( id, tooltip, icon, menu, status_bar, key, parent,
4035 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4038 //=======================================================================
4039 // function : createPopupItem
4041 //=======================================================================
4042 void SMESHGUI::createPopupItem( const int id,
4043 const QString& clients,
4044 const QString& types,
4045 const QString& theRule,
4048 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4049 popupMgr()->insert( action( id ), pId, 0 );
4051 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4052 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4053 QString rule = "(%1) and (%2) and (%3)";
4054 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4055 if( clients.isEmpty() )
4056 rule = rule.arg( QString( "true" ) );
4058 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4059 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4062 bool cont = myRules.contains( id );
4064 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4066 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4067 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4070 //=======================================================================
4071 // function : initialize
4073 //=======================================================================
4074 void SMESHGUI::initialize( CAM_Application* app )
4076 SalomeApp_Module::initialize( app );
4078 // SUIT_ResourceMgr* mgr = app->resourceMgr();
4080 /* Automatic Update flag */
4081 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4083 // ----- create actions --------------
4085 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4086 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4087 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4088 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
4090 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4092 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
4093 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
4094 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4095 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4096 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
4098 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4100 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
4101 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
4103 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
4104 createSMESHAction( SMESHOp::OpExportMED, "MED" );
4105 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
4106 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
4108 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4110 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
4111 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
4112 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4113 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4114 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4115 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4117 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4119 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
4120 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
4121 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4122 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
4123 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4124 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
4125 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
4126 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
4127 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
4128 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
4129 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
4130 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
4131 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
4132 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
4133 createSMESHAction( SMESHOp::OpRecompute, "RE_COMPUTE", "ICON_COMPUTE" );
4134 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
4135 createSMESHAction( SMESHOp::OpShowErrors, "SHOW_ERRORS", "ICON_SHOW_ERRORS" );
4136 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
4137 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
4138 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
4139 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
4140 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
4141 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
4142 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4143 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
4144 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
4145 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
4146 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
4147 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
4148 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
4149 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4150 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
4151 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
4152 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
4153 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4154 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
4156 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
4157 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
4158 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
4159 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
4160 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
4161 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
4162 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
4163 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
4164 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
4165 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
4166 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
4167 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
4168 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
4169 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
4170 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
4171 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
4172 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
4173 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
4174 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
4175 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
4176 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
4177 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
4178 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
4179 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4180 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4181 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4182 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4183 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4184 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4186 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4187 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4188 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4189 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4190 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4191 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4192 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4193 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4194 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4195 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4196 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4197 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4198 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4199 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4200 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4201 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4202 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4203 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4204 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4205 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4206 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4207 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4208 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4209 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4210 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4211 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4213 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4214 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4215 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4216 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4218 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4219 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4221 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4222 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4223 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4224 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4225 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4226 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4227 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4228 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4229 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4230 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4231 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4232 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4233 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4234 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4235 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4236 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4237 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4238 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4239 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4240 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4241 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4242 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4243 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4244 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4245 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4247 createSMESHAction( SMESHOp::OpReset, "RESET" );
4248 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4249 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4250 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4251 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4252 #ifndef DISABLE_PLOT2DVIEWER
4253 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4255 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4256 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4257 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4258 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4259 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4260 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4261 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4262 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4263 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4264 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4265 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4266 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4267 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4269 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4270 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4272 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4273 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4274 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4275 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4276 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4277 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4278 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4279 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4280 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4282 // Adaptation - begin
4283 createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
4286 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4287 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4288 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4289 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4290 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4291 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4293 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4294 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4295 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4297 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4299 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4301 QList<int> aCtrlActions;
4302 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4303 << SMESHOp::OpNodeConnectivityNb // node controls
4304 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4305 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4306 << SMESHOp::OpDeflection2D
4307 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4308 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4309 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4310 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4311 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4312 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4313 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4314 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4315 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4316 aCtrlGroup->setExclusive( true );
4317 for( int i = 0; i < aCtrlActions.size(); i++ )
4318 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4320 // ----- create menu --------------
4321 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4322 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4323 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4324 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4325 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4326 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4327 adaptId = createMenu( tr( "MEN_ADAPT" ), -1, 80, 10 ),
4328 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4329 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4331 createMenu( separator(), fileId );
4333 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4334 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4335 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4336 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4337 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4338 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4339 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4340 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4341 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4342 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4343 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4344 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4345 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4347 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4348 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4349 createMenu( SMESHOp::OpImportMED, importId, -1 );
4350 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4352 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4354 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4355 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4356 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4357 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4358 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4359 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4361 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4363 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4364 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4365 createMenu( separator(), fileId, 10 );
4367 createMenu( SMESHOp::OpDelete, editId, -1 );
4369 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4371 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4372 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4373 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4374 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4375 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4376 createMenu( separator(), meshId, -1 );
4377 createMenu( SMESHOp::OpCompute, meshId, -1 );
4378 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4379 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4380 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4381 createMenu( separator(), meshId, -1 );
4382 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4383 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4384 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4385 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4386 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4387 createMenu( separator(), meshId, -1 );
4388 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4389 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4390 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4391 createMenu( separator(), meshId, -1 );
4392 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4393 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4394 createMenu( separator(), meshId, -1 );
4395 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4396 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4397 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4398 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4399 createMenu( separator(), meshId, -1 );
4401 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4402 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4403 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4404 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4405 createMenu( SMESHOp::OpLength, edgeId, -1 );
4406 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4407 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4408 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4409 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4410 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4411 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4412 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4413 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4414 createMenu( SMESHOp::OpArea, faceId, -1 );
4415 createMenu( SMESHOp::OpTaper, faceId, -1 );
4416 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4417 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4418 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4419 createMenu( SMESHOp::OpSkew, faceId, -1 );
4420 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4421 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4422 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4423 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4424 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4425 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4426 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4427 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4428 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4429 createMenu( separator(), ctrlId, -1 );
4430 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4431 createMenu( separator(), ctrlId, -1 );
4432 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4434 createMenu( SMESHOp::OpNode, addId, -1 );
4435 createMenu( SMESHOp::OpElem0D, addId, -1 );
4436 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4437 createMenu( SMESHOp::OpBall, addId, -1 );
4438 createMenu( SMESHOp::OpEdge, addId, -1 );
4439 createMenu( SMESHOp::OpTriangle, addId, -1 );
4440 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4441 createMenu( SMESHOp::OpPolygon, addId, -1 );
4442 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4443 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4444 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4445 createMenu( SMESHOp::OpPyramid, addId, -1 );
4446 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4447 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4448 createMenu( separator(), addId, -1 );
4449 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4450 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4451 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4452 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4453 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4454 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4455 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4456 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4457 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4458 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4459 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4460 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4462 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4463 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4464 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4465 createMenu( separator(), removeId, -1 );
4466 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4467 createMenu( separator(), removeId, -1 );
4468 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4470 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4471 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4473 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4474 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4475 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4476 createMenu( SMESHOp::OpRotation, transfId, -1 );
4477 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4478 createMenu( SMESHOp::OpScale, transfId, -1 );
4479 createMenu( SMESHOp::OpOffset, transfId, -1 );
4480 createMenu( SMESHOp::OpSewing, transfId, -1 );
4481 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4483 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4484 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4485 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4486 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4487 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4488 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4489 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4490 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4491 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4492 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4493 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4494 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4495 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4496 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4497 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4498 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4500 // Adaptation - begin
4501 createMenu( SMESHOp::OpMGAdapt, adaptId, -1 );
4504 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4505 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4506 createMenu( SMESHOp::OpAngle, measureId, -1 );
4507 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4508 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4509 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4510 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4512 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4513 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4514 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4515 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4517 // ----- create toolbars --------------
4518 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ) ;
4519 createTool( SMESHOp::OpCreateMesh, meshTb );
4520 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4521 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4522 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4523 createTool( SMESHOp::OpCopyMesh, meshTb );
4524 createTool( separator(), meshTb );
4525 createTool( SMESHOp::OpCompute, meshTb );
4526 createTool( SMESHOp::OpPreCompute, meshTb );
4527 createTool( SMESHOp::OpEvaluate, meshTb );
4528 createTool( SMESHOp::OpMeshOrder, meshTb );
4530 int infoTb = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ) ;
4531 createTool( SMESHOp::OpMeshInformation, infoTb );
4532 //createTool( SMESHOp::OpStdInfo, meshTb );
4533 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4534 createTool( SMESHOp::OpFindElementByPoint, infoTb );
4536 int groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ) ;
4537 createTool( SMESHOp::OpCreateGroup, groupTb );
4538 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4539 createTool( SMESHOp::OpConstructGroup, groupTb );
4540 createTool( SMESHOp::OpEditGroup, groupTb );
4542 int ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ) ;
4543 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4544 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4545 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4547 int ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ) ;
4548 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4549 createTool( SMESHOp::OpLength, ctrl1dTb );
4550 createTool( SMESHOp::OpConnection, ctrl1dTb );
4551 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4553 int ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ) ;
4554 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4555 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4556 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4557 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4558 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4559 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4560 createTool( SMESHOp::OpArea, ctrl2dTb );
4561 createTool( SMESHOp::OpTaper, ctrl2dTb );
4562 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4563 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4564 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4565 createTool( SMESHOp::OpSkew, ctrl2dTb );
4566 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4567 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4568 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4570 int ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ) ;
4571 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4572 createTool( SMESHOp::OpVolume, ctrl3dTb );
4573 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4574 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4575 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4576 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4578 int addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ) ;
4579 createTool( SMESHOp::OpNode, addElemTb );
4580 createTool( SMESHOp::OpElem0D, addElemTb );
4581 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4582 createTool( SMESHOp::OpBall, addElemTb );
4583 createTool( SMESHOp::OpEdge, addElemTb );
4584 createTool( SMESHOp::OpTriangle, addElemTb );
4585 createTool( SMESHOp::OpQuadrangle, addElemTb );
4586 createTool( SMESHOp::OpPolygon, addElemTb );
4587 createTool( SMESHOp::OpTetrahedron, addElemTb );
4588 createTool( SMESHOp::OpHexahedron, addElemTb );
4589 createTool( SMESHOp::OpPentahedron, addElemTb );
4590 createTool( SMESHOp::OpPyramid, addElemTb );
4591 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4592 createTool( SMESHOp::OpPolyhedron, addElemTb );
4594 int addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ) ;
4595 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4596 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4597 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4598 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4599 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4600 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4601 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4602 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4603 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4604 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4605 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4606 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4608 int remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ) ;
4609 createTool( SMESHOp::OpRemoveNodes, remTb );
4610 createTool( SMESHOp::OpRemoveElements, remTb );
4611 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4612 createTool( SMESHOp::OpClearMesh, remTb );
4614 // int renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ) ;
4615 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4616 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4618 int transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ) ;
4619 createTool( SMESHOp::OpMergeNodes, transformTb );
4620 createTool( SMESHOp::OpMergeElements, transformTb );
4621 createTool( SMESHOp::OpTranslation, transformTb );
4622 createTool( SMESHOp::OpRotation, transformTb );
4623 createTool( SMESHOp::OpSymmetry, transformTb );
4624 createTool( SMESHOp::OpScale, transformTb );
4625 createTool( SMESHOp::OpOffset, transformTb );
4626 createTool( SMESHOp::OpSewing, transformTb );
4627 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4629 int modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ) ;
4630 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4631 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4632 createTool( SMESHOp::OpExtrusion, modifyTb );
4633 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4634 createTool( SMESHOp::OpRevolution, modifyTb );
4635 createTool( SMESHOp::OpOrientation, modifyTb );
4636 createTool( SMESHOp::OpReorientFaces, modifyTb );
4637 createTool( SMESHOp::OpMoveNode, modifyTb );
4638 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4639 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4640 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4641 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4642 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4643 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4644 createTool( SMESHOp::OpSmoothing, modifyTb );
4645 createTool( SMESHOp::OpPatternMapping, modifyTb );
4647 // Adaptation - begin
4648 int adaptTb = createTool( tr( "TB_ADAPTATION" ),QString( "SMESHAdaptationToolbar" ) ) ;
4649 createTool( SMESHOp::OpMGAdapt, adaptTb );
4652 int measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ) ;
4653 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4655 int dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4656 createTool( SMESHOp::OpUpdate, dispModeTb );
4658 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4659 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4663 OB = "'ObjectBrowser'",
4664 View = "'" + SVTK_Viewer::Type() + "'",
4666 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4667 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4668 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4669 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4670 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4671 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4672 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4673 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4674 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4675 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4676 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4677 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4679 mesh_part = mesh + " " + subMesh + " " + group,
4680 mesh_group = mesh + " " + group,
4681 mesh_submesh = mesh + " " + subMesh,
4682 hyp_alg = hypo + " " + algo;
4684 // popup for object browser
4686 isInvisible("not( isVisible )"),
4687 isEmpty("numberOfNodes = 0"),
4688 isNotEmpty("numberOfNodes <> 0"),
4690 // has nodes, edges, etc in VISIBLE! actor
4691 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4692 hasElems("(count( elemTypes ) > 0)"),
4693 hasDifferentElems("(count( elemTypes ) > 1)"),
4694 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4695 hasBalls("({'BallElem'} in elemTypes)"),
4696 hasElems0d("({'Elem0d'} in elemTypes)"),
4697 hasEdges("({'Edge'} in elemTypes)"),
4698 hasFaces("({'Face'} in elemTypes)"),
4699 hasVolumes("({'Volume'} in elemTypes)"),
4700 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4702 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4703 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4704 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && hasAlgo && hasGeomReference" );
4705 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4706 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4707 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4709 popupMgr()->insert( separator(), -1, 0 );
4710 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4711 createPopupItem( SMESHOp::OpRecompute, OB, mesh, "&& selcount=1 && hasAlgo && (" + isNotEmpty + " || hasErrors )");
4712 createPopupItem( SMESHOp::OpShowErrors, OB, mesh, "&& selcount=1 && hasErrors" );
4713 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
4714 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );
4715 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4716 popupMgr()->insert( separator(), -1, 0 );
4717 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4718 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4719 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1 && " + hasElems );
4720 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4721 popupMgr()->insert( separator(), -1, 0 );
4722 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4723 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4724 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4725 popupMgr()->insert( separator(), -1, 0 );
4726 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4727 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4728 popupMgr()->insert( separator(), -1, 0 );
4729 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
4730 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4731 popupMgr()->insert( separator(), -1, 0 );
4733 // Adaptation - begin
4734 createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
4737 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4738 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4739 QString only_one_2D = only_one_non_empty + " && dim>1";
4741 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4742 popupMgr()->findMenu( anId )->menuAction()->setIcon( resourceMgr()->loadPixmap( "SMESH", tr( "ICON_EXPORT" )));
4743 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4744 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4745 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4747 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4749 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4750 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4751 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4753 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4754 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4755 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4756 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4758 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4760 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4761 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4762 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4763 popupMgr()->insert( separator(), -1, 0 );
4765 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4766 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4767 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4770 createPopupItem( SMESHOp::OpEditGroup, View, group );
4771 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4772 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4774 popupMgr()->insert( separator(), -1, 0 );
4775 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4776 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4777 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh, "&& " + hasElems);
4778 popupMgr()->insert( separator(), -1, 0 );
4780 createPopupItem( SMESHOp::OpUpdate, OB + " " + View, mesh_part );
4781 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4782 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4783 popupMgr()->insert( separator(), -1, 0 );
4785 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4786 QString aType = QString( "%1type in {%2}" ).arg( lc );
4787 aType = aType.arg( mesh_part );
4788 QString aMeshInVTK = aClient + "&&" + aType;
4790 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4791 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4792 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4794 //-------------------------------------------------
4796 //-------------------------------------------------
4797 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4799 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4800 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4801 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4803 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4804 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4805 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4807 popupMgr()->insert( separator(), -1, -1 );
4809 //-------------------------------------------------
4811 //-------------------------------------------------
4812 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4814 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4815 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4816 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4818 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4819 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4820 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4822 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4823 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4824 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4826 popupMgr()->insert( separator(), anId, -1 );
4828 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4829 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4830 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4832 //-------------------------------------------------
4834 //-------------------------------------------------
4835 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4837 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4839 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4840 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4841 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4843 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4844 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4845 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4847 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4848 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4849 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4851 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4852 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4853 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4855 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4856 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4857 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4859 popupMgr()->insert( separator(), anId, -1 );
4861 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4862 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4864 popupMgr()->insert( separator(), anId, -1 );
4866 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4867 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4870 //-------------------------------------------------
4871 // Representation of the 2D Quadratic elements
4872 //-------------------------------------------------
4873 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4874 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4875 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4876 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4878 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4879 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4880 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4882 //-------------------------------------------------
4883 // Orientation of faces
4884 //-------------------------------------------------
4885 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4886 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4887 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4889 //-------------------------------------------------
4891 //-------------------------------------------------
4892 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4893 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4895 //-------------------------------------------------
4897 //-------------------------------------------------
4898 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4899 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4901 //-------------------------------------------------
4903 //-------------------------------------------------
4905 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4906 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4907 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4908 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4910 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4912 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4913 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4915 popupMgr()->insert( separator(), anId, -1 );
4917 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4919 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4920 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4921 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4923 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4924 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4925 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4927 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4928 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4929 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4931 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4933 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4934 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4935 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4937 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4938 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4939 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4941 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4942 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4943 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4944 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4945 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4946 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4948 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4950 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4951 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4952 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4954 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4955 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4956 QtxPopupMgr::VisibleRule );
4957 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4959 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4960 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4961 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4963 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4964 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4965 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4967 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4968 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4969 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4971 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4972 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4973 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4975 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4976 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4977 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4979 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4980 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4981 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4983 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4984 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4985 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4987 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4988 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4989 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4991 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4992 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4993 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4995 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4996 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4997 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4999 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
5000 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5001 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
5003 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
5004 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5005 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
5007 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
5008 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
5009 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
5011 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
5013 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
5014 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5015 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
5017 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
5018 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5019 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
5021 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
5022 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5023 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5025 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5026 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5027 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5029 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5030 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5031 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5033 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
5034 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5035 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5037 popupMgr()->insert( separator(), anId, -1 );
5039 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5040 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5041 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5042 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5043 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5045 popupMgr()->insert( separator(), anId, -1 );
5047 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5049 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5050 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5052 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5053 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5054 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5056 #ifndef DISABLE_PLOT2DVIEWER
5057 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5058 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5061 //-------------------------------------------------
5063 //-------------------------------------------------
5064 popupMgr()->insert( separator(), -1, -1 );
5065 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5066 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5067 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5068 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5070 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5071 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5073 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5074 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5076 popupMgr()->insert( separator(), -1, -1 );
5078 //-------------------------------------------------
5080 //-------------------------------------------------
5081 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5082 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5084 popupMgr()->insert( separator(), -1, -1 );
5086 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5087 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5088 popupMgr()->insert( separator(), -1, -1 );
5090 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5091 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5093 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5094 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5096 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5097 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5100 //================================================================================
5102 * \brief Return true if SMESH or GEOM objects are selected.
5103 * Is called form LightApp_Module::activateModule() which clear selection if
5104 * not isSelectionCompatible()
5106 //================================================================================
5108 bool SMESHGUI::isSelectionCompatible()
5110 bool isCompatible = true;
5111 SALOME_ListIO selected;
5112 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5113 Sel->selectedObjects( selected );
5115 SALOME_ListIteratorOfListIO It( selected );
5116 for ( ; isCompatible && It.More(); It.Next())
5118 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
5119 ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5120 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
5122 return isCompatible;
5126 bool SMESHGUI::reusableOperation( const int id )
5128 // compute, evaluate and precompute are not reusable operations
5129 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate || id == SMESHOp::OpRecompute ) ? false : SalomeApp_Module::reusableOperation( id );
5134 QString wrap(const QString& text, const QString& tag)
5135 { return QString("<%1>%2</%3>").arg(tag).arg(text).arg(tag);}
5138 bool SMESHGUI::activateModule( SUIT_Study* study )
5140 bool res = SalomeApp_Module::activateModule( study );
5142 setMenuShown( true );
5143 setToolShown( true );
5145 // Fill in Help Panel
5146 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( application() );
5147 app->infoPanel()->setTitle(tr("INFO_WELCOME_TO_SMESH"));
5149 int gb = app->infoPanel()->addGroup(tr("INFO_GRP_CREATE_MESH"));
5152 lab = tr("INFO_DEFINE_ALGOS") + "<br/>";
5153 lab = lab + tr("INFO_DEFINE_HYPOS") + "<br/>";
5154 lab = lab + tr("INFO_COMPUTE") + "<br/>";
5155 lab = lab + tr("INFO_REFINE") + ":";
5156 items << wrap(tr("INFO_REFINE_LOCAL_SIZE"), "li")
5157 << wrap(tr("INFO_REFINE_SUBMESH"), "li");
5158 lab = lab + wrap(items.join(""), "ul");
5161 app->infoPanel()->addLabel(lab, gb);
5163 gb = app->infoPanel()->addGroup(tr("INFO_GRP_IMPORT_MESH"));
5164 items << wrap("UNV", "li")
5165 << wrap("MED", "li")
5166 << wrap("STL", "li")
5167 << wrap("CGNS", "li")
5168 << wrap("SAUV", "li")
5169 << wrap("GMF", "li");
5170 lab = tr("INFO_AVAILABLE_FORMATS") + ":" + wrap(items.join(""), "ul");
5173 app->infoPanel()->addLabel(lab, gb);
5175 gb = app->infoPanel()->addGroup(tr("INFO_GRP_CHECK_MESH"));
5176 lab = tr("INFO_DISPLAY") + "<br/>";
5177 items << wrap(tr("INFO_QUALITY_AREA"), "li")
5178 << wrap(tr("INFO_QUALITY_VOLUME"), "li")
5179 << wrap(tr("INFO_QUALITY_ASPECT_RATION"), "li")
5180 << wrap("...", "li");
5181 lab = lab + tr("INFO_QUALITY_INFO") + ":" + wrap(items.join(""), "ul");
5183 lab = lab + tr("INFO_CLIPPING");
5185 app->infoPanel()->addLabel(lab, gb);
5188 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5189 PyGILState_STATE gstate = PyGILState_Ensure();
5190 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5191 if ( !pluginsmanager ) {
5195 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5200 PyGILState_Release(gstate);
5201 // end of SMESH plugins loading
5203 // Reset actions accelerator keys
5204 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5206 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5207 GetSMESHGen()->UpdateStudy();
5209 // get all view currently opened in the study and connect their signals to
5210 // the corresponding slots of the class.
5211 SUIT_Desktop* aDesk = study->application()->desktop();
5213 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5214 SUIT_ViewWindow* wnd;
5215 foreach ( wnd, wndList )
5219 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5220 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5226 Py_XDECREF(pluginsmanager);
5230 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5232 setMenuShown( false );
5233 setToolShown( false );
5235 EmitSignalCloseAllDialogs();
5237 // Unset actions accelerator keys
5238 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5240 return SalomeApp_Module::deactivateModule( study );
5243 void SMESHGUI::studyClosed( SUIT_Study* s )
5247 SMESH::RemoveVisuData();
5248 SalomeApp_Module::studyClosed( s );
5251 void SMESHGUI::OnGUIEvent()
5253 const QObject* obj = sender();
5254 if ( !obj || !obj->inherits( "QAction" ) )
5256 int id = actionId((QAction*)obj);
5261 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5263 if ( CORBA::is_nil( myComponentSMESH ) )
5265 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5266 return aGUI.myComponentSMESH;
5268 return myComponentSMESH;
5271 QString SMESHGUI::engineIOR() const
5273 CORBA::ORB_var anORB = getApp()->orb();
5274 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5275 return QString( anIOR.in() );
5278 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5280 SalomeApp_Module::contextMenuPopup( client, menu, title );
5282 selectionMgr()->selectedObjects( lst );
5283 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5284 Handle(SALOME_InteractiveObject) io = lst.First();
5285 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5286 _PTR(Study) study = appStudy->studyDS();
5287 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5289 QString aName = SMESH::fromUtf8( obj->GetName());
5290 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5291 aName.remove(( aName.length() - 1 ), 1 );
5297 LightApp_Selection* SMESHGUI::createSelection() const
5299 return new SMESHGUI_Selection();
5302 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5304 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5305 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5306 aMap.insert( SalomeApp_Application::WT_InfoPanel, Qt::RightDockWidgetArea);
5307 #ifndef DISABLE_PYCONSOLE
5308 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5312 void SMESHGUI::viewManagers( QStringList& list ) const
5314 list.append( SVTK_Viewer::Type() );
5317 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5319 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5320 SMESH::UpdateSelectionProp( this );
5322 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5323 for(int i = 0; i < aViews.count() ; i++){
5324 SUIT_ViewWindow *sf = aViews[i];
5327 EmitSignalActivatedViewManager();
5331 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5333 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5334 myClippingPlaneInfoMap.erase( theViewManager );
5337 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5339 theActor->AddObserver( SMESH::DeleteActorEvent,
5340 myEventCallbackCommand.GetPointer(),
5344 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5345 unsigned long theEvent,
5346 void* theClientData,
5347 void* /*theCallData*/ )
5349 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5350 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5351 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5352 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5353 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5354 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5355 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5356 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5357 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5358 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5359 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5360 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5361 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5362 if( anActor == *anIter3 ) {
5363 anActorList.erase( anIter3 );
5374 void SMESHGUI::createPreferences()
5376 // General tab ------------------------------------------------------------------------
5377 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5379 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5380 setPreferenceProperty( autoUpdate, "columns", 2 );
5381 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5382 setPreferenceProperty( lim, "min", 0 );
5383 setPreferenceProperty( lim, "max", 100000000 );
5384 setPreferenceProperty( lim, "step", 1000 );
5385 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5386 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5388 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5389 setPreferenceProperty( dispgroup, "columns", 2 );
5391 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5393 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5395 modes.append( tr("MEN_WIRE") );
5396 modes.append( tr("MEN_SHADE") );
5397 modes.append( tr("MEN_NODES") );
5398 modes.append( tr("MEN_SHRINK") );
5399 QList<QVariant> indices;
5400 indices.append( 0 );
5401 indices.append( 1 );
5402 indices.append( 2 );
5403 indices.append( 3 );
5404 setPreferenceProperty( dispmode, "strings", modes );
5405 setPreferenceProperty( dispmode, "indexes", indices );
5407 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5408 setPreferenceProperty( arcgroup, "columns", 2 );
5409 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5410 QStringList quadraticModes;
5411 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5412 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5414 indices.append( 0 );
5415 indices.append( 1 );
5416 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5417 setPreferenceProperty( quadraticmode, "indexes", indices );
5419 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5420 "SMESH", "max_angle" );
5421 setPreferenceProperty( maxAngle, "min", 1 );
5422 setPreferenceProperty( maxAngle, "max", 90 );
5424 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5425 setPreferenceProperty( qaGroup, "columns", 2 );
5426 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5427 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5428 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5429 setPreferenceProperty( prec, "min", 0 );
5430 setPreferenceProperty( prec, "max", 100 );
5431 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5432 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5433 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5434 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5435 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5438 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5439 setPreferenceProperty( cinc, "min", 0 );
5440 setPreferenceProperty( cinc, "max", 5 );
5443 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5444 setPreferenceProperty( exportgroup, "columns", 2 );
5445 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5446 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5447 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5448 setPreferenceProperty( zTol, "precision", 10 );
5449 setPreferenceProperty( zTol, "min", 0.0000000001 );
5450 setPreferenceProperty( zTol, "max", 1000000.0 );
5451 setPreferenceProperty( zTol, "step", 1. );
5452 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5454 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5455 setPreferenceProperty( computeGroup, "columns", 2 );
5456 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5458 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5459 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5460 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5462 indices.append( 0 );
5463 indices.append( 1 );
5464 indices.append( 2 );
5465 setPreferenceProperty( notifyMode, "strings", modes );
5466 setPreferenceProperty( notifyMode, "indexes", indices );
5468 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5469 setPreferenceProperty( infoGroup, "columns", 2 );
5470 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5472 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5473 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5475 indices.append( 0 );
5476 indices.append( 1 );
5477 setPreferenceProperty( elemInfo, "strings", modes );
5478 setPreferenceProperty( elemInfo, "indexes", indices );
5479 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5480 setPreferenceProperty( nodesLim, "min", 0 );
5481 setPreferenceProperty( nodesLim, "max", 10000000 );
5482 setPreferenceProperty( nodesLim, "step", 10000 );
5483 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5484 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5485 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5486 setPreferenceProperty( ctrlLim, "min", 0 );
5487 setPreferenceProperty( ctrlLim, "max", 10000000 );
5488 setPreferenceProperty( ctrlLim, "step", 1000 );
5489 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5490 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5491 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5492 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5493 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5495 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5496 setPreferenceProperty( segGroup, "columns", 2 );
5497 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5498 "SMESH", "segmentation" );
5499 setPreferenceProperty( segLen, "min", 1 );
5500 setPreferenceProperty( segLen, "max", 10000000 );
5501 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5502 "SMESH", "nb_segments_per_edge" );
5503 setPreferenceProperty( nbSeg, "min", 1 );
5504 setPreferenceProperty( nbSeg, "max", 10000000 );
5505 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5507 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5508 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5509 "SMESH", "forget_mesh_on_hyp_modif" );
5512 // Quantities with individual precision settings
5513 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5514 setPreferenceProperty( precGroup, "columns", 2 );
5516 const int nbQuantities = 6;
5517 int precs[nbQuantities], ii = 0;
5518 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5519 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5520 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5521 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5522 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5523 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5524 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5525 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5526 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5527 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5528 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5529 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5531 // Set property for precision value for spinboxes
5532 for ( ii = 0; ii < nbQuantities; ii++ ){
5533 setPreferenceProperty( precs[ii], "min", -14 );
5534 setPreferenceProperty( precs[ii], "max", 14 );
5535 setPreferenceProperty( precs[ii], "precision", 2 );
5538 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5539 setPreferenceProperty( previewGroup, "columns", 2 );
5540 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5541 setPreferenceProperty( chunkSize, "min", 1 );
5542 setPreferenceProperty( chunkSize, "max", 1000 );
5543 setPreferenceProperty( chunkSize, "step", 50 );
5545 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5546 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5548 // Mesh tab ------------------------------------------------------------------------
5549 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5550 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5551 setPreferenceProperty( nodeGroup, "columns", 3 );
5553 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5555 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5557 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5558 QList<QVariant> aMarkerTypeIndicesList;
5559 QList<QVariant> aMarkerTypeIconsList;
5560 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5561 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5562 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5563 aMarkerTypeIndicesList << i;
5564 aMarkerTypeIconsList << pixmap;
5566 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5567 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5569 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5571 QList<QVariant> aMarkerScaleIndicesList;
5572 QStringList aMarkerScaleValuesList;
5573 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5574 aMarkerScaleIndicesList << i;
5575 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5576 aMarkerScaleValuesList << QString::number( i );
5578 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5579 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5581 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5582 //setPreferenceProperty( elemGroup, "columns", 2 );
5584 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5585 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5586 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5587 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5588 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5589 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5590 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5591 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5592 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5595 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5596 setPreferenceProperty( grpGroup, "columns", 2 );
5598 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5599 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5601 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5602 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5603 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5604 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5605 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5606 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5607 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5608 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5609 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5610 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5611 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5612 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5613 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5614 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5616 setPreferenceProperty( size0d, "min", 1 );
5617 setPreferenceProperty( size0d, "max", 10 );
5619 // setPreferenceProperty( ballSize, "min", 1 );
5620 // setPreferenceProperty( ballSize, "max", 10 );
5622 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5623 setPreferenceProperty( ballDiameter, "max", 1e9 );
5624 setPreferenceProperty( ballDiameter, "step", 0.1 );
5626 setPreferenceProperty( ballScale, "min", 1e-2 );
5627 setPreferenceProperty( ballScale, "max", 1e7 );
5628 setPreferenceProperty( ballScale, "step", 0.5 );
5630 setPreferenceProperty( elemW, "min", 1 );
5631 setPreferenceProperty( elemW, "max", 5 );
5633 setPreferenceProperty( outW, "min", 1 );
5634 setPreferenceProperty( outW, "max", 5 );
5636 setPreferenceProperty( shrink, "min", 0 );
5637 setPreferenceProperty( shrink, "max", 100 );
5639 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5640 setPreferenceProperty( numGroup, "columns", 2 );
5642 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5643 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5645 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5646 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5648 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5649 setPreferenceProperty( orientGroup, "columns", 1 );
5651 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5652 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5654 setPreferenceProperty( orientScale, "min", 0.05 );
5655 setPreferenceProperty( orientScale, "max", 0.5 );
5656 setPreferenceProperty( orientScale, "step", 0.05 );
5658 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5660 // Selection tab ------------------------------------------------------------------------
5661 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5663 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5664 setPreferenceProperty( selGroup, "columns", 2 );
5666 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5667 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5669 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5670 setPreferenceProperty( preGroup, "columns", 2 );
5672 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5674 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5675 setPreferenceProperty( precSelGroup, "columns", 2 );
5677 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5678 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5679 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5681 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5682 setPreferenceProperty( sinc, "min", 0 );
5683 setPreferenceProperty( sinc, "max", 5 );
5685 // Scalar Bar tab ------------------------------------------------------------------------
5686 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5687 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5688 setPreferenceProperty( fontGr, "columns", 2 );
5690 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5691 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5693 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5694 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5696 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5697 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5699 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5700 setPreferenceProperty( numcol, "min", 2 );
5701 setPreferenceProperty( numcol, "max", 256 );
5703 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5704 setPreferenceProperty( numlab, "min", 2 );
5705 setPreferenceProperty( numlab, "max", 65 );
5707 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5708 setPreferenceProperty( orientGr, "columns", 2 );
5709 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5710 QStringList orients;
5711 orients.append( tr( "SMESH_VERTICAL" ) );
5712 orients.append( tr( "SMESH_HORIZONTAL" ) );
5713 indices.clear(); indices.append( 0 ); indices.append( 1 );
5714 setPreferenceProperty( orient, "strings", orients );
5715 setPreferenceProperty( orient, "indexes", indices );
5717 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5718 setPreferenceProperty( posVSizeGr, "columns", 2 );
5719 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5720 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5721 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5722 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5723 setPreferenceProperty( xv, "step", 0.1 );
5724 setPreferenceProperty( xv, "min", 0.0 );
5725 setPreferenceProperty( xv, "max", 1.0 );
5726 setPreferenceProperty( yv, "step", 0.1 );
5727 setPreferenceProperty( yv, "min", 0.0 );
5728 setPreferenceProperty( yv, "max", 1.0 );
5729 setPreferenceProperty( wv, "step", 0.1 );
5730 setPreferenceProperty( wv, "min", 0.0 );
5731 setPreferenceProperty( wv, "max", 1.0 );
5732 setPreferenceProperty( hv, "min", 0.0 );
5733 setPreferenceProperty( hv, "max", 1.0 );
5734 setPreferenceProperty( hv, "step", 0.1 );
5736 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5737 setPreferenceProperty( posHSizeGr, "columns", 2 );
5738 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5739 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5740 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5741 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5742 setPreferenceProperty( xv, "min", 0.0 );
5743 setPreferenceProperty( xv, "max", 1.0 );
5744 setPreferenceProperty( xv, "step", 0.1 );
5745 setPreferenceProperty( xh, "min", 0.0 );
5746 setPreferenceProperty( xh, "max", 1.0 );
5747 setPreferenceProperty( xh, "step", 0.1 );
5748 setPreferenceProperty( yh, "min", 0.0 );
5749 setPreferenceProperty( yh, "max", 1.0 );
5750 setPreferenceProperty( yh, "step", 0.1 );
5751 setPreferenceProperty( wh, "min", 0.0 );
5752 setPreferenceProperty( wh, "max", 1.0 );
5753 setPreferenceProperty( wh, "step", 0.1 );
5754 setPreferenceProperty( hh, "min", 0.0 );
5755 setPreferenceProperty( hh, "max", 1.0 );
5756 setPreferenceProperty( hh, "step", 0.1 );
5758 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5759 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5760 setPreferenceProperty( distributionGr, "columns", 3 );
5762 types.append( tr( "SMESH_MONOCOLOR" ) );
5763 types.append( tr( "SMESH_MULTICOLOR" ) );
5764 indices.clear(); indices.append( 0 ); indices.append( 1 );
5765 setPreferenceProperty( coloringType, "strings", types );
5766 setPreferenceProperty( coloringType, "indexes", indices );
5767 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5769 // Adaptation - begin
5770 // Adaptation tab ------------------------------------------------------------------------
5771 int adaptTab = addPreference( tr( "ADAPT_PREF_TAB_GENERAL" ) );
5774 bloc = addPreference( tr( "ADAPT_PREF_MG_ADAPT" ), adaptTab );
5775 setPreferenceProperty( bloc, "columns", 1 );
5776 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_FILE_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_file_mesh_out" );
5777 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_publish_mesh_out" );
5778 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_size_map" );
5779 QStringList aListOfSizeMap;
5780 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_LOCAL" );
5781 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_BACKGROUND" );
5782 aListOfSizeMap << tr( "ADAPT_PREF_NONE" );;
5783 setPreferenceProperty( pref, "strings", aListOfSizeMap );
5784 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_time_step" );
5785 QStringList aListOfTimeStep;
5786 aListOfTimeStep << tr( "ADAPT_PREF_NONE" );
5787 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_LAST" );
5788 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_C" );;
5789 setPreferenceProperty( pref, "strings", aListOfTimeStep );
5794 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5796 if ( sect=="SMESH" ) {
5797 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5798 float aTol = 1.00000009999999;
5799 std::string aWarning;
5800 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5802 if ( name == "selection_object_color" ||
5803 name == "selection_element_color" ||
5804 name == "highlight_color" ||
5805 name == "selection_precision_node" ||
5806 name == "selection_precision_element" ||
5807 name == "selection_precision_object" ||
5808 name == "selection_increment")
5810 SMESH::UpdateSelectionProp( this );
5812 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5814 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5815 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5816 if ( sbX1+sbW > aTol ) {
5817 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5820 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5821 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5824 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5826 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5827 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5828 if ( sbY1 + sbH > aTol ) {
5829 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5830 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5831 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5834 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5836 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5837 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5838 if ( sbX1 + sbW > aTol ) {
5839 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5842 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5843 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5846 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5848 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5849 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5850 if ( sbY1 + sbH > aTol ) {
5851 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5854 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5855 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5858 else if ( name == "segmentation" )
5860 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5861 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5863 else if ( name == "nb_segments_per_edge" )
5865 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5866 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5868 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5870 QString val = aResourceMgr->stringValue( "SMESH", name );
5871 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5873 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5875 SMESH::UpdateFontProp( this );
5877 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5879 SMESH::UpdateFontProp( this );
5882 if ( aWarning.size() != 0 ) {
5883 aWarning += "The default values are applied instead.";
5884 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5885 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5886 QObject::tr(aWarning.c_str()));
5891 //================================================================================
5893 * \brief Update something in accordance with update flags
5894 * \param theFlags - update flags
5896 * Update viewer or/and object browser etc. in accordance with update flags ( see
5897 * LightApp_UpdateFlags enumeration ).
5899 //================================================================================
5900 void SMESHGUI::update( const int flags )
5902 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5903 SMESH::UpdateView();
5905 SalomeApp_Module::update( flags );
5908 //================================================================================
5910 * \brief Set default selection mode
5912 * SLOT called when operation committed. Sets default selection mode
5914 //================================================================================
5915 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5917 SVTK_ViewWindow* vtkWnd =
5918 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5920 vtkWnd->SetSelectionMode( ActorSelection );
5923 //================================================================================
5925 * \brief Set default selection mode
5927 * SLOT called when operation aborted. Sets default selection mode
5929 //================================================================================
5930 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5932 SVTK_ViewWindow* vtkWnd =
5933 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5935 vtkWnd->SetSelectionMode( ActorSelection );
5938 //================================================================================
5940 * \brief Creates operation with given identifier
5941 * \param id - identifier of operation to be started
5942 * \return Pointer on created operation or NULL if operation is not created
5944 * Virtual method redefined from the base class creates operation with given id.
5945 * It is called called automatically from startOperation method of base class.
5947 //================================================================================
5948 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5950 LightApp_Operation* op = 0;
5951 // to do : create operation here
5954 case SMESHOp::OpSplitBiQuadratic:
5955 op = new SMESHGUI_SplitBiQuadOp();
5957 case SMESHOp::OpConvertMeshToQuadratic:
5958 op = new SMESHGUI_ConvToQuadOp();
5960 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5961 op = new SMESHGUI_Make2DFrom3DOp();
5963 case SMESHOp::OpReorientFaces:
5964 op = new SMESHGUI_ReorientFacesOp();
5966 case SMESHOp::OpCreateMesh:
5967 op = new SMESHGUI_MeshOp( true, true );
5969 case SMESHOp::OpCreateSubMesh:
5970 op = new SMESHGUI_MeshOp( true, false );
5972 case SMESHOp::OpEditMeshOrSubMesh:
5973 case SMESHOp::OpEditMesh:
5974 case SMESHOp::OpEditSubMesh:
5975 op = new SMESHGUI_MeshOp( false );
5977 case SMESHOp::OpCompute:
5978 case SMESHOp::OpComputeSubMesh:
5979 op = new SMESHGUI_ComputeOp();
5981 case SMESHOp::OpShowErrors:
5982 op = new SMESHGUI_ShowErrorsOp();
5984 case SMESHOp::OpPreCompute:
5985 op = new SMESHGUI_PrecomputeOp();
5987 case SMESHOp::OpEvaluate:
5988 op = new SMESHGUI_EvaluateOp();
5990 case SMESHOp::OpMeshOrder:
5991 op = new SMESHGUI_MeshOrderOp();
5993 case SMESHOp::OpCreateGeometryGroup:
5994 op = new SMESHGUI_GroupOnShapeOp();
5996 case SMESHOp::OpFindElementByPoint:
5997 op = new SMESHGUI_FindElemByPointOp();
5999 case SMESHOp::OpMoveNode: // Make mesh pass through point
6000 op = new SMESHGUI_MakeNodeAtPointOp();
6002 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
6003 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
6005 // Adaptation - begin
6006 case SMESHOp::OpMGAdapt:
6014 op = SalomeApp_Module::createOperation( id );
6018 //================================================================================
6020 * \brief Stops current operations and starts a given one
6021 * \param id - The id of the operation to start
6023 //================================================================================
6025 void SMESHGUI::switchToOperation(int id)
6027 activeStudy()->abortAllOperations();
6028 startOperation( id );
6031 LightApp_Displayer* SMESHGUI::displayer()
6034 myDisplayer = new SMESHGUI_Displayer( getApp() );
6038 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
6041 int aTolerance = 64;
6042 int anIterations = 0;
6048 if( anIterations % aPeriod == 0 )
6051 if( aTolerance < 1 )
6055 aHue = (int)( 360.0 * rand() / RAND_MAX );
6058 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
6059 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
6060 for( ; it != itEnd; ++it )
6062 SALOMEDS::Color anAutoColor = *it;
6063 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6066 aQColor.getHsv( &h, &s, &v );
6067 if( abs( h - aHue ) < aTolerance )
6079 aColor.setHsv( aHue, 255, 255 );
6081 SALOMEDS::Color aSColor;
6082 aSColor.R = aColor.redF();
6083 aSColor.G = aColor.greenF();
6084 aSColor.B = aColor.blueF();
6089 const char* gSeparator = "_"; // character used to separate parameter names
6090 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6091 const char* gPathSep = "|"; // character used to separate paths
6094 * \brief Store visual parameters
6096 * This method is called just before the study document is saved.
6097 * Store visual parameters in AttributeParameter attribute(s)
6099 void SMESHGUI::storeVisualParameters (int savePoint)
6102 Kernel_Utils::Localizer loc;
6104 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6105 if (!appStudy || !appStudy->studyDS())
6107 _PTR(Study) studyDS = appStudy->studyDS();
6109 // componentName is used for encoding of entries when storing them in IParameters
6110 std::string componentName = myComponentSMESH->ComponentDataType();
6111 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6112 //if (!aSComponent) return;
6115 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6116 componentName.c_str(),
6118 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6120 // store custom markers
6121 if( !myMarkerMap.empty() )
6123 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6124 for( ; anIter != myMarkerMap.end(); anIter++ )
6126 int anId = anIter->first;
6127 VTK::MarkerData aMarkerData = anIter->second;
6128 std::string aMarkerFileName = aMarkerData.first;
6129 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6130 if( aMarkerTexture.size() < 3 )
6131 continue; // should contain at least width, height and the first value
6133 QString aPropertyName( "texture" );
6134 aPropertyName += gSeparator;
6135 aPropertyName += QString::number( anId );
6137 QString aPropertyValue = aMarkerFileName.c_str();
6138 aPropertyValue += gPathSep;
6140 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6141 ushort aWidth = *aTextureIter++;
6142 ushort aHeight = *aTextureIter++;
6143 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6144 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6145 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6146 aPropertyValue += QString::number( *aTextureIter );
6148 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6152 // viewers counters are used for storing view_numbers in IParameters
6155 // main cycle to store parameters of displayed objects
6156 QList<SUIT_ViewManager*> lst;
6157 QList<SUIT_ViewManager*>::Iterator it;
6158 getApp()->viewManagers(lst);
6159 for (it = lst.begin(); it != lst.end(); it++)
6161 SUIT_ViewManager* vman = *it;
6162 QString vType = vman->getType();
6164 // saving VTK actors properties
6165 if (vType == SVTK_Viewer::Type())
6167 // store the clipping planes attached to the view manager
6168 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6169 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6170 if( anIter != myClippingPlaneInfoMap.end() )
6171 aClippingPlaneInfoList = anIter->second;
6173 if( !aClippingPlaneInfoList.empty() ) {
6174 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6175 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6177 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6178 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6180 QString aPropertyName( "ClippingPlane" );
6181 aPropertyName += gSeparator;
6182 aPropertyName += QString::number( vtkViewers );
6183 aPropertyName += gSeparator;
6184 aPropertyName += QString::number( anId );
6186 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6187 aPropertyValue += gDigitsSep;
6188 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6189 aPropertyValue += gDigitsSep;
6190 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6191 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6192 aPropertyValue += gDigitsSep;
6193 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6194 aPropertyValue += gDigitsSep;
6195 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6196 aPropertyValue += gDigitsSep;
6197 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6198 aPropertyValue += gDigitsSep;
6199 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6200 aPropertyValue += gDigitsSep;
6201 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6202 aPropertyValue += gDigitsSep;
6203 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6205 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6206 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6207 aPropertyValue += gDigitsSep;
6208 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6209 aPropertyValue += gDigitsSep;
6210 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6211 aPropertyValue += gDigitsSep;
6212 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6215 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6219 QVector<SUIT_ViewWindow*> views = vman->getViews();
6220 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6222 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6224 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6225 vtkActorCollection* allActors = aCopy.GetActors();
6226 allActors->InitTraversal();
6227 while (vtkActor* actor = allActors->GetNextActor())
6229 if (actor->GetVisibility()) // store only visible actors
6231 SMESH_Actor* aSmeshActor = 0;
6232 if (actor->IsA("SMESH_Actor"))
6233 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6234 if (aSmeshActor && aSmeshActor->hasIO())
6236 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6239 // entry is "encoded" = it does NOT contain component address,
6240 // since it is a subject to change on next component loading
6241 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6243 std::string param, vtkParam = vType.toLatin1().data();
6244 vtkParam += gSeparator;
6245 vtkParam += QString::number(vtkViewers).toLatin1().data();
6246 vtkParam += gSeparator;
6249 param = vtkParam + "Visibility";
6250 ip->setParameter(entry, param, "On");
6253 param = vtkParam + "Representation";
6254 ip->setParameter(entry, param, QString::number
6255 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6258 param = vtkParam + "IsShrunk";
6259 ip->setParameter(entry, param, QString::number
6260 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6262 // Displayed entities
6263 unsigned int aMode = aSmeshActor->GetEntityMode();
6264 bool isE = aMode & SMESH_Actor::eEdges;
6265 bool isF = aMode & SMESH_Actor::eFaces;
6266 bool isV = aMode & SMESH_Actor::eVolumes;
6267 bool is0d = aMode & SMESH_Actor::e0DElements;
6268 bool isB = aMode & SMESH_Actor::eBallElem;
6270 QString modeStr ("e");
6271 modeStr += gDigitsSep; modeStr += QString::number(isE);
6272 modeStr += gDigitsSep; modeStr += "f";
6273 modeStr += gDigitsSep; modeStr += QString::number(isF);
6274 modeStr += gDigitsSep; modeStr += "v";
6275 modeStr += gDigitsSep; modeStr += QString::number(isV);
6276 modeStr += gDigitsSep; modeStr += "0d";
6277 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6278 modeStr += gDigitsSep; modeStr += "b";
6279 modeStr += gDigitsSep; modeStr += QString::number(isB);
6281 param = vtkParam + "Entities";
6282 ip->setParameter(entry, param, modeStr.toLatin1().data());
6288 aSmeshActor->GetSufaceColor(r, g, b, delta);
6289 QStringList colorStr;
6290 colorStr << "surface";
6291 colorStr << QString::number(r);
6292 colorStr << QString::number(g);
6293 colorStr << QString::number(b);
6295 colorStr << "backsurface";
6296 colorStr << QString::number(delta);
6298 aSmeshActor->GetVolumeColor(r, g, b, delta);
6299 colorStr << "volume";
6300 colorStr << QString::number(r);
6301 colorStr << QString::number(g);
6302 colorStr << QString::number(b);
6303 colorStr << QString::number(delta);
6305 aSmeshActor->GetEdgeColor(r, g, b);
6307 colorStr << QString::number(r);
6308 colorStr << QString::number(g);
6309 colorStr << QString::number(b);
6311 aSmeshActor->GetNodeColor(r, g, b);
6313 colorStr << QString::number(r);
6314 colorStr << QString::number(g);
6315 colorStr << QString::number(b);
6317 aSmeshActor->GetOutlineColor(r, g, b);
6318 colorStr << "outline";
6319 colorStr << QString::number(r);
6320 colorStr << QString::number(g);
6321 colorStr << QString::number(b);
6323 aSmeshActor->Get0DColor(r, g, b);
6324 colorStr << "elem0d";
6325 colorStr << QString::number(r);
6326 colorStr << QString::number(g);
6327 colorStr << QString::number(b);
6329 aSmeshActor->GetBallColor(r, g, b);
6331 colorStr << QString::number(r);
6332 colorStr << QString::number(g);
6333 colorStr << QString::number(b);
6335 aSmeshActor->GetFacesOrientationColor(r, g, b);
6336 colorStr << "orientation";
6337 colorStr << QString::number(r);
6338 colorStr << QString::number(g);
6339 colorStr << QString::number(b);
6341 param = vtkParam + "Colors";
6342 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6345 QStringList sizeStr;
6347 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6348 sizeStr << "outline";
6349 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6350 sizeStr << "elem0d";
6351 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6353 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6354 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6355 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6356 sizeStr << "shrink";
6357 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6358 sizeStr << "orientation";
6359 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6360 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6362 param = vtkParam + "Sizes";
6363 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6368 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6369 if( aMarkerType == VTK::MT_USER ) {
6370 markerStr += "custom";
6371 markerStr += gDigitsSep;
6372 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6376 markerStr += gDigitsSep;
6377 markerStr += QString::number( (int)aMarkerType );
6378 markerStr += gDigitsSep;
6379 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6382 param = vtkParam + "PointMarker";
6383 ip->setParameter(entry, param, markerStr.toLatin1().data());
6386 param = vtkParam + "Opacity";
6387 ip->setParameter(entry, param,
6388 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6391 param = vtkParam + "ClippingPlane";
6393 if( !aClippingPlaneInfoList.empty() ) {
6394 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6395 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6397 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6398 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6399 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6400 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6401 if( aSmeshActor == *anIter2 ) {
6402 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6403 QString::number( anId ).toLatin1().constData() );
6410 ip->setParameter( entry, param, "Off" );
6411 } // if (io->hasEntry())
6412 } // SMESH_Actor && hasIO
6414 } // while.. actors traversal
6418 } // if (SVTK view model)
6419 } // for (viewManagers)
6422 // data structures for clipping planes processing
6426 bool isOpenGLClipping;
6427 vtkIdType RelativeOrientation;
6430 int AbsoluteOrientation;
6431 double X, Y, Z, Dx, Dy, Dz;
6433 typedef std::list<TPlaneData> TPlaneDataList;
6434 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6436 typedef std::list<vtkActor*> TActorList;
6439 TActorList ActorList;
6440 SUIT_ViewManager* ViewManager;
6442 typedef std::list<TPlaneInfo> TPlaneInfoList;
6443 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6446 * \brief Restore visual parameters
6448 * This method is called after the study document is opened.
6449 * Restore visual parameters from AttributeParameter attribute(s)
6451 void SMESHGUI::restoreVisualParameters (int savePoint)
6454 Kernel_Utils::Localizer loc;
6456 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6457 if (!appStudy || !appStudy->studyDS())
6459 _PTR(Study) studyDS = appStudy->studyDS();
6461 // componentName is used for encoding of entries when storing them in IParameters
6462 std::string componentName = myComponentSMESH->ComponentDataType();
6465 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6466 componentName.c_str(),
6468 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6470 // restore custom markers and map of clipping planes
6471 TPlaneDataMap aPlaneDataMap;
6473 std::vector<std::string> properties = ip->getProperties();
6474 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6476 std::string property = *propIt;
6477 QString aPropertyName( property.c_str() );
6478 QString aPropertyValue( ip->getProperty( property ).c_str() );
6480 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6481 if( aPropertyNameList.isEmpty() )
6484 QString aPropertyType = aPropertyNameList[0];
6485 if( aPropertyType == "texture" )
6487 if( aPropertyNameList.size() != 2 )
6491 int anId = aPropertyNameList[1].toInt( &ok );
6492 if( !ok || anId < 1 )
6495 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6496 if( aPropertyValueList.size() != 2 )
6499 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6500 QString aMarkerTextureString = aPropertyValueList[1];
6501 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6502 if( aMarkerTextureStringList.size() != 3 )
6506 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6511 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6515 VTK::MarkerTexture aMarkerTexture;
6516 aMarkerTexture.push_back( aWidth );
6517 aMarkerTexture.push_back( aHeight );
6519 QString aMarkerTextureData = aMarkerTextureStringList[2];
6520 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6522 QChar aChar = aMarkerTextureData.at( i );
6523 if( aChar.isDigit() )
6524 aMarkerTexture.push_back( aChar.digitValue() );
6527 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6529 else if( aPropertyType == "ClippingPlane" )
6531 if( aPropertyNameList.size() != 3 )
6535 int aViewId = aPropertyNameList[1].toInt( &ok );
6536 if( !ok || aViewId < 0 )
6540 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6541 if( !ok || aClippingPlaneId < 0 )
6544 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6545 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6548 TPlaneData aPlaneData;
6549 aPlaneData.AbsoluteOrientation = false;
6550 aPlaneData.RelativeOrientation = 0;
6551 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6552 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6553 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6555 aPlaneData.Id = aClippingPlaneId;
6558 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6563 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6567 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6570 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6575 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6580 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6585 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6590 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6595 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6600 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6604 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6606 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6611 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6616 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6621 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6626 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6627 aPlaneDataList.push_back( aPlaneData );
6631 TPlaneInfoMap aPlaneInfoMap;
6633 std::vector<std::string> entries = ip->getEntries();
6635 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6637 // entry is a normal entry - it should be "decoded" (setting base address of component)
6638 QString entry (ip->decodeEntry(*entIt).c_str());
6640 // Check that the entry corresponds to a real object in the Study
6641 // as the object may be deleted or modified after the visual state is saved.
6642 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6643 if (!so) continue; //Skip the not existent entry
6645 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6646 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6648 std::vector<std::string>::iterator namesIt = paramNames.begin();
6649 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6651 // actors are stored in a map after displaying of them for
6652 // quicker access in the future: map < viewID to actor >
6653 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6655 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6657 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6658 // '_' is used as separator and should not be used in viewer type or parameter names.
6659 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6660 if (lst.size() != 3)
6663 QString viewerTypStr = lst[0];
6664 QString viewIndexStr = lst[1];
6665 QString paramNameStr = lst[2];
6668 int viewIndex = viewIndexStr.toUInt(&ok);
6669 if (!ok) // bad conversion of view index to integer
6673 if (viewerTypStr == SVTK_Viewer::Type())
6675 SMESH_Actor* aSmeshActor = 0;
6676 if (vtkActors.IsBound(viewIndex))
6677 aSmeshActor = vtkActors.Find(viewIndex);
6679 QList<SUIT_ViewManager*> lst;
6680 getApp()->viewManagers(viewerTypStr, lst);
6682 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6683 SUIT_ViewManager* vman = NULL;
6684 if (viewIndex >= 0 && viewIndex < lst.count())
6685 vman = lst.at(viewIndex);
6687 if (paramNameStr == "Visibility")
6689 if (!aSmeshActor && displayer() && vman)
6691 SUIT_ViewModel* vmodel = vman->getViewModel();
6692 // SVTK view model can be casted to SALOME_View
6693 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6695 // store displayed actor in a temporary map for quicker
6696 // access later when restoring other parameters
6697 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6698 vtkRenderer* Renderer = vtkView->getRenderer();
6699 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6700 vtkActorCollection* theActors = aCopy.GetActors();
6701 theActors->InitTraversal();
6702 bool isFound = false;
6703 vtkActor *ac = theActors->GetNextActor();
6704 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6705 if (ac->IsA("SMESH_Actor")) {
6706 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6707 if (aGeomAc->hasIO()) {
6708 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6709 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6711 vtkActors.Bind(viewIndex, aGeomAc);
6717 } // if (paramNameStr == "Visibility")
6720 // the rest properties "work" with SMESH_Actor
6723 QString val ((*valuesIt).c_str());
6726 if (paramNameStr == "Representation") {
6727 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6730 else if (paramNameStr == "IsShrunk") {
6732 if (!aSmeshActor->IsShrunk())
6733 aSmeshActor->SetShrink();
6736 if (aSmeshActor->IsShrunk())
6737 aSmeshActor->UnShrink();
6740 // Displayed entities
6741 else if (paramNameStr == "Entities") {
6742 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6743 int aEntityMode = SMESH_Actor::eAllEntity;
6744 for ( int i = 0; i < mode.count(); i+=2 ) {
6745 if ( i < mode.count()-1 ) {
6746 QString type = mode[i];
6747 bool val = mode[i+1].toInt();
6748 if ( type == "e" && !val )
6749 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6750 else if ( type == "f" && !val )
6751 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6752 else if ( type == "v" && !val )
6753 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6754 else if ( type == "0d" && !val )
6755 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6756 else if ( type == "b" && !val )
6757 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6760 aSmeshActor->SetEntityMode( aEntityMode );
6763 else if (paramNameStr == "Colors") {
6764 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6771 QColor outlineColor;
6772 QColor orientationColor;
6778 // below lines are required to get default values for delta coefficients
6779 // of backface color for faces and color of reversed volumes
6780 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6781 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6782 for ( int i = 0; i < colors.count(); i++ ) {
6783 QString type = colors[i];
6784 if ( type == "surface" ) {
6785 // face color is set by 3 values r:g:b, where
6786 // - r,g,b - is rgb color components
6787 if ( i+1 >= colors.count() ) break; // format error
6788 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6789 if ( i+2 >= colors.count() ) break; // format error
6790 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6791 if ( i+3 >= colors.count() ) break; // format error
6792 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6793 faceColor.setRgbF( r, g, b );
6796 else if ( type == "backsurface" ) {
6797 // backface color can be defined in several ways
6798 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6799 // - in latest versions, it is set as delta coefficient
6800 bool rgbOk = false, deltaOk;
6801 if ( i+1 >= colors.count() ) break; // format error
6802 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6803 int delta = colors[i+1].toInt( &deltaOk );
6805 if ( i+1 < colors.count() ) // index is shifted to 1
6806 g = colors[i+1].toDouble( &rgbOk );
6807 if ( rgbOk ) i++; // shift index
6808 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6809 b = colors[i+1].toDouble( &rgbOk );
6811 // - as currently there's no way to set directly backsurface color as it was before,
6812 // we ignore old dump where r,g,b triple was set
6813 // - also we check that delta parameter is set properly
6814 if ( !rgbOk && deltaOk )
6817 else if ( type == "volume" ) {
6818 // volume color is set by 4 values r:g:b:delta, where
6819 // - r,g,b - is a normal volume rgb color components
6820 // - delta - is a reversed volume color delta coefficient
6821 if ( i+1 >= colors.count() ) break; // format error
6822 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6823 if ( i+2 >= colors.count() ) break; // format error
6824 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6825 if ( i+3 >= colors.count() ) break; // format error
6826 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6827 if ( i+4 >= colors.count() ) break; // format error
6828 int delta = colors[i+4].toInt( &bOk );
6829 if ( !bOk ) break; // format error
6830 volumeColor.setRgbF( r, g, b );
6834 else if ( type == "edge" ) {
6835 // edge color is set by 3 values r:g:b, where
6836 // - r,g,b - is rgb color components
6837 if ( i+1 >= colors.count() ) break; // format error
6838 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6839 if ( i+2 >= colors.count() ) break; // format error
6840 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6841 if ( i+3 >= colors.count() ) break; // format error
6842 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6843 edgeColor.setRgbF( r, g, b );
6846 else if ( type == "node" ) {
6847 // node color is set by 3 values r:g:b, where
6848 // - r,g,b - is rgb color components
6849 if ( i+1 >= colors.count() ) break; // format error
6850 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6851 if ( i+2 >= colors.count() ) break; // format error
6852 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6853 if ( i+3 >= colors.count() ) break; // format error
6854 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6855 nodeColor.setRgbF( r, g, b );
6858 else if ( type == "elem0d" ) {
6859 // 0d element color is set by 3 values r:g:b, where
6860 // - r,g,b - is rgb color components
6861 if ( i+1 >= colors.count() ) break; // format error
6862 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6863 if ( i+2 >= colors.count() ) break; // format error
6864 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6865 if ( i+3 >= colors.count() ) break; // format error
6866 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6867 elem0dColor.setRgbF( r, g, b );
6870 else if ( type == "ball" ) {
6871 // ball color is set by 3 values r:g:b, where
6872 // - r,g,b - is rgb color components
6873 if ( i+1 >= colors.count() ) break; // format error
6874 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6875 if ( i+2 >= colors.count() ) break; // format error
6876 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6877 if ( i+3 >= colors.count() ) break; // format error
6878 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6879 ballColor.setRgbF( r, g, b );
6882 else if ( type == "outline" ) {
6883 // outline color is set by 3 values r:g:b, where
6884 // - r,g,b - is rgb color components
6885 if ( i+1 >= colors.count() ) break; // format error
6886 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6887 if ( i+2 >= colors.count() ) break; // format error
6888 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6889 if ( i+3 >= colors.count() ) break; // format error
6890 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6891 outlineColor.setRgbF( r, g, b );
6894 else if ( type == "orientation" ) {
6895 // orientation color is set by 3 values r:g:b, where
6896 // - r,g,b - is rgb color components
6897 if ( i+1 >= colors.count() ) break; // format error
6898 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6899 if ( i+2 >= colors.count() ) break; // format error
6900 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6901 if ( i+3 >= colors.count() ) break; // format error
6902 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6903 orientationColor.setRgbF( r, g, b );
6908 if ( nodeColor.isValid() )
6909 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6911 if ( edgeColor.isValid() )
6912 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6914 if ( faceColor.isValid() )
6915 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6917 if ( volumeColor.isValid() )
6918 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6919 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6920 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6922 if ( elem0dColor.isValid() )
6923 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6925 if ( ballColor.isValid() )
6926 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6928 if ( outlineColor.isValid() )
6929 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6930 // orientation color
6931 if ( orientationColor.isValid() )
6932 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6935 else if (paramNameStr == "Sizes") {
6936 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6939 int outlineWidth = -1;
6940 int elem0dSize = -1;
6941 //int ballSize = -1;
6942 double ballDiameter = -1.0;
6943 double ballScale = -1.0;
6944 double shrinkSize = -1;
6945 double orientationSize = -1;
6946 bool orientation3d = false;
6947 for ( int i = 0; i < sizes.count(); i++ ) {
6948 QString type = sizes[i];
6949 if ( type == "line" ) {
6950 // line (wireframe) width is given as single integer value
6951 if ( i+1 >= sizes.count() ) break; // format error
6952 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6956 if ( type == "outline" ) {
6957 // outline width is given as single integer value
6958 if ( i+1 >= sizes.count() ) break; // format error
6959 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6963 else if ( type == "elem0d" ) {
6964 // 0d element size is given as single integer value
6965 if ( i+1 >= sizes.count() ) break; // format error
6966 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6970 else if ( type == "ball" ) {
6971 // balls are specified by two values: size:scale, where
6972 // - size - is a integer value specifying size
6973 // - scale - is a double value specifying scale factor
6974 if ( i+1 >= sizes.count() ) break; // format error
6975 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6976 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6977 if ( i+2 >= sizes.count() ) break; // format error
6978 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6984 else if ( type == "shrink" ) {
6985 // shrink factor is given as single floating point value
6986 if ( i+1 >= sizes.count() ) break; // format error
6987 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6991 else if ( type == "orientation" ) {
6992 // orientation vectors are specified by two values size:3d, where
6993 // - size - is a floating point value specifying scale factor
6994 // - 3d - is a boolean
6995 if ( i+1 >= sizes.count() ) break; // format error
6996 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6997 if ( i+2 >= sizes.count() ) break; // format error
6998 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6999 orientationSize = v1;
7000 orientation3d = (bool)v2;
7004 // line (wireframe) width
7005 if ( lineWidth > 0 )
7006 aSmeshActor->SetLineWidth( lineWidth );
7008 if ( outlineWidth > 0 )
7009 aSmeshActor->SetOutlineWidth( outlineWidth );
7010 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
7011 aSmeshActor->SetOutlineWidth( lineWidth );
7013 if ( elem0dSize > 0 )
7014 aSmeshActor->Set0DSize( elem0dSize );
7016 /*if ( ballSize > 0 )
7017 aSmeshActor->SetBallSize( ballSize );*/
7019 if ( ballDiameter > 0 )
7020 aSmeshActor->SetBallSize( ballDiameter );
7022 if ( ballScale > 0.0 )
7023 aSmeshActor->SetBallScale( ballScale );
7025 if ( shrinkSize > 0 )
7026 aSmeshActor->SetShrinkFactor( shrinkSize );
7027 // orientation vectors
7028 if ( orientationSize > 0 ) {
7029 aSmeshActor->SetFacesOrientationScale( orientationSize );
7030 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
7034 else if (paramNameStr == "PointMarker") {
7035 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
7036 if( data.count() >= 2 ) {
7038 int aParam1 = data[1].toInt( &ok );
7040 if( data[0] == "std" && data.count() == 3 ) {
7041 int aParam2 = data[2].toInt( &ok );
7042 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
7044 else if( data[0] == "custom" ) {
7045 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
7046 if( markerIt != myMarkerMap.end() ) {
7047 VTK::MarkerData aMarkerData = markerIt->second;
7048 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
7055 else if (paramNameStr == "Opacity") {
7056 aSmeshActor->SetOpacity(val.toFloat());
7059 else if (paramNameStr.startsWith("ClippingPlane")) {
7060 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
7061 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
7062 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
7063 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
7064 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7065 // new format - val looks like "Off" or "0" (plane id)
7066 // (note: in new format "Off" value is used only for consistency,
7067 // so it is processed together with values in old format)
7068 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7069 if( anIsOldFormat ) {
7070 if (paramNameStr == "ClippingPlane1" || val == "Off")
7071 aSmeshActor->RemoveAllClippingPlanes();
7073 QList<SUIT_ViewManager*> lst;
7074 getApp()->viewManagers(viewerTypStr, lst);
7075 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7076 if (viewIndex >= 0 && viewIndex < lst.count()) {
7077 SUIT_ViewManager* vman = lst.at(viewIndex);
7078 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7080 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7082 SMESH::TActorList anActorList;
7083 anActorList.push_back( aSmeshActor );
7084 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7085 aPlane->myViewWindow = vtkView;
7086 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7087 aPlane->PlaneMode = aMode;
7088 bool isOpenGLClipping = ( bool )vals[1].toInt();
7089 aPlane->IsOpenGLClipping = isOpenGLClipping;
7090 if ( aMode == SMESH::Absolute ) {
7091 aPlane->myAbsoluteOrientation = vals[2].toInt();
7092 aPlane->X = vals[3].toFloat();
7093 aPlane->Y = vals[4].toFloat();
7094 aPlane->Z = vals[5].toFloat();
7095 aPlane->Dx = vals[6].toFloat();
7096 aPlane->Dy = vals[7].toFloat();
7097 aPlane->Dz = vals[8].toFloat();
7099 else if ( aMode == SMESH::Relative ) {
7100 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7101 aPlane->myDistance = vals[3].toFloat();
7102 aPlane->myAngle[0] = vals[4].toFloat();
7103 aPlane->myAngle[1] = vals[5].toFloat();
7107 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7108 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7109 aClippingPlaneInfo.Plane = aPlane;
7110 aClippingPlaneInfo.ActorList = anActorList;
7111 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7119 int aPlaneId = val.toInt( &ok );
7120 if( ok && aPlaneId >= 0 ) {
7121 bool anIsDefinedPlane = false;
7122 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7123 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7124 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7125 TPlaneInfo& aPlaneInfo = *anIter;
7126 if( aPlaneInfo.PlaneId == aPlaneId ) {
7127 aPlaneInfo.ActorList.push_back( aSmeshActor );
7128 anIsDefinedPlane = true;
7132 if( !anIsDefinedPlane ) {
7133 TPlaneInfo aPlaneInfo;
7134 aPlaneInfo.PlaneId = aPlaneId;
7135 aPlaneInfo.ActorList.push_back( aSmeshActor );
7136 aPlaneInfo.ViewManager = vman;
7138 // to make the list sorted by plane id
7139 anIter = aPlaneInfoList.begin();
7140 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7141 const TPlaneInfo& aPlaneInfoRef = *anIter;
7142 if( aPlaneInfoRef.PlaneId > aPlaneId )
7145 aPlaneInfoList.insert( anIter, aPlaneInfo );
7150 } // if (aSmeshActor)
7151 } // other parameters than Visibility
7153 } // for names/parameters iterator
7154 } // for entries iterator
7156 // take into account planes with empty list of actors referred to them
7157 QList<SUIT_ViewManager*> aVMList;
7158 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7160 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7161 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7162 int aViewId = aPlaneDataIter->first;
7163 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7164 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7166 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7168 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7169 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7170 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7171 const TPlaneData& aPlaneData = *anIter2;
7172 int aPlaneId = aPlaneData.Id;
7174 bool anIsFound = false;
7175 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7176 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7177 const TPlaneInfo& aPlaneInfo = *anIter3;
7178 if( aPlaneInfo.PlaneId == aPlaneId ) {
7185 TPlaneInfo aPlaneInfo; // ActorList field is empty
7186 aPlaneInfo.PlaneId = aPlaneId;
7187 aPlaneInfo.ViewManager = aViewManager;
7189 // to make the list sorted by plane id
7190 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7191 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7192 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7193 if( aPlaneInfoRef.PlaneId > aPlaneId )
7196 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7202 // add clipping planes to actors according to the restored parameters
7203 // and update the clipping plane map
7204 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7205 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7206 int aViewId = anIter1->first;
7207 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7209 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7210 if( anIter2 == aPlaneDataMap.end() )
7212 const TPlaneDataList& aPlaneDataList = anIter2->second;
7214 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7215 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7216 const TPlaneInfo& aPlaneInfo = *anIter3;
7217 int aPlaneId = aPlaneInfo.PlaneId;
7218 const TActorList& anActorList = aPlaneInfo.ActorList;
7219 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7223 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7227 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7229 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7230 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7231 const TPlaneData& aPlaneData = *anIter4;
7232 if( aPlaneData.Id == aPlaneId ) {
7233 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7234 aPlane->myViewWindow = aViewWindow;
7235 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7236 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7237 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7238 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7239 aPlane->X = aPlaneData.X;
7240 aPlane->Y = aPlaneData.Y;
7241 aPlane->Z = aPlaneData.Z;
7242 aPlane->Dx = aPlaneData.Dx;
7243 aPlane->Dy = aPlaneData.Dy;
7244 aPlane->Dz = aPlaneData.Dz;
7246 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7247 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7248 aPlane->myDistance = aPlaneData.Distance;
7249 aPlane->myAngle[0] = aPlaneData.Angle[0];
7250 aPlane->myAngle[1] = aPlaneData.Angle[1];
7253 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7254 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7255 aClippingPlaneInfo.Plane = aPlane;
7256 aClippingPlaneInfo.ActorList = anActorList;
7257 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7268 // update all VTK views
7269 QList<SUIT_ViewManager*> lst;
7270 getApp()->viewManagers(lst);
7271 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7272 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7273 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7274 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7275 // set OpenGL clipping planes
7276 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7277 vtkActorCollection* anAllActors = aCopy.GetActors();
7278 anAllActors->InitTraversal();
7279 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7280 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7281 anActor->SetOpenGLClippingPlane();
7283 vtkView->getRenderer()->ResetCameraClippingRange();
7290 \brief Adds preferences for dfont of VTK viewer
7292 \param pIf group identifier
7293 \param param parameter
7294 \return identifier of preferences
7296 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7298 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7300 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7303 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7304 fam.append( tr( "SMESH_FONT_COURIER" ) );
7305 fam.append( tr( "SMESH_FONT_TIMES" ) );
7307 setPreferenceProperty( tfont, "fonts", fam );
7309 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7310 if ( needSize ) f = f | QtxFontEdit::Size;
7311 setPreferenceProperty( tfont, "features", f );
7317 \brief Actions after hypothesis edition
7318 Updates object browser after hypothesis edition
7320 void SMESHGUI::onHypothesisEdit( int result )
7323 SMESHGUI::Modified();
7324 updateObjBrowser( true );
7328 \brief Actions after choosing menu of control modes
7329 Updates control mode actions according to current selection
7331 void SMESHGUI::onUpdateControlActions()
7333 SALOME_ListIO selected;
7334 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7335 aSel->selectedObjects( selected );
7337 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7338 if ( selected.Extent() ) {
7339 if ( selected.First()->hasEntry() ) {
7340 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7341 aControl = anActor->GetControlMode();
7342 SALOME_ListIteratorOfListIO it(selected);
7343 for ( it.Next(); it.More(); it.Next() ) {
7344 Handle(SALOME_InteractiveObject) anIO = it.Value();
7345 if ( anIO->hasEntry() ) {
7346 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7347 if ( aControl != anActor->GetControlMode() ) {
7348 aControl = SMESH_Actor::eNone;
7358 int anAction = ActionToControl( aControl, true );
7360 action( anAction )->setChecked( true );
7362 QMenu* send = (QMenu*)sender();
7363 QList<QAction*> actions = send->actions();
7364 for ( int i = 0; i < actions.size(); i++ )
7365 actions[i]->setChecked( false );
7371 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7372 \param pview view being closed
7374 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7375 #ifndef DISABLE_PLOT2DVIEWER
7376 //Crear all Plot2d Viewers if need.
7377 SMESH::ClearPlot2Viewers(pview);
7379 EmitSignalCloseView();
7382 void SMESHGUI::message( const QString& msg )
7385 QStringList data = msg.split("/");
7386 if ( data.count() > 0 ) {
7387 if ( data.first() == "mesh_loading" ) {
7389 QString entry = data.count() > 1 ? data[1] : QString();
7390 if ( entry.isEmpty() )
7393 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7395 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7398 name = SMESH::fromUtf8(obj->GetName());
7399 if ( name.isEmpty() )
7402 if ( data.last() == "stop" )
7403 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7405 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7406 QApplication::processEvents();
7412 \brief Connects or disconnects signals about activating and cloning view on the module slots
7413 \param pview view which is connected/disconnected
7415 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7419 SUIT_ViewManager* viewMgr = pview->getViewManager();
7421 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7422 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7424 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7425 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7430 \brief Return \c true if object can be renamed
7432 bool SMESHGUI::renameAllowed( const QString& entry) const {
7433 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7437 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7441 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7446 if(appStudy->isComponent(entry) || obj->isReference())
7449 // check type to prevent renaming of inappropriate objects
7450 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7451 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7452 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7453 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7454 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7455 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7462 Rename object by entry.
7463 \param entry entry of the object
7464 \param name new name of the object
7465 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7467 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7469 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7473 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7478 _PTR(Study) aStudy = appStudy->studyDS();
7483 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7485 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7490 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7491 _PTR(GenericAttribute) anAttr;
7492 _PTR(AttributeName) aName;
7494 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7496 // check type to prevent renaming of inappropriate objects
7497 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7498 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7499 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7500 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7501 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7502 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7503 if ( !name.isEmpty() ) {
7504 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7506 // update name of group object and its actor
7507 Handle(SALOME_InteractiveObject) IObject =
7508 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7510 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7511 if( !aGroupObject->_is_nil() ) {
7512 aGroupObject->SetName( qUtf8Printable(name) );
7513 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7514 anActor->setName( qUtf8Printable(name) );
7524 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7526 static QList<QColor> colors;
7528 if ( colors.isEmpty() ) {
7530 for (int s = 0; s < 2 ; s++)
7532 for (int v = 100; v >= 40; v = v - 20)
7534 for (int h = 0; h < 359 ; h = h + 60)
7536 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7541 static int currentColor = randomize( colors.size() );
7543 SALOMEDS::Color color;
7544 color.R = (double)colors[currentColor].red() / 255.0;
7545 color.G = (double)colors[currentColor].green() / 255.0;
7546 color.B = (double)colors[currentColor].blue() / 255.0;
7548 currentColor = (currentColor+1) % colors.count();