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_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_DisplayEntitiesDlg.h"
44 #include "SMESHGUI_Displayer.h"
45 #include "SMESHGUI_DuplicateNodesDlg.h"
46 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
47 #include "SMESHGUI_ExtrusionDlg.h"
48 #include "SMESHGUI_FaceGroupsSeparatedByEdgesDlg.h"
49 #include "SMESHGUI_FieldSelectorWdg.h"
50 #include "SMESHGUI_FileInfoDlg.h"
51 #include "SMESHGUI_FileValidator.h"
52 #include "SMESHGUI_FilterDlg.h"
53 #include "SMESHGUI_FilterLibraryDlg.h"
54 #include "SMESHGUI_FilterUtils.h"
55 #include "SMESHGUI_FindElemByPointDlg.h"
56 #include "SMESHGUI_GEOMGenUtils.h"
57 #include "SMESHGUI_GroupDlg.h"
58 #include "SMESHGUI_GroupOnShapeDlg.h"
59 #include "SMESHGUI_GroupOpDlg.h"
60 #include "SMESHGUI_GroupUtils.h"
61 #include "SMESHGUI_Hypotheses.h"
62 #include "SMESHGUI_HypothesesUtils.h"
63 #include "SMESHGUI_Make2DFrom3DOp.h"
64 #include "SMESHGUI_MakeNodeAtPointDlg.h"
65 #include "SMESHGUI_Measurements.h"
66 #include "SMESHGUI_MergeDlg.h"
67 #include "SMESHGUI_MeshInfo.h"
68 #include "SMESHGUI_MeshOp.h"
69 #include "SMESHGUI_MeshOrderOp.h"
70 #include "SMESHGUI_MeshPatternDlg.h"
71 #include "SMESHGUI_MeshUtils.h"
72 #include "SMESHGUI_MultiEditDlg.h"
73 #include "SMESHGUI_NodesDlg.h"
74 #include "SMESHGUI_OffsetDlg.h"
75 #include "SMESHGUI_Operations.h"
76 #include "SMESHGUI_PatternUtils.h"
77 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
78 #include "SMESHGUI_PropertiesDlg.h"
79 #include "SMESHGUI_RemoveElementsDlg.h"
80 #include "SMESHGUI_RemoveNodesDlg.h"
81 #include "SMESHGUI_RenumberingDlg.h"
82 #include "SMESHGUI_ReorientFacesDlg.h"
83 #include "SMESHGUI_RevolutionDlg.h"
84 #include "SMESHGUI_RotationDlg.h"
85 #include "SMESHGUI_ScaleDlg.h"
86 #include "SMESHGUI_Selection.h"
87 #include "SMESHGUI_SewingDlg.h"
88 #include "SMESHGUI_SingleEditDlg.h"
89 #include "SMESHGUI_SmoothingDlg.h"
90 #include "SMESHGUI_SpinBox.h"
91 #include "SMESHGUI_SplitBiQuad.h"
92 #include "SMESHGUI_SymmetryDlg.h"
93 #include "SMESHGUI_TranslationDlg.h"
94 #include "SMESHGUI_TransparencyDlg.h"
95 #include "SMESHGUI_Utils.h"
96 #include "SMESHGUI_VTKUtils.h"
98 #include "SMESH_version.h"
100 #include "SMESH_Actor.h"
101 #include "SMESH_ActorUtils.h"
102 #include "SMESH_Client.hxx"
103 #include "SMESH_Comment.hxx"
104 #include "SMESH_ControlsDef.hxx"
105 #include "SMESH_ScalarBarActor.h"
106 #include "SMESH_TypeFilter.hxx"
107 #include "SMESH_Component_Generator.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() : SalomeApp_Module( "SMESH" )
2161 if ( CORBA::is_nil( myComponentSMESH ) )
2163 CORBA::Boolean anIsEmbeddedMode;
2164 SALOME_NamingService_Abstract *ns = SalomeApp_Application::namingService();
2165 if( dynamic_cast<SALOME_NamingService *>(ns) )
2166 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2169 Engines::EngineComponent_var comp = RetrieveSMESHInstance();
2170 myComponentSMESH = SMESH::SMESH_Gen::_narrow(comp);
2173 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2175 // 0019923: EDF 765 SMESH : default values of hypothesis
2176 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2177 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2178 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2179 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2180 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2182 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2183 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2184 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2186 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2187 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2191 myActiveDialogBox = 0;
2192 myFilterLibraryDlg = 0;
2196 myEventCallbackCommand = vtkCallbackCommand::New();
2197 myEventCallbackCommand->Delete();
2198 myEventCallbackCommand->SetClientData( this );
2199 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2202 /* load resources for all available meshers */
2203 SMESH::InitAvailableHypotheses();
2206 //=============================================================================
2210 //=============================================================================
2211 SMESHGUI::~SMESHGUI()
2215 //=============================================================================
2219 //=============================================================================
2220 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2222 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2224 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2229 //=============================================================================
2233 //=============================================================================
2234 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2236 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2240 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2241 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2242 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2243 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2244 return autoUpdate && !exceeded;
2247 //=============================================================================
2251 //=============================================================================
2252 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2253 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2255 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2259 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2260 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2261 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2263 SMESH::long_array_var info = theMesh->GetMeshInfo();
2264 long nbOdElems = info[SMDSEntity_0D];
2265 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2266 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2267 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2268 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2269 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2270 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2271 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2272 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2273 info[SMDSEntity_Polyhedra] +
2274 info[SMDSEntity_Hexagonal_Prism];
2275 long nbBalls = info[SMDSEntity_Ball];
2277 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2278 *nbElements = requestedSize;
2280 *entities = SMESH_Actor::eAllEntity;
2283 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2285 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2287 if ( incrementalLimit ) {
2290 if ( nbOdElems > 0 ) {
2291 if ( total + nbOdElems > updateLimit ) {
2292 *entities = *entities & ~SMESH_Actor::e0DElements;
2293 *hidden = *hidden | SMESH_Actor::e0DElements;
2300 if ( nbEdges > 0 ) {
2301 if ( total + nbEdges > updateLimit ) {
2302 *entities = *entities & ~SMESH_Actor::eEdges;
2303 *hidden = *hidden | SMESH_Actor::eEdges;
2310 if ( nbFaces > 0 ) {
2311 if ( total + nbFaces > updateLimit ) {
2312 *entities = *entities & ~SMESH_Actor::eFaces;
2313 *hidden = *hidden | SMESH_Actor::eFaces;
2320 if ( nbVolumes > 0 ) {
2321 if ( total + nbVolumes > updateLimit ) {
2322 *entities = *entities & ~SMESH_Actor::eVolumes;
2323 *hidden = *hidden | SMESH_Actor::eVolumes;
2330 if ( nbBalls > 0 ) {
2331 if ( total + nbBalls > updateLimit ) {
2332 *entities = *entities & ~SMESH_Actor::eBallElem;
2333 *hidden = *hidden | SMESH_Actor::eBallElem;
2341 return autoUpdate && !exceeded;
2344 //=============================================================================
2348 //=============================================================================
2349 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2351 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2354 //=============================================================================
2358 //=============================================================================
2359 SMESHGUI* SMESHGUI::GetSMESHGUI()
2361 SMESHGUI* smeshMod = 0;
2362 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2365 CAM_Module* module = app->module( "Mesh" );
2366 smeshMod = dynamic_cast<SMESHGUI*>( module );
2374 Standard_EXPORT SMESHGUI* GetComponentGUI()
2376 return SMESHGUI::GetSMESHGUI();
2380 //=============================================================================
2384 //=============================================================================
2385 void SMESHGUI::SetState(int aState)
2390 //=============================================================================
2394 //=============================================================================
2395 void SMESHGUI::ResetState()
2400 //=============================================================================
2404 //=============================================================================
2405 void SMESHGUI::EmitSignalDeactivateDialog()
2407 emit SignalDeactivateActiveDialog();
2410 //=============================================================================
2414 //=============================================================================
2415 void SMESHGUI::EmitSignalStudyFrameChanged()
2417 emit SignalStudyFrameChanged();
2420 //=============================================================================
2424 //=============================================================================
2425 void SMESHGUI::EmitSignalCloseAllDialogs()
2427 emit SignalCloseAllDialogs();
2430 //=============================================================================
2434 //=============================================================================
2435 void SMESHGUI::EmitSignalVisibilityChanged()
2437 emit SignalVisibilityChanged();
2440 //=============================================================================
2444 //=============================================================================
2445 void SMESHGUI::EmitSignalCloseView()
2447 emit SignalCloseView();
2450 //=============================================================================
2454 //=============================================================================
2455 void SMESHGUI::EmitSignalActivatedViewManager()
2457 emit SignalActivatedViewManager();
2460 //=============================================================================
2464 //=============================================================================
2465 QDialog *SMESHGUI::GetActiveDialogBox()
2467 return myActiveDialogBox;
2470 //=============================================================================
2474 //=============================================================================
2475 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2477 myActiveDialogBox = (QDialog *) aDlg;
2481 //=============================================================================
2485 //=============================================================================
2486 SUIT_Desktop* SMESHGUI::desktop()
2488 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2490 return app->desktop();
2495 //=============================================================================
2499 //=============================================================================
2500 SalomeApp_Study* SMESHGUI::activeStudy()
2502 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2504 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2509 //=============================================================================
2513 //=============================================================================
2514 void SMESHGUI::Modified( bool theIsUpdateActions )
2516 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2517 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2518 appStudy->Modified();
2519 if( theIsUpdateActions )
2520 app->updateActions();
2525 //=============================================================================
2529 //=============================================================================
2530 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2532 /* Here the position is on the bottom right corner - 10 */
2533 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2535 SUIT_Desktop *PP = desktop();
2536 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2537 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2542 * \brief Verifies whether study of operation is locked
2543 * \param theMess - specifies whether message box must be shown if study is locked
2544 * \return State of study.
2546 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2547 * is locked when corresponding message box appears
2549 bool SMESHGUI::isStudyLocked( bool theMessage )
2551 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2554 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2555 QObject::tr( "WRN_WARNING" ),
2556 QObject::tr( "WRN_STUDY_LOCKED" ) );
2562 //=============================================================================
2566 //=============================================================================
2567 bool SMESHGUI::OnGUIEvent( int theCommandID )
2569 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2573 SUIT_ResourceMgr* mgr = resourceMgr();
2577 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2578 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2580 //QAction* act = action( theCommandID );
2582 switch (theCommandID) {
2583 case SMESHOp::OpDelete:
2584 if(isStudyLocked()) break;
2587 case SMESHOp::OpImportDAT:
2588 case SMESHOp::OpImportUNV:
2589 case SMESHOp::OpImportMED:
2590 case SMESHOp::OpImportSTL:
2591 case SMESHOp::OpImportCGNS:
2592 case SMESHOp::OpImportSAUV:
2593 case SMESHOp::OpImportGMF:
2594 case SMESHOp::OpPopupImportDAT:
2595 case SMESHOp::OpPopupImportUNV:
2596 case SMESHOp::OpPopupImportMED:
2597 case SMESHOp::OpPopupImportSTL:
2598 case SMESHOp::OpPopupImportCGNS:
2599 case SMESHOp::OpPopupImportSAUV:
2600 case SMESHOp::OpPopupImportGMF:
2602 if(isStudyLocked()) break;
2603 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2607 case SMESHOp::OpFileInformation:
2609 SALOME_ListIO selected;
2610 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2612 aSel->selectedObjects( selected );
2613 if( selected.Extent() )
2615 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2616 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2617 if ( !aMesh->_is_nil() )
2619 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2625 case SMESHOp::OpExportDAT:
2626 case SMESHOp::OpExportMED:
2627 case SMESHOp::OpExportUNV:
2628 case SMESHOp::OpExportSTL:
2629 case SMESHOp::OpExportCGNS:
2630 case SMESHOp::OpExportSAUV:
2631 case SMESHOp::OpExportGMF:
2632 case SMESHOp::OpPopupExportDAT:
2633 case SMESHOp::OpPopupExportMED:
2634 case SMESHOp::OpPopupExportUNV:
2635 case SMESHOp::OpPopupExportSTL:
2636 case SMESHOp::OpPopupExportCGNS:
2637 case SMESHOp::OpPopupExportSAUV:
2638 case SMESHOp::OpPopupExportGMF:
2640 ::ExportMeshToFile(theCommandID);
2644 case SMESHOp::OpReset: // SCALAR BAR
2646 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2647 SALOME_ListIO selected;
2649 aSel->selectedObjects( selected );
2651 SALOME_ListIteratorOfListIO it(selected);
2652 for( ; it.More(); it.Next()) {
2653 Handle(SALOME_InteractiveObject) anIO = it.Value();
2654 if( anIO->hasEntry() ) {
2655 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2656 anActor->SetControlMode( SMESH_Actor::eNone );
2657 #ifndef DISABLE_PLOT2DVIEWER
2658 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2660 anActor->UpdateFilter();
2664 SMESH::UpdateView();
2667 case SMESHOp::OpScalarBarProperties:
2669 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2672 case SMESHOp::OpShowScalarBar:
2674 // show/hide scalar bar
2675 ::ShowElement(theCommandID);
2678 case SMESHOp::OpSaveDistribution:
2680 // dump control distribution data to the text file
2681 ::SaveDistribution();
2685 case SMESHOp::OpShowDistribution:
2687 // show/hide distribution
2688 ::ShowElement(theCommandID);
2692 #ifndef DISABLE_PLOT2DVIEWER
2693 case SMESHOp::OpPlotDistribution:
2695 // plot distribution
2696 ::PlotDistribution();
2702 case SMESHOp::OpAutoColor:
2706 case SMESHOp::OpDisableAutoColor:
2707 ::DisableAutoColor();
2710 case SMESHOp::OpClipping:
2711 case SMESHOp::OpTransparency:
2712 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2715 case SMESHOp::OpDMWireframe:
2716 case SMESHOp::OpDMShading:
2717 case SMESHOp::OpDMNodes:
2718 case SMESHOp::OpDMShrink:
2719 ::SetDisplayMode(theCommandID, myMarkerMap);
2722 //2D quadratic representation
2723 case SMESHOp::OpRepresentationLines:
2724 case SMESHOp::OpRepresentationArcs:
2725 ::SetDisplayMode(theCommandID, myMarkerMap);
2729 case SMESHOp::OpDE0DElements:
2730 case SMESHOp::OpDEEdges:
2731 case SMESHOp::OpDEFaces:
2732 case SMESHOp::OpDEVolumes:
2733 case SMESHOp::OpDEBalls:
2734 case SMESHOp::OpDEAllEntity:
2735 ::SetDisplayEntity(theCommandID);
2738 // Choose entities to be displayed
2739 case SMESHOp::OpDEChoose:
2741 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2745 case SMESHOp::OpOrientationOnFaces:
2747 SUIT_OverrideCursor wc;
2748 LightApp_SelectionMgr* mgr = selectionMgr();
2749 SALOME_ListIO selected; mgr->selectedObjects( selected );
2751 SALOME_ListIteratorOfListIO it(selected);
2752 for( ; it.More(); it.Next()) {
2753 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2754 if(anIObject->hasEntry()) {
2755 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2756 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2763 case SMESHOp::OpUpdate:
2765 if(isStudyLocked()) break;
2766 SUIT_OverrideCursor wc;
2769 SMESH::UpdateView();
2771 catch (std::bad_alloc&) { // PAL16774 (Crash after display of many groups)
2772 SMESH::OnVisuException();
2774 catch (...) { // PAL16774 (Crash after display of many groups)
2775 SMESH::OnVisuException();
2779 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2780 aSel->selectedObjects( l );
2781 aSel->setSelectedObjects( l );
2785 case SMESHOp::OpHide:
2786 case SMESHOp::OpShow:
2787 case SMESHOp::OpShowOnly:
2789 SUIT_OverrideCursor wc;
2790 SMESH::EDisplaing anAction;
2791 switch (theCommandID) {
2792 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2793 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2794 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2797 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2798 SALOME_ListIO sel_objects, to_process;
2800 aSel->selectedObjects( sel_objects );
2802 if ( theCommandID==SMESHOp::OpShowOnly )
2804 //MESSAGE("anAction = SMESH::eDisplayOnly");
2805 startOperation( myEraseAll );
2808 extractContainers( sel_objects, to_process );
2813 SALOME_ListIteratorOfListIO It( to_process );
2814 for ( ; It.More(); It.Next())
2816 Handle(SALOME_InteractiveObject) IOS = It.Value();
2817 if ( IOS->hasEntry() )
2819 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2820 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2821 break; // PAL16774 (Crash after display of many groups)
2823 if (anAction == SMESH::eDisplayOnly)
2824 anAction = SMESH::eDisplay;
2829 // PAL13338 + PAL15161 -->
2830 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2831 SMESH::UpdateView();
2832 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2834 // PAL13338 + PAL15161 <--
2836 catch (...) { // PAL16774 (Crash after display of many groups)
2837 SMESH::OnVisuException();
2840 if (anAction == SMESH::eErase) {
2842 aSel->setSelectedObjects( l1 );
2845 aSel->setSelectedObjects( to_process );
2847 if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2848 ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2849 vtkwnd->GetRenderer()->AdjustActors();
2854 case SMESHOp::OpNode:
2856 if(isStudyLocked()) break;
2859 EmitSignalDeactivateDialog();
2861 ( new SMESHGUI_NodesDlg( this ) )->show();
2864 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2869 case SMESHOp::OpEditMeshOrSubMesh:
2870 case SMESHOp::OpEditMesh:
2871 case SMESHOp::OpEditSubMesh:
2872 case SMESHOp::OpMeshOrder:
2873 case SMESHOp::OpCreateSubMesh:
2874 if ( warnOnGeomModif() )
2875 break; // action forbidden as geometry modified
2877 case SMESHOp::OpCreateMesh:
2878 case SMESHOp::OpCompute:
2879 case SMESHOp::OpComputeSubMesh:
2880 case SMESHOp::OpPreCompute:
2881 case SMESHOp::OpEvaluate:
2882 case SMESHOp::OpShowErrors:
2883 startOperation( theCommandID );
2885 case SMESHOp::OpRecompute:
2887 if ( isStudyLocked() )
2889 SALOME_ListIO selected;
2890 if ( LightApp_SelectionMgr *sel = selectionMgr() )
2891 sel->selectedObjects( selected );
2892 if ( selected.Extent() == 1 ) {
2893 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO( selected.First() );
2894 if ( !aMesh->_is_nil() )
2896 startOperation( SMESHOp::OpCompute );
2900 case SMESHOp::OpCopyMesh:
2902 if (isStudyLocked()) break;
2903 EmitSignalDeactivateDialog();
2904 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2907 case SMESHOp::OpBuildCompoundMesh:
2909 if (isStudyLocked()) break;
2910 EmitSignalDeactivateDialog();
2911 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2915 case SMESHOp::OpDiagonalInversion:
2916 case SMESHOp::OpUnionOfTwoTriangle:
2920 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2924 if ( isStudyLocked() )
2926 if ( warnOnGeomModif() )
2927 break; // action forbidden as geometry modified
2929 /*Standard_Boolean aRes;
2930 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2931 if ( aMesh->_is_nil() )
2933 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2934 tr( "SMESH_BAD_SELECTION" ) );
2938 EmitSignalDeactivateDialog();
2939 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2940 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2942 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2945 case SMESHOp::OpOrientation:
2946 case SMESHOp::OpUnionOfTriangles:
2947 case SMESHOp::OpCuttingOfQuadrangles:
2948 case SMESHOp::OpSplitVolumes:
2952 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2956 if ( isStudyLocked() )
2958 if ( warnOnGeomModif() )
2959 break; // action forbidden as geometry modified
2961 EmitSignalDeactivateDialog();
2962 SMESHGUI_MultiEditDlg* aDlg = NULL;
2963 if ( theCommandID == SMESHOp::OpOrientation )
2964 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2965 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2966 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2967 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2968 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2970 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2975 case SMESHOp::OpSmoothing:
2977 if(isStudyLocked()) break;
2978 if ( warnOnGeomModif() )
2979 break; // action forbidden as geometry modified
2981 EmitSignalDeactivateDialog();
2982 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2985 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2989 case SMESHOp::OpExtrusion:
2991 if (isStudyLocked()) break;
2992 if ( warnOnGeomModif() )
2993 break; // action forbidden as geometry modified
2995 EmitSignalDeactivateDialog();
2996 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2998 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3002 case SMESHOp::OpExtrusionAlongAPath:
3004 if (isStudyLocked()) break;
3005 if ( warnOnGeomModif() )
3006 break; // action forbidden as geometry modified
3008 EmitSignalDeactivateDialog();
3009 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
3011 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3015 case SMESHOp::OpRevolution:
3017 if(isStudyLocked()) break;
3018 if ( warnOnGeomModif() )
3019 break; // action forbidden as geometry modified
3021 EmitSignalDeactivateDialog();
3022 ( new SMESHGUI_RevolutionDlg( this ) )->show();
3025 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3029 case SMESHOp::OpPatternMapping:
3031 if ( isStudyLocked() )
3033 if ( warnOnGeomModif() )
3034 break; // action forbidden as geometry modified
3037 EmitSignalDeactivateDialog();
3038 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
3041 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
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 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4283 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4284 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4285 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4286 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4287 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4289 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4290 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4291 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4293 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4295 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4297 QList<int> aCtrlActions;
4298 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4299 << SMESHOp::OpNodeConnectivityNb // node controls
4300 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4301 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4302 << SMESHOp::OpDeflection2D
4303 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4304 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4305 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4306 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4307 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4308 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4309 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4310 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4311 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4312 aCtrlGroup->setExclusive( true );
4313 for( int i = 0; i < aCtrlActions.size(); i++ )
4314 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4316 // ----- create menu --------------
4317 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4318 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4319 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4320 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4321 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4322 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4323 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4324 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4326 createMenu( separator(), fileId );
4328 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4329 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4330 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4331 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4332 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4333 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4334 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4335 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4336 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4337 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4338 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4339 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4340 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4342 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4343 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4344 createMenu( SMESHOp::OpImportMED, importId, -1 );
4345 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4347 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4349 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4350 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4351 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4352 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4353 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4354 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4356 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4358 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4359 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4360 createMenu( separator(), fileId, 10 );
4362 createMenu( SMESHOp::OpDelete, editId, -1 );
4364 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4366 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4367 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4368 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4369 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4370 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4371 createMenu( separator(), meshId, -1 );
4372 createMenu( SMESHOp::OpCompute, meshId, -1 );
4373 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4374 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4375 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4376 createMenu( separator(), meshId, -1 );
4377 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4378 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4379 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4380 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4381 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4382 createMenu( separator(), meshId, -1 );
4383 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4384 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4385 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4386 createMenu( separator(), meshId, -1 );
4387 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4388 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4389 createMenu( separator(), meshId, -1 );
4390 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4391 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4392 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4393 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4394 createMenu( separator(), meshId, -1 );
4396 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4397 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4398 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4399 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4400 createMenu( SMESHOp::OpLength, edgeId, -1 );
4401 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4402 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4403 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4404 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4405 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4406 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4407 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4408 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4409 createMenu( SMESHOp::OpArea, faceId, -1 );
4410 createMenu( SMESHOp::OpTaper, faceId, -1 );
4411 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4412 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4413 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4414 createMenu( SMESHOp::OpSkew, faceId, -1 );
4415 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4416 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4417 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4418 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4419 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4420 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4421 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4422 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4423 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4424 createMenu( separator(), ctrlId, -1 );
4425 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4426 createMenu( separator(), ctrlId, -1 );
4427 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4429 createMenu( SMESHOp::OpNode, addId, -1 );
4430 createMenu( SMESHOp::OpElem0D, addId, -1 );
4431 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4432 createMenu( SMESHOp::OpBall, addId, -1 );
4433 createMenu( SMESHOp::OpEdge, addId, -1 );
4434 createMenu( SMESHOp::OpTriangle, addId, -1 );
4435 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4436 createMenu( SMESHOp::OpPolygon, addId, -1 );
4437 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4438 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4439 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4440 createMenu( SMESHOp::OpPyramid, addId, -1 );
4441 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4442 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4443 createMenu( separator(), addId, -1 );
4444 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4445 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4446 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4447 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4448 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4449 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4450 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4451 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4452 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4453 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4454 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4455 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4457 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4458 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4459 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4460 createMenu( separator(), removeId, -1 );
4461 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4462 createMenu( separator(), removeId, -1 );
4463 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4465 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4466 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4468 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4469 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4470 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4471 createMenu( SMESHOp::OpRotation, transfId, -1 );
4472 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4473 createMenu( SMESHOp::OpScale, transfId, -1 );
4474 createMenu( SMESHOp::OpOffset, transfId, -1 );
4475 createMenu( SMESHOp::OpSewing, transfId, -1 );
4476 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4478 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4479 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4480 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4481 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4482 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4483 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4484 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4485 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4486 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4487 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4488 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4489 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4490 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4491 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4492 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4493 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4495 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4496 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4497 createMenu( SMESHOp::OpAngle, measureId, -1 );
4498 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4499 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4500 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4501 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4503 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4504 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4505 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4506 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4508 // ----- create toolbars --------------
4509 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4510 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4511 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4512 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4513 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4514 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4515 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4516 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4517 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4518 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4519 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4520 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4521 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4522 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4523 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4525 createTool( SMESHOp::OpCreateMesh, meshTb );
4526 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4527 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4528 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4529 createTool( SMESHOp::OpCopyMesh, meshTb );
4530 createTool( separator(), meshTb );
4531 createTool( SMESHOp::OpCompute, meshTb );
4532 createTool( SMESHOp::OpPreCompute, meshTb );
4533 createTool( SMESHOp::OpEvaluate, meshTb );
4534 createTool( SMESHOp::OpMeshOrder, meshTb );
4536 createTool( SMESHOp::OpCreateGroup, groupTb );
4537 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4538 createTool( SMESHOp::OpConstructGroup, groupTb );
4539 createTool( SMESHOp::OpEditGroup, groupTb );
4541 createTool( SMESHOp::OpMeshInformation, info );
4542 //createTool( SMESHOp::OpStdInfo, meshTb );
4543 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4544 createTool( SMESHOp::OpFindElementByPoint, info );
4546 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4547 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4548 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4550 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4551 createTool( SMESHOp::OpLength, ctrl1dTb );
4552 createTool( SMESHOp::OpConnection, ctrl1dTb );
4553 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4555 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4556 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4557 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4558 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4559 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4560 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4561 createTool( SMESHOp::OpArea, ctrl2dTb );
4562 createTool( SMESHOp::OpTaper, ctrl2dTb );
4563 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4564 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4565 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4566 createTool( SMESHOp::OpSkew, ctrl2dTb );
4567 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4568 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4569 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
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 createTool( SMESHOp::OpNode, addElemTb );
4579 createTool( SMESHOp::OpElem0D, addElemTb );
4580 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4581 createTool( SMESHOp::OpBall, addElemTb );
4582 createTool( SMESHOp::OpEdge, addElemTb );
4583 createTool( SMESHOp::OpTriangle, addElemTb );
4584 createTool( SMESHOp::OpQuadrangle, addElemTb );
4585 createTool( SMESHOp::OpPolygon, addElemTb );
4586 createTool( SMESHOp::OpTetrahedron, addElemTb );
4587 createTool( SMESHOp::OpHexahedron, addElemTb );
4588 createTool( SMESHOp::OpPentahedron, addElemTb );
4589 createTool( SMESHOp::OpPyramid, addElemTb );
4590 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4591 createTool( SMESHOp::OpPolyhedron, addElemTb );
4593 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4594 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4595 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4596 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4597 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4598 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4599 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4600 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4601 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4602 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4603 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4604 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4606 createTool( SMESHOp::OpRemoveNodes, remTb );
4607 createTool( SMESHOp::OpRemoveElements, remTb );
4608 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4609 createTool( SMESHOp::OpClearMesh, remTb );
4611 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4612 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4614 createTool( SMESHOp::OpMergeNodes, transformTb );
4615 createTool( SMESHOp::OpMergeElements, transformTb );
4616 createTool( SMESHOp::OpTranslation, transformTb );
4617 createTool( SMESHOp::OpRotation, transformTb );
4618 createTool( SMESHOp::OpSymmetry, transformTb );
4619 createTool( SMESHOp::OpScale, transformTb );
4620 createTool( SMESHOp::OpOffset, transformTb );
4621 createTool( SMESHOp::OpSewing, transformTb );
4622 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4624 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4625 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4626 createTool( SMESHOp::OpExtrusion, modifyTb );
4627 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4628 createTool( SMESHOp::OpRevolution, modifyTb );
4629 createTool( SMESHOp::OpOrientation, modifyTb );
4630 createTool( SMESHOp::OpReorientFaces, modifyTb );
4631 createTool( SMESHOp::OpMoveNode, modifyTb );
4632 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4633 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4634 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4635 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4636 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4637 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4638 createTool( SMESHOp::OpSmoothing, modifyTb );
4639 createTool( SMESHOp::OpPatternMapping, modifyTb );
4641 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4643 createTool( SMESHOp::OpUpdate, dispModeTb );
4645 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4646 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4650 OB = "'ObjectBrowser'",
4651 View = "'" + SVTK_Viewer::Type() + "'",
4653 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4654 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4655 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4656 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4657 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4658 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4659 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4660 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4661 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4662 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4663 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4664 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4666 mesh_part = mesh + " " + subMesh + " " + group,
4667 mesh_group = mesh + " " + group,
4668 mesh_submesh = mesh + " " + subMesh,
4669 hyp_alg = hypo + " " + algo;
4671 // popup for object browser
4673 isInvisible("not( isVisible )"),
4674 isEmpty("numberOfNodes = 0"),
4675 isNotEmpty("numberOfNodes <> 0"),
4677 // has nodes, edges, etc in VISIBLE! actor
4678 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4679 hasElems("(count( elemTypes ) > 0)"),
4680 hasDifferentElems("(count( elemTypes ) > 1)"),
4681 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4682 hasBalls("({'BallElem'} in elemTypes)"),
4683 hasElems0d("({'Elem0d'} in elemTypes)"),
4684 hasEdges("({'Edge'} in elemTypes)"),
4685 hasFaces("({'Face'} in elemTypes)"),
4686 hasVolumes("({'Volume'} in elemTypes)"),
4687 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4689 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4690 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4691 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && hasAlgo && hasGeomReference" );
4692 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4693 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4694 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4696 popupMgr()->insert( separator(), -1, 0 );
4697 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4698 createPopupItem( SMESHOp::OpRecompute, OB, mesh, "&& selcount=1 && hasAlgo && (" + isNotEmpty + " || hasErrors )");
4699 createPopupItem( SMESHOp::OpShowErrors, OB, mesh, "&& selcount=1 && hasErrors" );
4700 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
4701 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );
4702 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4703 popupMgr()->insert( separator(), -1, 0 );
4704 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4705 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4706 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1 && " + hasElems );
4707 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4708 popupMgr()->insert( separator(), -1, 0 );
4709 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4710 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4711 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4712 popupMgr()->insert( separator(), -1, 0 );
4713 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4714 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4715 popupMgr()->insert( separator(), -1, 0 );
4716 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
4717 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4718 //popupMgr()->insert( separator(), -1, 0 );
4720 //popupMgr()->insert( separator(), -1, 0 );
4722 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4723 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4724 QString only_one_2D = only_one_non_empty + " && dim>1";
4726 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4727 popupMgr()->findMenu( anId )->menuAction()->setIcon( resourceMgr()->loadPixmap( "SMESH", tr( "ICON_EXPORT" )));
4728 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4729 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4730 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4732 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4734 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4735 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4736 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4738 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4739 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4740 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4741 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4743 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4745 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4746 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4747 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4748 popupMgr()->insert( separator(), -1, 0 );
4750 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4751 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4752 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4755 createPopupItem( SMESHOp::OpEditGroup, View, group );
4756 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4757 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4759 popupMgr()->insert( separator(), -1, 0 );
4760 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4761 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4762 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh, "&& " + hasElems);
4763 popupMgr()->insert( separator(), -1, 0 );
4765 createPopupItem( SMESHOp::OpUpdate, OB + " " + View, mesh_part );
4766 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4767 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4768 popupMgr()->insert( separator(), -1, 0 );
4770 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4771 QString aType = QString( "%1type in {%2}" ).arg( lc );
4772 aType = aType.arg( mesh_part );
4773 QString aMeshInVTK = aClient + "&&" + aType;
4775 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4776 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4777 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4779 //-------------------------------------------------
4781 //-------------------------------------------------
4782 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4784 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4785 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4786 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4788 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4789 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4790 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4792 popupMgr()->insert( separator(), -1, -1 );
4794 //-------------------------------------------------
4796 //-------------------------------------------------
4797 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4799 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4800 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4801 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4803 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4804 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4805 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4807 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4808 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4809 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4811 popupMgr()->insert( separator(), anId, -1 );
4813 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4814 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4815 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4817 //-------------------------------------------------
4819 //-------------------------------------------------
4820 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4822 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4824 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4825 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4826 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4828 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4829 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4830 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4832 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4833 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4834 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4836 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4837 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4838 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4840 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4841 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4842 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4844 popupMgr()->insert( separator(), anId, -1 );
4846 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4847 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4849 popupMgr()->insert( separator(), anId, -1 );
4851 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4852 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4855 //-------------------------------------------------
4856 // Representation of the 2D Quadratic elements
4857 //-------------------------------------------------
4858 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4859 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4860 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4861 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4863 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4864 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4865 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4867 //-------------------------------------------------
4868 // Orientation of faces
4869 //-------------------------------------------------
4870 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4871 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4872 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4874 //-------------------------------------------------
4876 //-------------------------------------------------
4877 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4878 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4880 //-------------------------------------------------
4882 //-------------------------------------------------
4883 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4884 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4886 //-------------------------------------------------
4888 //-------------------------------------------------
4890 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4891 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4892 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4893 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4895 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4897 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4898 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4900 popupMgr()->insert( separator(), anId, -1 );
4902 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4904 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4905 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4906 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4908 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4909 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4910 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4912 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4913 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4914 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4916 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4918 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4919 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4920 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4922 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4923 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4924 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4926 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4927 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4928 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4929 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4930 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4931 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4933 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4935 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4936 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4937 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4939 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4940 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4941 QtxPopupMgr::VisibleRule );
4942 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4944 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4945 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4946 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4948 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4949 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4950 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4952 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4953 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4954 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4956 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4957 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4958 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4960 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4961 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4962 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4964 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4965 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4966 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4968 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4969 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4970 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4972 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4973 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4974 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4976 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4977 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4978 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4980 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4981 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4982 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4984 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4985 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4986 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4988 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4989 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4990 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4992 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4993 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4994 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4996 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4998 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4999 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5000 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
5002 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
5003 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5004 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
5006 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
5007 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5008 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5010 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5011 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5012 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5014 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5015 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5016 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5018 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
5019 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5020 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5022 popupMgr()->insert( separator(), anId, -1 );
5024 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5025 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5026 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5027 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5028 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5030 popupMgr()->insert( separator(), anId, -1 );
5032 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5034 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5035 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5037 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5038 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5039 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5041 #ifndef DISABLE_PLOT2DVIEWER
5042 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5043 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5046 //-------------------------------------------------
5048 //-------------------------------------------------
5049 popupMgr()->insert( separator(), -1, -1 );
5050 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5051 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5052 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5053 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5055 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5056 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5058 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5059 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5061 popupMgr()->insert( separator(), -1, -1 );
5063 //-------------------------------------------------
5065 //-------------------------------------------------
5066 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5067 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5069 popupMgr()->insert( separator(), -1, -1 );
5071 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5072 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5073 popupMgr()->insert( separator(), -1, -1 );
5075 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5076 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5078 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5079 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5081 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5082 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5085 //================================================================================
5087 * \brief Return true if SMESH or GEOM objects are selected.
5088 * Is called form LightApp_Module::activateModule() which clear selection if
5089 * not isSelectionCompatible()
5091 //================================================================================
5093 bool SMESHGUI::isSelectionCompatible()
5095 bool isCompatible = true;
5096 SALOME_ListIO selected;
5097 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5098 Sel->selectedObjects( selected );
5100 SALOME_ListIteratorOfListIO It( selected );
5101 for ( ; isCompatible && It.More(); It.Next())
5103 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
5104 ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5105 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
5107 return isCompatible;
5111 bool SMESHGUI::reusableOperation( const int id )
5113 // compute, evaluate and precompute are not reusable operations
5114 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate || id == SMESHOp::OpRecompute ) ? false : SalomeApp_Module::reusableOperation( id );
5119 QString wrap(const QString& text, const QString& tag)
5120 { return QString("<%1>%2</%3>").arg(tag).arg(text).arg(tag);}
5123 bool SMESHGUI::activateModule( SUIT_Study* study )
5125 bool res = SalomeApp_Module::activateModule( study );
5127 setMenuShown( true );
5128 setToolShown( true );
5130 // Fill in Help Panel
5131 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( application() );
5132 app->infoPanel()->setTitle(tr("INFO_WELCOME_TO_SMESH"));
5134 int gb = app->infoPanel()->addGroup(tr("INFO_GRP_CREATE_MESH"));
5137 lab = tr("INFO_DEFINE_ALGOS") + "<br/>";
5138 lab = lab + tr("INFO_DEFINE_HYPOS") + "<br/>";
5139 lab = lab + tr("INFO_COMPUTE") + "<br/>";
5140 lab = lab + tr("INFO_REFINE") + ":";
5141 items << wrap(tr("INFO_REFINE_LOCAL_SIZE"), "li")
5142 << wrap(tr("INFO_REFINE_SUBMESH"), "li");
5143 lab = lab + wrap(items.join(""), "ul");
5146 app->infoPanel()->addLabel(lab, gb);
5148 gb = app->infoPanel()->addGroup(tr("INFO_GRP_IMPORT_MESH"));
5149 items << wrap("UNV", "li")
5150 << wrap("MED", "li")
5151 << wrap("STL", "li")
5152 << wrap("CGNS", "li")
5153 << wrap("SAUV", "li")
5154 << wrap("GMF", "li");
5155 lab = tr("INFO_AVAILABLE_FORMATS") + ":" + wrap(items.join(""), "ul");
5158 app->infoPanel()->addLabel(lab, gb);
5160 gb = app->infoPanel()->addGroup(tr("INFO_GRP_CHECK_MESH"));
5161 lab = tr("INFO_DISPLAY") + "<br/>";
5162 items << wrap(tr("INFO_QUALITY_AREA"), "li")
5163 << wrap(tr("INFO_QUALITY_VOLUME"), "li")
5164 << wrap(tr("INFO_QUALITY_ASPECT_RATION"), "li")
5165 << wrap("...", "li");
5166 lab = lab + tr("INFO_QUALITY_INFO") + ":" + wrap(items.join(""), "ul");
5168 lab = lab + tr("INFO_CLIPPING");
5170 app->infoPanel()->addLabel(lab, gb);
5173 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5174 PyGILState_STATE gstate = PyGILState_Ensure();
5175 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5176 if ( !pluginsmanager ) {
5180 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5185 PyGILState_Release(gstate);
5186 // end of SMESH plugins loading
5188 // Reset actions accelerator keys
5189 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5191 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5192 GetSMESHGen()->UpdateStudy();
5194 // get all view currently opened in the study and connect their signals to
5195 // the corresponding slots of the class.
5196 SUIT_Desktop* aDesk = study->application()->desktop();
5198 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5199 SUIT_ViewWindow* wnd;
5200 foreach ( wnd, wndList )
5204 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5205 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5211 Py_XDECREF(pluginsmanager);
5215 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5217 setMenuShown( false );
5218 setToolShown( false );
5220 EmitSignalCloseAllDialogs();
5222 // Unset actions accelerator keys
5223 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5225 return SalomeApp_Module::deactivateModule( study );
5228 void SMESHGUI::studyClosed( SUIT_Study* s )
5232 SMESH::RemoveVisuData();
5233 SalomeApp_Module::studyClosed( s );
5236 void SMESHGUI::OnGUIEvent()
5238 const QObject* obj = sender();
5239 if ( !obj || !obj->inherits( "QAction" ) )
5241 int id = actionId((QAction*)obj);
5246 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5248 if ( CORBA::is_nil( myComponentSMESH ) )
5250 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5251 return aGUI.myComponentSMESH;
5253 return myComponentSMESH;
5256 QString SMESHGUI::engineIOR() const
5258 CORBA::ORB_var anORB = getApp()->orb();
5259 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5260 return QString( anIOR.in() );
5263 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5265 SalomeApp_Module::contextMenuPopup( client, menu, title );
5267 selectionMgr()->selectedObjects( lst );
5268 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5269 Handle(SALOME_InteractiveObject) io = lst.First();
5270 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5271 _PTR(Study) study = appStudy->studyDS();
5272 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5274 QString aName = SMESH::fromUtf8( obj->GetName());
5275 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5276 aName.remove(( aName.length() - 1 ), 1 );
5282 LightApp_Selection* SMESHGUI::createSelection() const
5284 return new SMESHGUI_Selection();
5287 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5289 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5290 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5291 aMap.insert( SalomeApp_Application::WT_InfoPanel, Qt::RightDockWidgetArea);
5292 #ifndef DISABLE_PYCONSOLE
5293 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5297 void SMESHGUI::viewManagers( QStringList& list ) const
5299 list.append( SVTK_Viewer::Type() );
5302 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5304 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5305 SMESH::UpdateSelectionProp( this );
5307 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5308 for(int i = 0; i < aViews.count() ; i++){
5309 SUIT_ViewWindow *sf = aViews[i];
5312 EmitSignalActivatedViewManager();
5316 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5318 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5319 myClippingPlaneInfoMap.erase( theViewManager );
5322 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5324 theActor->AddObserver( SMESH::DeleteActorEvent,
5325 myEventCallbackCommand.GetPointer(),
5329 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5330 unsigned long theEvent,
5331 void* theClientData,
5332 void* /*theCallData*/ )
5334 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5335 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5336 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5337 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5338 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5339 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5340 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5341 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5342 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5343 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5344 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5345 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5346 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5347 if( anActor == *anIter3 ) {
5348 anActorList.erase( anIter3 );
5359 void SMESHGUI::createPreferences()
5361 // General tab ------------------------------------------------------------------------
5362 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5364 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5365 setPreferenceProperty( autoUpdate, "columns", 2 );
5366 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5367 setPreferenceProperty( lim, "min", 0 );
5368 setPreferenceProperty( lim, "max", 100000000 );
5369 setPreferenceProperty( lim, "step", 1000 );
5370 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5371 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5373 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5374 setPreferenceProperty( dispgroup, "columns", 2 );
5376 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5378 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5380 modes.append( tr("MEN_WIRE") );
5381 modes.append( tr("MEN_SHADE") );
5382 modes.append( tr("MEN_NODES") );
5383 modes.append( tr("MEN_SHRINK") );
5384 QList<QVariant> indices;
5385 indices.append( 0 );
5386 indices.append( 1 );
5387 indices.append( 2 );
5388 indices.append( 3 );
5389 setPreferenceProperty( dispmode, "strings", modes );
5390 setPreferenceProperty( dispmode, "indexes", indices );
5392 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5393 setPreferenceProperty( arcgroup, "columns", 2 );
5394 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5395 QStringList quadraticModes;
5396 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5397 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5399 indices.append( 0 );
5400 indices.append( 1 );
5401 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5402 setPreferenceProperty( quadraticmode, "indexes", indices );
5404 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5405 "SMESH", "max_angle" );
5406 setPreferenceProperty( maxAngle, "min", 1 );
5407 setPreferenceProperty( maxAngle, "max", 90 );
5409 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5410 setPreferenceProperty( qaGroup, "columns", 2 );
5411 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5412 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5413 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5414 setPreferenceProperty( prec, "min", 0 );
5415 setPreferenceProperty( prec, "max", 100 );
5416 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5417 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5418 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5419 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5420 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5423 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5424 setPreferenceProperty( cinc, "min", 0 );
5425 setPreferenceProperty( cinc, "max", 5 );
5428 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5429 setPreferenceProperty( exportgroup, "columns", 2 );
5430 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5431 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5432 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5433 setPreferenceProperty( zTol, "precision", 10 );
5434 setPreferenceProperty( zTol, "min", 0.0000000001 );
5435 setPreferenceProperty( zTol, "max", 1000000.0 );
5436 setPreferenceProperty( zTol, "step", 1. );
5437 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5439 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5440 setPreferenceProperty( computeGroup, "columns", 2 );
5441 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5443 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5444 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5445 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5447 indices.append( 0 );
5448 indices.append( 1 );
5449 indices.append( 2 );
5450 setPreferenceProperty( notifyMode, "strings", modes );
5451 setPreferenceProperty( notifyMode, "indexes", indices );
5453 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5454 setPreferenceProperty( infoGroup, "columns", 2 );
5455 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5457 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5458 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5460 indices.append( 0 );
5461 indices.append( 1 );
5462 setPreferenceProperty( elemInfo, "strings", modes );
5463 setPreferenceProperty( elemInfo, "indexes", indices );
5464 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5465 setPreferenceProperty( nodesLim, "min", 0 );
5466 setPreferenceProperty( nodesLim, "max", 10000000 );
5467 setPreferenceProperty( nodesLim, "step", 10000 );
5468 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5469 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5470 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5471 setPreferenceProperty( ctrlLim, "min", 0 );
5472 setPreferenceProperty( ctrlLim, "max", 10000000 );
5473 setPreferenceProperty( ctrlLim, "step", 1000 );
5474 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5475 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5476 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5477 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5478 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5480 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5481 setPreferenceProperty( segGroup, "columns", 2 );
5482 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5483 "SMESH", "segmentation" );
5484 setPreferenceProperty( segLen, "min", 1 );
5485 setPreferenceProperty( segLen, "max", 10000000 );
5486 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5487 "SMESH", "nb_segments_per_edge" );
5488 setPreferenceProperty( nbSeg, "min", 1 );
5489 setPreferenceProperty( nbSeg, "max", 10000000 );
5490 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5492 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5493 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5494 "SMESH", "forget_mesh_on_hyp_modif" );
5497 // Quantities with individual precision settings
5498 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5499 setPreferenceProperty( precGroup, "columns", 2 );
5501 const int nbQuantities = 6;
5502 int precs[nbQuantities], ii = 0;
5503 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5504 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5505 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5506 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5507 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5508 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5509 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5510 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5511 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5512 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5513 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5514 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5516 // Set property for precision value for spinboxes
5517 for ( ii = 0; ii < nbQuantities; ii++ ){
5518 setPreferenceProperty( precs[ii], "min", -14 );
5519 setPreferenceProperty( precs[ii], "max", 14 );
5520 setPreferenceProperty( precs[ii], "precision", 2 );
5523 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5524 setPreferenceProperty( previewGroup, "columns", 2 );
5525 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5526 setPreferenceProperty( chunkSize, "min", 1 );
5527 setPreferenceProperty( chunkSize, "max", 1000 );
5528 setPreferenceProperty( chunkSize, "step", 50 );
5530 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5531 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5533 // Mesh tab ------------------------------------------------------------------------
5534 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5535 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5536 setPreferenceProperty( nodeGroup, "columns", 3 );
5538 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5540 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5542 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5543 QList<QVariant> aMarkerTypeIndicesList;
5544 QList<QVariant> aMarkerTypeIconsList;
5545 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5546 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5547 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5548 aMarkerTypeIndicesList << i;
5549 aMarkerTypeIconsList << pixmap;
5551 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5552 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5554 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5556 QList<QVariant> aMarkerScaleIndicesList;
5557 QStringList aMarkerScaleValuesList;
5558 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5559 aMarkerScaleIndicesList << i;
5560 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5561 aMarkerScaleValuesList << QString::number( i );
5563 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5564 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5566 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5567 //setPreferenceProperty( elemGroup, "columns", 2 );
5569 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5570 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5571 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5572 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5573 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5574 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5575 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5576 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5577 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5580 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5581 setPreferenceProperty( grpGroup, "columns", 2 );
5583 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5584 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5586 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5587 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5588 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5589 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5590 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5591 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5592 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5593 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5594 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5595 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5596 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5597 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5598 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5599 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5601 setPreferenceProperty( size0d, "min", 1 );
5602 setPreferenceProperty( size0d, "max", 10 );
5604 // setPreferenceProperty( ballSize, "min", 1 );
5605 // setPreferenceProperty( ballSize, "max", 10 );
5607 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5608 setPreferenceProperty( ballDiameter, "max", 1e9 );
5609 setPreferenceProperty( ballDiameter, "step", 0.1 );
5611 setPreferenceProperty( ballScale, "min", 1e-2 );
5612 setPreferenceProperty( ballScale, "max", 1e7 );
5613 setPreferenceProperty( ballScale, "step", 0.5 );
5615 setPreferenceProperty( elemW, "min", 1 );
5616 setPreferenceProperty( elemW, "max", 5 );
5618 setPreferenceProperty( outW, "min", 1 );
5619 setPreferenceProperty( outW, "max", 5 );
5621 setPreferenceProperty( shrink, "min", 0 );
5622 setPreferenceProperty( shrink, "max", 100 );
5624 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5625 setPreferenceProperty( numGroup, "columns", 2 );
5627 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5628 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5630 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5631 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5633 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5634 setPreferenceProperty( orientGroup, "columns", 1 );
5636 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5637 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5639 setPreferenceProperty( orientScale, "min", 0.05 );
5640 setPreferenceProperty( orientScale, "max", 0.5 );
5641 setPreferenceProperty( orientScale, "step", 0.05 );
5643 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5645 // Selection tab ------------------------------------------------------------------------
5646 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5648 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5649 setPreferenceProperty( selGroup, "columns", 2 );
5651 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5652 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5654 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5655 setPreferenceProperty( preGroup, "columns", 2 );
5657 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5659 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5660 setPreferenceProperty( precSelGroup, "columns", 2 );
5662 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5663 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5664 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5666 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5667 setPreferenceProperty( sinc, "min", 0 );
5668 setPreferenceProperty( sinc, "max", 5 );
5670 // Scalar Bar tab ------------------------------------------------------------------------
5671 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5672 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5673 setPreferenceProperty( fontGr, "columns", 2 );
5675 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5676 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5678 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5679 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5681 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5682 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5684 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5685 setPreferenceProperty( numcol, "min", 2 );
5686 setPreferenceProperty( numcol, "max", 256 );
5688 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5689 setPreferenceProperty( numlab, "min", 2 );
5690 setPreferenceProperty( numlab, "max", 65 );
5692 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5693 setPreferenceProperty( orientGr, "columns", 2 );
5694 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5695 QStringList orients;
5696 orients.append( tr( "SMESH_VERTICAL" ) );
5697 orients.append( tr( "SMESH_HORIZONTAL" ) );
5698 indices.clear(); indices.append( 0 ); indices.append( 1 );
5699 setPreferenceProperty( orient, "strings", orients );
5700 setPreferenceProperty( orient, "indexes", indices );
5702 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5703 setPreferenceProperty( posVSizeGr, "columns", 2 );
5704 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5705 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5706 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5707 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5708 setPreferenceProperty( xv, "step", 0.1 );
5709 setPreferenceProperty( xv, "min", 0.0 );
5710 setPreferenceProperty( xv, "max", 1.0 );
5711 setPreferenceProperty( yv, "step", 0.1 );
5712 setPreferenceProperty( yv, "min", 0.0 );
5713 setPreferenceProperty( yv, "max", 1.0 );
5714 setPreferenceProperty( wv, "step", 0.1 );
5715 setPreferenceProperty( wv, "min", 0.0 );
5716 setPreferenceProperty( wv, "max", 1.0 );
5717 setPreferenceProperty( hv, "min", 0.0 );
5718 setPreferenceProperty( hv, "max", 1.0 );
5719 setPreferenceProperty( hv, "step", 0.1 );
5721 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5722 setPreferenceProperty( posHSizeGr, "columns", 2 );
5723 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5724 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5725 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5726 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5727 setPreferenceProperty( xv, "min", 0.0 );
5728 setPreferenceProperty( xv, "max", 1.0 );
5729 setPreferenceProperty( xv, "step", 0.1 );
5730 setPreferenceProperty( xh, "min", 0.0 );
5731 setPreferenceProperty( xh, "max", 1.0 );
5732 setPreferenceProperty( xh, "step", 0.1 );
5733 setPreferenceProperty( yh, "min", 0.0 );
5734 setPreferenceProperty( yh, "max", 1.0 );
5735 setPreferenceProperty( yh, "step", 0.1 );
5736 setPreferenceProperty( wh, "min", 0.0 );
5737 setPreferenceProperty( wh, "max", 1.0 );
5738 setPreferenceProperty( wh, "step", 0.1 );
5739 setPreferenceProperty( hh, "min", 0.0 );
5740 setPreferenceProperty( hh, "max", 1.0 );
5741 setPreferenceProperty( hh, "step", 0.1 );
5743 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5744 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5745 setPreferenceProperty( distributionGr, "columns", 3 );
5747 types.append( tr( "SMESH_MONOCOLOR" ) );
5748 types.append( tr( "SMESH_MULTICOLOR" ) );
5749 indices.clear(); indices.append( 0 ); indices.append( 1 );
5750 setPreferenceProperty( coloringType, "strings", types );
5751 setPreferenceProperty( coloringType, "indexes", indices );
5752 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5756 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5758 if ( sect=="SMESH" ) {
5759 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5760 float aTol = 1.00000009999999;
5761 std::string aWarning;
5762 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5764 if ( name == "selection_object_color" ||
5765 name == "selection_element_color" ||
5766 name == "highlight_color" ||
5767 name == "selection_precision_node" ||
5768 name == "selection_precision_element" ||
5769 name == "selection_precision_object" ||
5770 name == "selection_increment")
5772 SMESH::UpdateSelectionProp( this );
5774 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5776 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5777 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5778 if ( sbX1+sbW > aTol ) {
5779 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5782 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5783 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5786 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5788 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5789 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5790 if ( sbY1 + sbH > aTol ) {
5791 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5792 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5793 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5796 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5798 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5799 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5800 if ( sbX1 + sbW > aTol ) {
5801 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5804 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5805 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5808 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5810 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5811 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5812 if ( sbY1 + sbH > aTol ) {
5813 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5816 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5817 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5820 else if ( name == "segmentation" )
5822 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5823 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5825 else if ( name == "nb_segments_per_edge" )
5827 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5828 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5830 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5832 QString val = aResourceMgr->stringValue( "SMESH", name );
5833 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5835 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5837 SMESH::UpdateFontProp( this );
5839 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5841 SMESH::UpdateFontProp( this );
5844 if ( aWarning.size() != 0 ) {
5845 aWarning += "The default values are applied instead.";
5846 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5847 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5848 QObject::tr(aWarning.c_str()));
5853 //================================================================================
5855 * \brief Update something in accordance with update flags
5856 * \param theFlags - update flags
5858 * Update viewer or/and object browser etc. in accordance with update flags ( see
5859 * LightApp_UpdateFlags enumeration ).
5861 //================================================================================
5862 void SMESHGUI::update( const int flags )
5864 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5865 SMESH::UpdateView();
5867 SalomeApp_Module::update( flags );
5870 //================================================================================
5872 * \brief Set default selection mode
5874 * SLOT called when operation committed. Sets default selection mode
5876 //================================================================================
5877 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5879 SVTK_ViewWindow* vtkWnd =
5880 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5882 vtkWnd->SetSelectionMode( ActorSelection );
5885 //================================================================================
5887 * \brief Set default selection mode
5889 * SLOT called when operation aborted. Sets default selection mode
5891 //================================================================================
5892 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5894 SVTK_ViewWindow* vtkWnd =
5895 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5897 vtkWnd->SetSelectionMode( ActorSelection );
5900 //================================================================================
5902 * \brief Creates operation with given identifier
5903 * \param id - identifier of operation to be started
5904 * \return Pointer on created operation or NULL if operation is not created
5906 * Virtual method redefined from the base class creates operation with given id.
5907 * It is called called automatically from startOperation method of base class.
5909 //================================================================================
5910 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5912 LightApp_Operation* op = 0;
5913 // to do : create operation here
5916 case SMESHOp::OpSplitBiQuadratic:
5917 op = new SMESHGUI_SplitBiQuadOp();
5919 case SMESHOp::OpConvertMeshToQuadratic:
5920 op = new SMESHGUI_ConvToQuadOp();
5922 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5923 op = new SMESHGUI_Make2DFrom3DOp();
5925 case SMESHOp::OpReorientFaces:
5926 op = new SMESHGUI_ReorientFacesOp();
5928 case SMESHOp::OpCreateMesh:
5929 op = new SMESHGUI_MeshOp( true, true );
5931 case SMESHOp::OpCreateSubMesh:
5932 op = new SMESHGUI_MeshOp( true, false );
5934 case SMESHOp::OpEditMeshOrSubMesh:
5935 case SMESHOp::OpEditMesh:
5936 case SMESHOp::OpEditSubMesh:
5937 op = new SMESHGUI_MeshOp( false );
5939 case SMESHOp::OpCompute:
5940 case SMESHOp::OpComputeSubMesh:
5941 op = new SMESHGUI_ComputeOp();
5943 case SMESHOp::OpShowErrors:
5944 op = new SMESHGUI_ShowErrorsOp();
5946 case SMESHOp::OpPreCompute:
5947 op = new SMESHGUI_PrecomputeOp();
5949 case SMESHOp::OpEvaluate:
5950 op = new SMESHGUI_EvaluateOp();
5952 case SMESHOp::OpMeshOrder:
5953 op = new SMESHGUI_MeshOrderOp();
5955 case SMESHOp::OpCreateGeometryGroup:
5956 op = new SMESHGUI_GroupOnShapeOp();
5958 case SMESHOp::OpFindElementByPoint:
5959 op = new SMESHGUI_FindElemByPointOp();
5961 case SMESHOp::OpMoveNode: // Make mesh pass through point
5962 op = new SMESHGUI_MakeNodeAtPointOp();
5964 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5965 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5972 op = SalomeApp_Module::createOperation( id );
5976 //================================================================================
5978 * \brief Stops current operations and starts a given one
5979 * \param id - The id of the operation to start
5981 //================================================================================
5983 void SMESHGUI::switchToOperation(int id)
5985 activeStudy()->abortAllOperations();
5986 startOperation( id );
5989 LightApp_Displayer* SMESHGUI::displayer()
5992 myDisplayer = new SMESHGUI_Displayer( getApp() );
5996 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5999 int aTolerance = 64;
6000 int anIterations = 0;
6006 if( anIterations % aPeriod == 0 )
6009 if( aTolerance < 1 )
6013 aHue = (int)( 360.0 * rand() / RAND_MAX );
6016 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
6017 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
6018 for( ; it != itEnd; ++it )
6020 SALOMEDS::Color anAutoColor = *it;
6021 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6024 aQColor.getHsv( &h, &s, &v );
6025 if( abs( h - aHue ) < aTolerance )
6037 aColor.setHsv( aHue, 255, 255 );
6039 SALOMEDS::Color aSColor;
6040 aSColor.R = aColor.redF();
6041 aSColor.G = aColor.greenF();
6042 aSColor.B = aColor.blueF();
6047 const char* gSeparator = "_"; // character used to separate parameter names
6048 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6049 const char* gPathSep = "|"; // character used to separate paths
6052 * \brief Store visual parameters
6054 * This method is called just before the study document is saved.
6055 * Store visual parameters in AttributeParameter attribute(s)
6057 void SMESHGUI::storeVisualParameters (int savePoint)
6060 Kernel_Utils::Localizer loc;
6062 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6063 if (!appStudy || !appStudy->studyDS())
6065 _PTR(Study) studyDS = appStudy->studyDS();
6067 // componentName is used for encoding of entries when storing them in IParameters
6068 std::string componentName = myComponentSMESH->ComponentDataType();
6069 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6070 //if (!aSComponent) return;
6073 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6074 componentName.c_str(),
6076 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6078 // store custom markers
6079 if( !myMarkerMap.empty() )
6081 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6082 for( ; anIter != myMarkerMap.end(); anIter++ )
6084 int anId = anIter->first;
6085 VTK::MarkerData aMarkerData = anIter->second;
6086 std::string aMarkerFileName = aMarkerData.first;
6087 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6088 if( aMarkerTexture.size() < 3 )
6089 continue; // should contain at least width, height and the first value
6091 QString aPropertyName( "texture" );
6092 aPropertyName += gSeparator;
6093 aPropertyName += QString::number( anId );
6095 QString aPropertyValue = aMarkerFileName.c_str();
6096 aPropertyValue += gPathSep;
6098 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6099 ushort aWidth = *aTextureIter++;
6100 ushort aHeight = *aTextureIter++;
6101 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6102 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6103 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6104 aPropertyValue += QString::number( *aTextureIter );
6106 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6110 // viewers counters are used for storing view_numbers in IParameters
6113 // main cycle to store parameters of displayed objects
6114 QList<SUIT_ViewManager*> lst;
6115 QList<SUIT_ViewManager*>::Iterator it;
6116 getApp()->viewManagers(lst);
6117 for (it = lst.begin(); it != lst.end(); it++)
6119 SUIT_ViewManager* vman = *it;
6120 QString vType = vman->getType();
6122 // saving VTK actors properties
6123 if (vType == SVTK_Viewer::Type())
6125 // store the clipping planes attached to the view manager
6126 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6127 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6128 if( anIter != myClippingPlaneInfoMap.end() )
6129 aClippingPlaneInfoList = anIter->second;
6131 if( !aClippingPlaneInfoList.empty() ) {
6132 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6133 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6135 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6136 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6138 QString aPropertyName( "ClippingPlane" );
6139 aPropertyName += gSeparator;
6140 aPropertyName += QString::number( vtkViewers );
6141 aPropertyName += gSeparator;
6142 aPropertyName += QString::number( anId );
6144 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6145 aPropertyValue += gDigitsSep;
6146 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6147 aPropertyValue += gDigitsSep;
6148 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6149 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6150 aPropertyValue += gDigitsSep;
6151 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6152 aPropertyValue += gDigitsSep;
6153 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6154 aPropertyValue += gDigitsSep;
6155 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6156 aPropertyValue += gDigitsSep;
6157 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6158 aPropertyValue += gDigitsSep;
6159 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6160 aPropertyValue += gDigitsSep;
6161 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6163 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6164 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6165 aPropertyValue += gDigitsSep;
6166 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6167 aPropertyValue += gDigitsSep;
6168 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6169 aPropertyValue += gDigitsSep;
6170 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6173 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6177 QVector<SUIT_ViewWindow*> views = vman->getViews();
6178 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6180 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6182 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6183 vtkActorCollection* allActors = aCopy.GetActors();
6184 allActors->InitTraversal();
6185 while (vtkActor* actor = allActors->GetNextActor())
6187 if (actor->GetVisibility()) // store only visible actors
6189 SMESH_Actor* aSmeshActor = 0;
6190 if (actor->IsA("SMESH_Actor"))
6191 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6192 if (aSmeshActor && aSmeshActor->hasIO())
6194 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6197 // entry is "encoded" = it does NOT contain component address,
6198 // since it is a subject to change on next component loading
6199 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6201 std::string param, vtkParam = vType.toLatin1().data();
6202 vtkParam += gSeparator;
6203 vtkParam += QString::number(vtkViewers).toLatin1().data();
6204 vtkParam += gSeparator;
6207 param = vtkParam + "Visibility";
6208 ip->setParameter(entry, param, "On");
6211 param = vtkParam + "Representation";
6212 ip->setParameter(entry, param, QString::number
6213 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6216 param = vtkParam + "IsShrunk";
6217 ip->setParameter(entry, param, QString::number
6218 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6220 // Displayed entities
6221 unsigned int aMode = aSmeshActor->GetEntityMode();
6222 bool isE = aMode & SMESH_Actor::eEdges;
6223 bool isF = aMode & SMESH_Actor::eFaces;
6224 bool isV = aMode & SMESH_Actor::eVolumes;
6225 bool is0d = aMode & SMESH_Actor::e0DElements;
6226 bool isB = aMode & SMESH_Actor::eBallElem;
6228 QString modeStr ("e");
6229 modeStr += gDigitsSep; modeStr += QString::number(isE);
6230 modeStr += gDigitsSep; modeStr += "f";
6231 modeStr += gDigitsSep; modeStr += QString::number(isF);
6232 modeStr += gDigitsSep; modeStr += "v";
6233 modeStr += gDigitsSep; modeStr += QString::number(isV);
6234 modeStr += gDigitsSep; modeStr += "0d";
6235 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6236 modeStr += gDigitsSep; modeStr += "b";
6237 modeStr += gDigitsSep; modeStr += QString::number(isB);
6239 param = vtkParam + "Entities";
6240 ip->setParameter(entry, param, modeStr.toLatin1().data());
6246 aSmeshActor->GetSufaceColor(r, g, b, delta);
6247 QStringList colorStr;
6248 colorStr << "surface";
6249 colorStr << QString::number(r);
6250 colorStr << QString::number(g);
6251 colorStr << QString::number(b);
6253 colorStr << "backsurface";
6254 colorStr << QString::number(delta);
6256 aSmeshActor->GetVolumeColor(r, g, b, delta);
6257 colorStr << "volume";
6258 colorStr << QString::number(r);
6259 colorStr << QString::number(g);
6260 colorStr << QString::number(b);
6261 colorStr << QString::number(delta);
6263 aSmeshActor->GetEdgeColor(r, g, b);
6265 colorStr << QString::number(r);
6266 colorStr << QString::number(g);
6267 colorStr << QString::number(b);
6269 aSmeshActor->GetNodeColor(r, g, b);
6271 colorStr << QString::number(r);
6272 colorStr << QString::number(g);
6273 colorStr << QString::number(b);
6275 aSmeshActor->GetOutlineColor(r, g, b);
6276 colorStr << "outline";
6277 colorStr << QString::number(r);
6278 colorStr << QString::number(g);
6279 colorStr << QString::number(b);
6281 aSmeshActor->Get0DColor(r, g, b);
6282 colorStr << "elem0d";
6283 colorStr << QString::number(r);
6284 colorStr << QString::number(g);
6285 colorStr << QString::number(b);
6287 aSmeshActor->GetBallColor(r, g, b);
6289 colorStr << QString::number(r);
6290 colorStr << QString::number(g);
6291 colorStr << QString::number(b);
6293 aSmeshActor->GetFacesOrientationColor(r, g, b);
6294 colorStr << "orientation";
6295 colorStr << QString::number(r);
6296 colorStr << QString::number(g);
6297 colorStr << QString::number(b);
6299 param = vtkParam + "Colors";
6300 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6303 QStringList sizeStr;
6305 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6306 sizeStr << "outline";
6307 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6308 sizeStr << "elem0d";
6309 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6311 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6312 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6313 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6314 sizeStr << "shrink";
6315 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6316 sizeStr << "orientation";
6317 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6318 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6320 param = vtkParam + "Sizes";
6321 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6326 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6327 if( aMarkerType == VTK::MT_USER ) {
6328 markerStr += "custom";
6329 markerStr += gDigitsSep;
6330 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6334 markerStr += gDigitsSep;
6335 markerStr += QString::number( (int)aMarkerType );
6336 markerStr += gDigitsSep;
6337 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6340 param = vtkParam + "PointMarker";
6341 ip->setParameter(entry, param, markerStr.toLatin1().data());
6344 param = vtkParam + "Opacity";
6345 ip->setParameter(entry, param,
6346 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6349 param = vtkParam + "ClippingPlane";
6351 if( !aClippingPlaneInfoList.empty() ) {
6352 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6353 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6355 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6356 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6357 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6358 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6359 if( aSmeshActor == *anIter2 ) {
6360 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6361 QString::number( anId ).toLatin1().constData() );
6368 ip->setParameter( entry, param, "Off" );
6369 } // if (io->hasEntry())
6370 } // SMESH_Actor && hasIO
6372 } // while.. actors traversal
6376 } // if (SVTK view model)
6377 } // for (viewManagers)
6380 // data structures for clipping planes processing
6384 bool isOpenGLClipping;
6385 vtkIdType RelativeOrientation;
6388 int AbsoluteOrientation;
6389 double X, Y, Z, Dx, Dy, Dz;
6391 typedef std::list<TPlaneData> TPlaneDataList;
6392 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6394 typedef std::list<vtkActor*> TActorList;
6397 TActorList ActorList;
6398 SUIT_ViewManager* ViewManager;
6400 typedef std::list<TPlaneInfo> TPlaneInfoList;
6401 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6404 * \brief Restore visual parameters
6406 * This method is called after the study document is opened.
6407 * Restore visual parameters from AttributeParameter attribute(s)
6409 void SMESHGUI::restoreVisualParameters (int savePoint)
6412 Kernel_Utils::Localizer loc;
6414 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6415 if (!appStudy || !appStudy->studyDS())
6417 _PTR(Study) studyDS = appStudy->studyDS();
6419 // componentName is used for encoding of entries when storing them in IParameters
6420 std::string componentName = myComponentSMESH->ComponentDataType();
6423 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6424 componentName.c_str(),
6426 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6428 // restore custom markers and map of clipping planes
6429 TPlaneDataMap aPlaneDataMap;
6431 std::vector<std::string> properties = ip->getProperties();
6432 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6434 std::string property = *propIt;
6435 QString aPropertyName( property.c_str() );
6436 QString aPropertyValue( ip->getProperty( property ).c_str() );
6438 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6439 if( aPropertyNameList.isEmpty() )
6442 QString aPropertyType = aPropertyNameList[0];
6443 if( aPropertyType == "texture" )
6445 if( aPropertyNameList.size() != 2 )
6449 int anId = aPropertyNameList[1].toInt( &ok );
6450 if( !ok || anId < 1 )
6453 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6454 if( aPropertyValueList.size() != 2 )
6457 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6458 QString aMarkerTextureString = aPropertyValueList[1];
6459 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6460 if( aMarkerTextureStringList.size() != 3 )
6464 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6469 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6473 VTK::MarkerTexture aMarkerTexture;
6474 aMarkerTexture.push_back( aWidth );
6475 aMarkerTexture.push_back( aHeight );
6477 QString aMarkerTextureData = aMarkerTextureStringList[2];
6478 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6480 QChar aChar = aMarkerTextureData.at( i );
6481 if( aChar.isDigit() )
6482 aMarkerTexture.push_back( aChar.digitValue() );
6485 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6487 else if( aPropertyType == "ClippingPlane" )
6489 if( aPropertyNameList.size() != 3 )
6493 int aViewId = aPropertyNameList[1].toInt( &ok );
6494 if( !ok || aViewId < 0 )
6498 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6499 if( !ok || aClippingPlaneId < 0 )
6502 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6503 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6506 TPlaneData aPlaneData;
6507 aPlaneData.AbsoluteOrientation = false;
6508 aPlaneData.RelativeOrientation = 0;
6509 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6510 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6511 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6513 aPlaneData.Id = aClippingPlaneId;
6516 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6521 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6525 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6528 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6533 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6538 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6543 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6548 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6553 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6558 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6562 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6564 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6569 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6574 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6579 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6584 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6585 aPlaneDataList.push_back( aPlaneData );
6589 TPlaneInfoMap aPlaneInfoMap;
6591 std::vector<std::string> entries = ip->getEntries();
6593 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6595 // entry is a normal entry - it should be "decoded" (setting base address of component)
6596 QString entry (ip->decodeEntry(*entIt).c_str());
6598 // Check that the entry corresponds to a real object in the Study
6599 // as the object may be deleted or modified after the visual state is saved.
6600 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6601 if (!so) continue; //Skip the not existent entry
6603 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6604 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6606 std::vector<std::string>::iterator namesIt = paramNames.begin();
6607 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6609 // actors are stored in a map after displaying of them for
6610 // quicker access in the future: map < viewID to actor >
6611 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6613 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6615 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6616 // '_' is used as separator and should not be used in viewer type or parameter names.
6617 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6618 if (lst.size() != 3)
6621 QString viewerTypStr = lst[0];
6622 QString viewIndexStr = lst[1];
6623 QString paramNameStr = lst[2];
6626 int viewIndex = viewIndexStr.toUInt(&ok);
6627 if (!ok) // bad conversion of view index to integer
6631 if (viewerTypStr == SVTK_Viewer::Type())
6633 SMESH_Actor* aSmeshActor = 0;
6634 if (vtkActors.IsBound(viewIndex))
6635 aSmeshActor = vtkActors.Find(viewIndex);
6637 QList<SUIT_ViewManager*> lst;
6638 getApp()->viewManagers(viewerTypStr, lst);
6640 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6641 SUIT_ViewManager* vman = NULL;
6642 if (viewIndex >= 0 && viewIndex < lst.count())
6643 vman = lst.at(viewIndex);
6645 if (paramNameStr == "Visibility")
6647 if (!aSmeshActor && displayer() && vman)
6649 SUIT_ViewModel* vmodel = vman->getViewModel();
6650 // SVTK view model can be casted to SALOME_View
6651 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6653 // store displayed actor in a temporary map for quicker
6654 // access later when restoring other parameters
6655 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6656 vtkRenderer* Renderer = vtkView->getRenderer();
6657 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6658 vtkActorCollection* theActors = aCopy.GetActors();
6659 theActors->InitTraversal();
6660 bool isFound = false;
6661 vtkActor *ac = theActors->GetNextActor();
6662 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6663 if (ac->IsA("SMESH_Actor")) {
6664 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6665 if (aGeomAc->hasIO()) {
6666 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6667 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6669 vtkActors.Bind(viewIndex, aGeomAc);
6675 } // if (paramNameStr == "Visibility")
6678 // the rest properties "work" with SMESH_Actor
6681 QString val ((*valuesIt).c_str());
6684 if (paramNameStr == "Representation") {
6685 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6688 else if (paramNameStr == "IsShrunk") {
6690 if (!aSmeshActor->IsShrunk())
6691 aSmeshActor->SetShrink();
6694 if (aSmeshActor->IsShrunk())
6695 aSmeshActor->UnShrink();
6698 // Displayed entities
6699 else if (paramNameStr == "Entities") {
6700 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6701 int aEntityMode = SMESH_Actor::eAllEntity;
6702 for ( int i = 0; i < mode.count(); i+=2 ) {
6703 if ( i < mode.count()-1 ) {
6704 QString type = mode[i];
6705 bool val = mode[i+1].toInt();
6706 if ( type == "e" && !val )
6707 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6708 else if ( type == "f" && !val )
6709 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6710 else if ( type == "v" && !val )
6711 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6712 else if ( type == "0d" && !val )
6713 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6714 else if ( type == "b" && !val )
6715 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6718 aSmeshActor->SetEntityMode( aEntityMode );
6721 else if (paramNameStr == "Colors") {
6722 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6729 QColor outlineColor;
6730 QColor orientationColor;
6736 // below lines are required to get default values for delta coefficients
6737 // of backface color for faces and color of reversed volumes
6738 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6739 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6740 for ( int i = 0; i < colors.count(); i++ ) {
6741 QString type = colors[i];
6742 if ( type == "surface" ) {
6743 // face color is set by 3 values r:g:b, where
6744 // - r,g,b - is rgb color components
6745 if ( i+1 >= colors.count() ) break; // format error
6746 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6747 if ( i+2 >= colors.count() ) break; // format error
6748 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6749 if ( i+3 >= colors.count() ) break; // format error
6750 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6751 faceColor.setRgbF( r, g, b );
6754 else if ( type == "backsurface" ) {
6755 // backface color can be defined in several ways
6756 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6757 // - in latest versions, it is set as delta coefficient
6758 bool rgbOk = false, deltaOk;
6759 if ( i+1 >= colors.count() ) break; // format error
6760 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6761 int delta = colors[i+1].toInt( &deltaOk );
6763 if ( i+1 < colors.count() ) // index is shifted to 1
6764 g = colors[i+1].toDouble( &rgbOk );
6765 if ( rgbOk ) i++; // shift index
6766 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6767 b = colors[i+1].toDouble( &rgbOk );
6769 // - as currently there's no way to set directly backsurface color as it was before,
6770 // we ignore old dump where r,g,b triple was set
6771 // - also we check that delta parameter is set properly
6772 if ( !rgbOk && deltaOk )
6775 else if ( type == "volume" ) {
6776 // volume color is set by 4 values r:g:b:delta, where
6777 // - r,g,b - is a normal volume rgb color components
6778 // - delta - is a reversed volume color delta coefficient
6779 if ( i+1 >= colors.count() ) break; // format error
6780 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6781 if ( i+2 >= colors.count() ) break; // format error
6782 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6783 if ( i+3 >= colors.count() ) break; // format error
6784 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6785 if ( i+4 >= colors.count() ) break; // format error
6786 int delta = colors[i+4].toInt( &bOk );
6787 if ( !bOk ) break; // format error
6788 volumeColor.setRgbF( r, g, b );
6792 else if ( type == "edge" ) {
6793 // edge color is set by 3 values r:g:b, where
6794 // - r,g,b - is rgb color components
6795 if ( i+1 >= colors.count() ) break; // format error
6796 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6797 if ( i+2 >= colors.count() ) break; // format error
6798 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6799 if ( i+3 >= colors.count() ) break; // format error
6800 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6801 edgeColor.setRgbF( r, g, b );
6804 else if ( type == "node" ) {
6805 // node color is set by 3 values r:g:b, where
6806 // - r,g,b - is rgb color components
6807 if ( i+1 >= colors.count() ) break; // format error
6808 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6809 if ( i+2 >= colors.count() ) break; // format error
6810 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6811 if ( i+3 >= colors.count() ) break; // format error
6812 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6813 nodeColor.setRgbF( r, g, b );
6816 else if ( type == "elem0d" ) {
6817 // 0d element color is set by 3 values r:g:b, where
6818 // - r,g,b - is rgb color components
6819 if ( i+1 >= colors.count() ) break; // format error
6820 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6821 if ( i+2 >= colors.count() ) break; // format error
6822 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6823 if ( i+3 >= colors.count() ) break; // format error
6824 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6825 elem0dColor.setRgbF( r, g, b );
6828 else if ( type == "ball" ) {
6829 // ball color is set by 3 values r:g:b, where
6830 // - r,g,b - is rgb color components
6831 if ( i+1 >= colors.count() ) break; // format error
6832 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6833 if ( i+2 >= colors.count() ) break; // format error
6834 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6835 if ( i+3 >= colors.count() ) break; // format error
6836 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6837 ballColor.setRgbF( r, g, b );
6840 else if ( type == "outline" ) {
6841 // outline color is set by 3 values r:g:b, where
6842 // - r,g,b - is rgb color components
6843 if ( i+1 >= colors.count() ) break; // format error
6844 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6845 if ( i+2 >= colors.count() ) break; // format error
6846 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6847 if ( i+3 >= colors.count() ) break; // format error
6848 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6849 outlineColor.setRgbF( r, g, b );
6852 else if ( type == "orientation" ) {
6853 // orientation color is set by 3 values r:g:b, where
6854 // - r,g,b - is rgb color components
6855 if ( i+1 >= colors.count() ) break; // format error
6856 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6857 if ( i+2 >= colors.count() ) break; // format error
6858 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6859 if ( i+3 >= colors.count() ) break; // format error
6860 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6861 orientationColor.setRgbF( r, g, b );
6866 if ( nodeColor.isValid() )
6867 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6869 if ( edgeColor.isValid() )
6870 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6872 if ( faceColor.isValid() )
6873 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6875 if ( volumeColor.isValid() )
6876 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6877 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6878 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6880 if ( elem0dColor.isValid() )
6881 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6883 if ( ballColor.isValid() )
6884 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6886 if ( outlineColor.isValid() )
6887 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6888 // orientation color
6889 if ( orientationColor.isValid() )
6890 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6893 else if (paramNameStr == "Sizes") {
6894 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6897 int outlineWidth = -1;
6898 int elem0dSize = -1;
6899 //int ballSize = -1;
6900 double ballDiameter = -1.0;
6901 double ballScale = -1.0;
6902 double shrinkSize = -1;
6903 double orientationSize = -1;
6904 bool orientation3d = false;
6905 for ( int i = 0; i < sizes.count(); i++ ) {
6906 QString type = sizes[i];
6907 if ( type == "line" ) {
6908 // line (wireframe) width is given as single integer value
6909 if ( i+1 >= sizes.count() ) break; // format error
6910 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6914 if ( type == "outline" ) {
6915 // outline width is given as single integer value
6916 if ( i+1 >= sizes.count() ) break; // format error
6917 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6921 else if ( type == "elem0d" ) {
6922 // 0d element size is given as single integer value
6923 if ( i+1 >= sizes.count() ) break; // format error
6924 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6928 else if ( type == "ball" ) {
6929 // balls are specified by two values: size:scale, where
6930 // - size - is a integer value specifying size
6931 // - scale - is a double value specifying scale factor
6932 if ( i+1 >= sizes.count() ) break; // format error
6933 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6934 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6935 if ( i+2 >= sizes.count() ) break; // format error
6936 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6942 else if ( type == "shrink" ) {
6943 // shrink factor is given as single floating point value
6944 if ( i+1 >= sizes.count() ) break; // format error
6945 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6949 else if ( type == "orientation" ) {
6950 // orientation vectors are specified by two values size:3d, where
6951 // - size - is a floating point value specifying scale factor
6952 // - 3d - is a boolean
6953 if ( i+1 >= sizes.count() ) break; // format error
6954 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6955 if ( i+2 >= sizes.count() ) break; // format error
6956 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6957 orientationSize = v1;
6958 orientation3d = (bool)v2;
6962 // line (wireframe) width
6963 if ( lineWidth > 0 )
6964 aSmeshActor->SetLineWidth( lineWidth );
6966 if ( outlineWidth > 0 )
6967 aSmeshActor->SetOutlineWidth( outlineWidth );
6968 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6969 aSmeshActor->SetOutlineWidth( lineWidth );
6971 if ( elem0dSize > 0 )
6972 aSmeshActor->Set0DSize( elem0dSize );
6974 /*if ( ballSize > 0 )
6975 aSmeshActor->SetBallSize( ballSize );*/
6977 if ( ballDiameter > 0 )
6978 aSmeshActor->SetBallSize( ballDiameter );
6980 if ( ballScale > 0.0 )
6981 aSmeshActor->SetBallScale( ballScale );
6983 if ( shrinkSize > 0 )
6984 aSmeshActor->SetShrinkFactor( shrinkSize );
6985 // orientation vectors
6986 if ( orientationSize > 0 ) {
6987 aSmeshActor->SetFacesOrientationScale( orientationSize );
6988 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6992 else if (paramNameStr == "PointMarker") {
6993 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6994 if( data.count() >= 2 ) {
6996 int aParam1 = data[1].toInt( &ok );
6998 if( data[0] == "std" && data.count() == 3 ) {
6999 int aParam2 = data[2].toInt( &ok );
7000 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
7002 else if( data[0] == "custom" ) {
7003 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
7004 if( markerIt != myMarkerMap.end() ) {
7005 VTK::MarkerData aMarkerData = markerIt->second;
7006 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
7013 else if (paramNameStr == "Opacity") {
7014 aSmeshActor->SetOpacity(val.toFloat());
7017 else if (paramNameStr.startsWith("ClippingPlane")) {
7018 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
7019 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
7020 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
7021 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
7022 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7023 // new format - val looks like "Off" or "0" (plane id)
7024 // (note: in new format "Off" value is used only for consistency,
7025 // so it is processed together with values in old format)
7026 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7027 if( anIsOldFormat ) {
7028 if (paramNameStr == "ClippingPlane1" || val == "Off")
7029 aSmeshActor->RemoveAllClippingPlanes();
7031 QList<SUIT_ViewManager*> lst;
7032 getApp()->viewManagers(viewerTypStr, lst);
7033 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7034 if (viewIndex >= 0 && viewIndex < lst.count()) {
7035 SUIT_ViewManager* vman = lst.at(viewIndex);
7036 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7038 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7040 SMESH::TActorList anActorList;
7041 anActorList.push_back( aSmeshActor );
7042 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7043 aPlane->myViewWindow = vtkView;
7044 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7045 aPlane->PlaneMode = aMode;
7046 bool isOpenGLClipping = ( bool )vals[1].toInt();
7047 aPlane->IsOpenGLClipping = isOpenGLClipping;
7048 if ( aMode == SMESH::Absolute ) {
7049 aPlane->myAbsoluteOrientation = vals[2].toInt();
7050 aPlane->X = vals[3].toFloat();
7051 aPlane->Y = vals[4].toFloat();
7052 aPlane->Z = vals[5].toFloat();
7053 aPlane->Dx = vals[6].toFloat();
7054 aPlane->Dy = vals[7].toFloat();
7055 aPlane->Dz = vals[8].toFloat();
7057 else if ( aMode == SMESH::Relative ) {
7058 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7059 aPlane->myDistance = vals[3].toFloat();
7060 aPlane->myAngle[0] = vals[4].toFloat();
7061 aPlane->myAngle[1] = vals[5].toFloat();
7065 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7066 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7067 aClippingPlaneInfo.Plane = aPlane;
7068 aClippingPlaneInfo.ActorList = anActorList;
7069 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7077 int aPlaneId = val.toInt( &ok );
7078 if( ok && aPlaneId >= 0 ) {
7079 bool anIsDefinedPlane = false;
7080 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7081 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7082 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7083 TPlaneInfo& aPlaneInfo = *anIter;
7084 if( aPlaneInfo.PlaneId == aPlaneId ) {
7085 aPlaneInfo.ActorList.push_back( aSmeshActor );
7086 anIsDefinedPlane = true;
7090 if( !anIsDefinedPlane ) {
7091 TPlaneInfo aPlaneInfo;
7092 aPlaneInfo.PlaneId = aPlaneId;
7093 aPlaneInfo.ActorList.push_back( aSmeshActor );
7094 aPlaneInfo.ViewManager = vman;
7096 // to make the list sorted by plane id
7097 anIter = aPlaneInfoList.begin();
7098 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7099 const TPlaneInfo& aPlaneInfoRef = *anIter;
7100 if( aPlaneInfoRef.PlaneId > aPlaneId )
7103 aPlaneInfoList.insert( anIter, aPlaneInfo );
7108 } // if (aSmeshActor)
7109 } // other parameters than Visibility
7111 } // for names/parameters iterator
7112 } // for entries iterator
7114 // take into account planes with empty list of actors referred to them
7115 QList<SUIT_ViewManager*> aVMList;
7116 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7118 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7119 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7120 int aViewId = aPlaneDataIter->first;
7121 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7122 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7124 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7126 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7127 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7128 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7129 const TPlaneData& aPlaneData = *anIter2;
7130 int aPlaneId = aPlaneData.Id;
7132 bool anIsFound = false;
7133 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7134 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7135 const TPlaneInfo& aPlaneInfo = *anIter3;
7136 if( aPlaneInfo.PlaneId == aPlaneId ) {
7143 TPlaneInfo aPlaneInfo; // ActorList field is empty
7144 aPlaneInfo.PlaneId = aPlaneId;
7145 aPlaneInfo.ViewManager = aViewManager;
7147 // to make the list sorted by plane id
7148 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7149 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7150 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7151 if( aPlaneInfoRef.PlaneId > aPlaneId )
7154 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7160 // add clipping planes to actors according to the restored parameters
7161 // and update the clipping plane map
7162 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7163 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7164 int aViewId = anIter1->first;
7165 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7167 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7168 if( anIter2 == aPlaneDataMap.end() )
7170 const TPlaneDataList& aPlaneDataList = anIter2->second;
7172 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7173 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7174 const TPlaneInfo& aPlaneInfo = *anIter3;
7175 int aPlaneId = aPlaneInfo.PlaneId;
7176 const TActorList& anActorList = aPlaneInfo.ActorList;
7177 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7181 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7185 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7187 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7188 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7189 const TPlaneData& aPlaneData = *anIter4;
7190 if( aPlaneData.Id == aPlaneId ) {
7191 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7192 aPlane->myViewWindow = aViewWindow;
7193 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7194 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7195 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7196 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7197 aPlane->X = aPlaneData.X;
7198 aPlane->Y = aPlaneData.Y;
7199 aPlane->Z = aPlaneData.Z;
7200 aPlane->Dx = aPlaneData.Dx;
7201 aPlane->Dy = aPlaneData.Dy;
7202 aPlane->Dz = aPlaneData.Dz;
7204 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7205 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7206 aPlane->myDistance = aPlaneData.Distance;
7207 aPlane->myAngle[0] = aPlaneData.Angle[0];
7208 aPlane->myAngle[1] = aPlaneData.Angle[1];
7211 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7212 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7213 aClippingPlaneInfo.Plane = aPlane;
7214 aClippingPlaneInfo.ActorList = anActorList;
7215 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7226 // update all VTK views
7227 QList<SUIT_ViewManager*> lst;
7228 getApp()->viewManagers(lst);
7229 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7230 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7231 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7232 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7233 // set OpenGL clipping planes
7234 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7235 vtkActorCollection* anAllActors = aCopy.GetActors();
7236 anAllActors->InitTraversal();
7237 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7238 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7239 anActor->SetOpenGLClippingPlane();
7241 vtkView->getRenderer()->ResetCameraClippingRange();
7248 \brief Adds preferences for dfont of VTK viewer
7250 \param pIf group identifier
7251 \param param parameter
7252 \return identifier of preferences
7254 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7256 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7258 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7261 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7262 fam.append( tr( "SMESH_FONT_COURIER" ) );
7263 fam.append( tr( "SMESH_FONT_TIMES" ) );
7265 setPreferenceProperty( tfont, "fonts", fam );
7267 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7268 if ( needSize ) f = f | QtxFontEdit::Size;
7269 setPreferenceProperty( tfont, "features", f );
7275 \brief Actions after hypothesis edition
7276 Updates object browser after hypothesis edition
7278 void SMESHGUI::onHypothesisEdit( int result )
7281 SMESHGUI::Modified();
7282 updateObjBrowser( true );
7286 \brief Actions after choosing menu of control modes
7287 Updates control mode actions according to current selection
7289 void SMESHGUI::onUpdateControlActions()
7291 SALOME_ListIO selected;
7292 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7293 aSel->selectedObjects( selected );
7295 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7296 if ( selected.Extent() ) {
7297 if ( selected.First()->hasEntry() ) {
7298 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7299 aControl = anActor->GetControlMode();
7300 SALOME_ListIteratorOfListIO it(selected);
7301 for ( it.Next(); it.More(); it.Next() ) {
7302 Handle(SALOME_InteractiveObject) anIO = it.Value();
7303 if ( anIO->hasEntry() ) {
7304 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7305 if ( aControl != anActor->GetControlMode() ) {
7306 aControl = SMESH_Actor::eNone;
7316 int anAction = ActionToControl( aControl, true );
7318 action( anAction )->setChecked( true );
7320 QMenu* send = (QMenu*)sender();
7321 QList<QAction*> actions = send->actions();
7322 for ( int i = 0; i < actions.size(); i++ )
7323 actions[i]->setChecked( false );
7329 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7330 \param pview view being closed
7332 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7333 #ifndef DISABLE_PLOT2DVIEWER
7334 //Crear all Plot2d Viewers if need.
7335 SMESH::ClearPlot2Viewers(pview);
7337 EmitSignalCloseView();
7340 void SMESHGUI::message( const QString& msg )
7343 QStringList data = msg.split("/");
7344 if ( data.count() > 0 ) {
7345 if ( data.first() == "mesh_loading" ) {
7347 QString entry = data.count() > 1 ? data[1] : QString();
7348 if ( entry.isEmpty() )
7351 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7353 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7356 name = SMESH::fromUtf8(obj->GetName());
7357 if ( name.isEmpty() )
7360 if ( data.last() == "stop" )
7361 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7363 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7364 QApplication::processEvents();
7370 \brief Connects or disconnects signals about activating and cloning view on the module slots
7371 \param pview view which is connected/disconnected
7373 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7377 SUIT_ViewManager* viewMgr = pview->getViewManager();
7379 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7380 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7382 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7383 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7388 \brief Return \c true if object can be renamed
7390 bool SMESHGUI::renameAllowed( const QString& entry) const {
7391 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7395 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7399 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7404 if(appStudy->isComponent(entry) || obj->isReference())
7407 // check type to prevent renaming of inappropriate objects
7408 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7409 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7410 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7411 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7412 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7413 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7420 Rename object by entry.
7421 \param entry entry of the object
7422 \param name new name of the object
7423 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7425 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7427 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7431 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7436 _PTR(Study) aStudy = appStudy->studyDS();
7441 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7443 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7448 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7449 _PTR(GenericAttribute) anAttr;
7450 _PTR(AttributeName) aName;
7452 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7454 // check type to prevent renaming of inappropriate objects
7455 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7456 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7457 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7458 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7459 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7460 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7461 if ( !name.isEmpty() ) {
7462 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7464 // update name of group object and its actor
7465 Handle(SALOME_InteractiveObject) IObject =
7466 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7468 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7469 if( !aGroupObject->_is_nil() ) {
7470 aGroupObject->SetName( qUtf8Printable(name) );
7471 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7472 anActor->setName( qUtf8Printable(name) );
7482 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7484 static QList<QColor> colors;
7486 if ( colors.isEmpty() ) {
7488 for (int s = 0; s < 2 ; s++)
7490 for (int v = 100; v >= 40; v = v - 20)
7492 for (int h = 0; h < 359 ; h = h + 60)
7494 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7499 static int currentColor = randomize( colors.size() );
7501 SALOMEDS::Color color;
7502 color.R = (double)colors[currentColor].red() / 255.0;
7503 color.G = (double)colors[currentColor].green() / 255.0;
7504 color.B = (double)colors[currentColor].blue() / 255.0;
7506 currentColor = (currentColor+1) % colors.count();