1 // Copyright (C) 2007-2021 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_MG_ADAPTDRIVER.h"
64 #include "SMESHGUI_HomardAdaptDlg.h"
65 #include "SMESHGUI_Make2DFrom3DOp.h"
66 #include "SMESHGUI_MakeNodeAtPointDlg.h"
67 #include "SMESHGUI_Measurements.h"
68 #include "SMESHGUI_MergeDlg.h"
69 #include "SMESHGUI_MeshInfo.h"
70 #include "SMESHGUI_MeshOp.h"
71 #include "SMESHGUI_MeshOrderOp.h"
72 #include "SMESHGUI_MeshPatternDlg.h"
73 #include "SMESHGUI_MeshUtils.h"
74 #include "SMESHGUI_MultiEditDlg.h"
75 #include "SMESHGUI_NodesDlg.h"
76 #include "SMESHGUI_OffsetDlg.h"
77 #include "SMESHGUI_Operations.h"
78 #include "SMESHGUI_PatternUtils.h"
79 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
80 #include "SMESHGUI_PropertiesDlg.h"
81 #include "SMESHGUI_RemoveElementsDlg.h"
82 #include "SMESHGUI_RemoveNodesDlg.h"
83 #include "SMESHGUI_RenumberingDlg.h"
84 #include "SMESHGUI_ReorientFacesDlg.h"
85 #include "SMESHGUI_RevolutionDlg.h"
86 #include "SMESHGUI_RotationDlg.h"
87 #include "SMESHGUI_ScaleDlg.h"
88 #include "SMESHGUI_Selection.h"
89 #include "SMESHGUI_SewingDlg.h"
90 #include "SMESHGUI_SingleEditDlg.h"
91 #include "SMESHGUI_SmoothingDlg.h"
92 #include "SMESHGUI_SpinBox.h"
93 #include "SMESHGUI_SplitBiQuad.h"
94 #include "SMESHGUI_SymmetryDlg.h"
95 #include "SMESHGUI_TranslationDlg.h"
96 #include "SMESHGUI_TransparencyDlg.h"
97 #include "SMESHGUI_Utils.h"
98 #include "SMESHGUI_VTKUtils.h"
100 #include "SMESH_version.h"
102 #include "SMESH_Actor.h"
103 #include "SMESH_ActorUtils.h"
104 #include "SMESH_Client.hxx"
105 #include "SMESH_Comment.hxx"
106 #include "SMESH_ControlsDef.hxx"
107 #include "SMESH_ScalarBarActor.h"
108 #include "SMESH_TypeFilter.hxx"
109 #include "SMESH_Component_Generator.hxx"
111 // SALOME GUI includes
112 #include <LightApp_DataOwner.h>
113 #include <LightApp_NameDlg.h>
114 #include <LightApp_Preferences.h>
115 #include <LightApp_SelectionMgr.h>
116 #include <LightApp_UpdateFlags.h>
117 #include <QtxFontEdit.h>
118 #include <QtxPopupMgr.h>
119 #include <QtxInfoPanel.h>
120 #include <SALOME_ListIO.hxx>
121 #include <SUIT_Desktop.h>
122 #include <SUIT_FileDlg.h>
123 #include <SUIT_MessageBox.h>
124 #include <SUIT_OverrideCursor.h>
125 #include <SUIT_ResourceMgr.h>
126 #include <SUIT_Session.h>
127 #include <SVTK_Renderer.h>
128 #include <SVTK_ViewManager.h>
129 #include <SVTK_ViewModel.h>
130 #include <SVTK_ViewWindow.h>
131 #include <SalomeApp_Application.h>
132 #include <SalomeApp_CheckFileDlg.h>
133 #include <SalomeApp_DataObject.h>
134 #include <SalomeApp_Study.h>
135 #include <SalomeApp_Tools.h>
136 #include <VTKViewer_Algorithm.h>
138 #ifndef DISABLE_PLOT2DVIEWER
139 #include <SPlot2d_ViewModel.h>
140 #include <SPlot2d_Histogram.h>
144 #include <SALOMEconfig.h>
145 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
146 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
147 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
148 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
149 #include CORBA_CLIENT_HEADER(SMESH_Homard)
152 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
153 #include <QApplication>
155 #include <QDialogButtonBox>
159 #include <QTextStream>
163 #include <boost/shared_ptr.hpp>
166 #include <vtkCallbackCommand.h>
167 #include <vtkCamera.h>
168 #include <vtkLookupTable.h>
169 #include <vtkPlane.h>
170 #include <vtkRenderer.h>
172 // SALOME KERNEL includes
173 #include <Basics_Utils.hxx>
174 #include <SALOMEDSClient_ClientFactory.hxx>
175 #include <SALOMEDSClient_IParameters.hxx>
176 #include <SALOMEDSClient_SComponent.hxx>
177 #include <SALOMEDSClient_StudyBuilder.hxx>
178 #include <SALOMEDS_SObject.hxx>
179 #include <SALOMEDS_Study.hxx>
180 #include <SALOME_GenericObj_wrap.hxx>
181 #include <SALOME_LifeCycleCORBA.hxx>
182 #include <utilities.h>
185 #include <Standard_ErrorHandler.hxx>
186 #include <NCollection_DataMap.hxx>
187 #include <NCollection_DoubleMap.hxx>
189 // Below macro, when uncommented, switches on simplified (more performant) algorithm
190 // of auto-color picking up
191 #define SIMPLE_AUTOCOLOR
196 //=============================================================
197 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
200 void ExportMeshToFile(int theCommandID);
202 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap);
204 void SetDisplayEntity(int theCommandID);
206 int ActionToControl( int theID, bool theReversed = false );
208 void Control( int theCommandID );
211 //================================================================================
213 * \brief Reads meshes from file
215 //================================================================================
217 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
221 std::string myExtension;
223 if ( theCommandID == SMESHOp::OpImportMED ||
224 theCommandID == SMESHOp::OpPopupImportMED ) {
225 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
226 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
228 else if ( theCommandID == SMESHOp::OpImportUNV ||
229 theCommandID == SMESHOp::OpPopupImportUNV ) {
230 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
232 else if ( theCommandID == SMESHOp::OpImportDAT ||
233 theCommandID == SMESHOp::OpPopupImportDAT ) {
234 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
236 else if ( theCommandID == SMESHOp::OpImportSTL ||
237 theCommandID == SMESHOp::OpPopupImportSTL ) {
238 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
240 else if ( theCommandID == SMESHOp::OpImportCGNS ||
241 theCommandID == SMESHOp::OpPopupImportCGNS ) {
242 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
244 else if ( theCommandID == SMESHOp::OpImportGMF ||
245 theCommandID == SMESHOp::OpPopupImportGMF ) {
246 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
247 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
250 QString anInitialPath = "";
251 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
252 anInitialPath = QDir::currentPath();
254 QStringList filenames;
255 bool toCreateGroups = true;
257 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
258 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
259 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
260 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
261 // fd->setNameFilters( filter );
262 // fd->SetChecked( true );
264 // filenames << fd->selectedFile();
265 // toCreateGroups = fd->IsChecked();
271 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
274 QObject::tr( "SMESH_IMPORT_MESH" ) );
276 if ( filenames.count() > 0 )
278 SUIT_OverrideCursor wc;
279 _PTR(Study) aStudy = SMESH::getStudy();
282 QStringList anEntryList;
283 bool isEmpty = false;
284 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
286 QString filename = *it;
287 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
289 switch ( theCommandID ) {
290 case SMESHOp::OpImportDAT:
291 case SMESHOp::OpPopupImportDAT:
293 // DAT format (currently unsupported)
294 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
295 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
298 case SMESHOp::OpImportUNV:
299 case SMESHOp::OpPopupImportUNV:
302 aMeshes->length( 1 );
303 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
304 if ( aMeshes[0]->_is_nil() )
305 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
306 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
309 case SMESHOp::OpImportMED:
310 case SMESHOp::OpPopupImportMED:
313 SMESH::DriverMED_ReadStatus res;
314 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
315 if ( res != SMESH::DRS_OK ) {
316 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
317 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
321 case SMESHOp::OpImportSTL:
322 case SMESHOp::OpPopupImportSTL:
325 aMeshes->length( 1 );
326 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
327 if ( aMeshes[0]->_is_nil() ) {
328 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
329 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
333 case SMESHOp::OpImportCGNS:
334 case SMESHOp::OpPopupImportCGNS:
337 SMESH::DriverMED_ReadStatus res;
338 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
339 if ( res != SMESH::DRS_OK ) {
340 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
341 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
345 case SMESHOp::OpImportGMF:
346 case SMESHOp::OpPopupImportGMF:
349 SMESH::ComputeError_var res;
350 aMeshes->length( 1 );
351 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
354 if ( res->code != SMESH::DRS_OK ) {
355 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
356 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
357 if ( strlen( res->comment.in() ) > 0 ) {
358 errors.back() += ": ";
359 errors.back() += res->comment.in();
366 catch ( const SALOME::SALOME_Exception& S_ex ) {
367 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
368 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
371 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
373 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
375 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
376 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
377 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
378 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
379 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
381 anEntryList.append( aMeshSO->GetID().c_str() );
389 // update Object browser
390 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
392 // browse to the published meshes
393 if( LightApp_Application* anApp =
394 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
395 anApp->browseObjects( anEntryList );
397 // show Error message box if there were errors
398 if ( errors.count() > 0 ) {
399 SUIT_MessageBox::critical( SMESHGUI::desktop(),
400 QObject::tr( "SMESH_ERROR" ),
401 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
404 // show warning message box, if some imported mesh is empty
406 SUIT_MessageBox::warning( SMESHGUI::desktop(),
407 QObject::tr( "SMESH_WRN_WARNING" ),
408 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
413 //================================================================================
415 * \brief Export selected meshes or groups into a file
417 //================================================================================
419 void ExportMeshToFile( int theCommandID )
421 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
422 SALOME_ListIO selected;
424 aSel->selectedObjects( selected );
426 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
427 theCommandID == SMESHOp::OpPopupExportDAT );
428 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
429 theCommandID == SMESHOp::OpPopupExportMED );
430 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
431 theCommandID == SMESHOp::OpPopupExportUNV );
432 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
433 theCommandID == SMESHOp::OpPopupExportSTL );
434 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
435 theCommandID == SMESHOp::OpPopupExportCGNS );
436 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
437 theCommandID == SMESHOp::OpPopupExportGMF );
439 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
440 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
442 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
443 bool aCheckWarn = true;
445 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
447 // get mesh object from selection and check duplication of their names
448 bool hasDuplicatedMeshNames = false;
449 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
450 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
451 SALOME_ListIteratorOfListIO It( selected );
452 for( ; It.More(); It.Next() )
454 Handle(SALOME_InteractiveObject) anIObject = It.Value();
455 SMESH::SMESH_IDSource_var aMeshItem =
456 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
457 if ( aMeshItem->_is_nil() ) {
458 SUIT_MessageBox::warning( SMESHGUI::desktop(),
459 QObject::tr( "SMESH_WRN_WARNING" ),
460 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
463 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
464 if ( aCheckWarn && !aGroup->_is_nil() )
466 QMessageBox msgBox(SUIT_MessageBox::Warning,
467 QObject::tr("SMESH_WRN_WARNING"),
468 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
469 QMessageBox::StandardButton::NoButton,
470 SMESHGUI::desktop());
471 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
472 msgBox.addButton(QMessageBox::Ok);
473 msgBox.addButton(QMessageBox::Cancel);
474 msgBox.setDefaultButton(QMessageBox::Cancel);
475 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
476 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
477 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
478 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
479 if ( msgBox.exec() != QMessageBox::Ok )
482 if ( dontShowCheckBox.checkState() == Qt::Checked && resMgr )
483 resMgr->setValue( "SMESH", "show_warning", false);
486 QString aMeshName = anIObject->getName();
488 // check for name duplications
489 if ( !hasDuplicatedMeshNames )
490 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
491 if( aMeshName == (*aMeshIter).second ) {
492 hasDuplicatedMeshNames = true;
497 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
500 if( hasDuplicatedMeshNames && isMED ) {
501 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
502 QObject::tr("SMESH_WRN_WARNING"),
503 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
504 QObject::tr("SMESH_BUT_YES"),
505 QObject::tr("SMESH_BUT_NO"), 0, 1);
510 aMeshIter = aMeshList.begin();
511 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
512 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
513 QString aMeshName = (*aMeshIter).second;
515 if ( isMED || isCGNS ) // formats where group names must be unique
517 // check for equal group names within each mesh
518 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
519 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
520 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
521 int aRet = SUIT_MessageBox::warning
522 (SMESHGUI::desktop(),
523 QObject::tr("SMESH_WRN_WARNING"),
524 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
525 QObject::tr("SMESH_BUT_YES"),
526 QObject::tr("SMESH_BUT_NO"), 0, 1);
533 // Warn the user about presence of not supported elements
535 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
539 notSupportedElemTypes.push_back( SMESH::Entity_0D );
540 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
545 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
546 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
547 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
548 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
549 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
550 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
551 notSupportedElemTypes.push_back( SMESH::Entity_0D );
552 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
557 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
558 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
559 notSupportedElemTypes.push_back( SMESH::Entity_0D );
560 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
565 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
570 notSupportedElemTypes.push_back( SMESH::Entity_0D );
571 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
572 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
573 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
574 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
575 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
576 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
577 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
578 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
579 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
581 if ( ! notSupportedElemTypes.empty() )
583 SMESH::smIdType_array_var nbElems = aMeshOrGroup->GetMeshInfo();
584 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
585 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
586 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
588 if ( !presentNotSupported.empty() )
591 const char* typeMsg[] = {
592 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
593 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
594 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
595 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
596 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
597 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
598 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
599 "SMESH_BIQUADRATIC_PENTAHEDRONS",
600 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
602 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
603 static_assert( sizeof(typeMsg) / sizeof(const char*) == SMESH::Entity_Last,
604 "Update names of EntityType's!!!" );
606 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
607 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
608 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
609 if ( iType != presentNotSupported.size() - 1 )
610 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
612 int aRet = SUIT_MessageBox::warning
613 (SMESHGUI::desktop(),
614 QObject::tr("SMESH_WRN_WARNING"),
615 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
616 QObject::tr("SMESH_BUT_YES"),
617 QObject::tr("SMESH_BUT_NO"), 0, 1);
622 // Get parameters of export operation
625 int aFormat =-1; // for MED version used for write
626 bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
628 // Init the parameters with the default values
629 bool aIsASCII_STL = true;
630 bool toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
631 bool toOverwrite = true;
632 bool toFindOutDim = true;
633 bool saveNumbers = resMgr->booleanValue( "SMESH", "med_save_numbers", true );
634 bool toRenumber = true;
635 double zTol = resMgr->doubleValue( "SMESH", "med_ztolerance", 0. );
637 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
638 QString anInitialPath = "";
639 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
640 anInitialPath = QDir::currentPath();
642 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
644 // Get a file name to write in and additional options
645 if ( isGMF ) // Export w/o options
647 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
648 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
649 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
651 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
652 anInitialPath + QString("/") + aMeshName,
653 aFilter, aTitle, false);
655 else if ( isCGNS || isUNV || isDAT ) // Export to [ CGNS | UNV | DAT ] - one option
657 const char* theOptionResource = isCGNS ? "cgns_group_elems_by_type" : "export_renumber";
658 bool option = resMgr->booleanValue( "SMESH", theOptionResource, false );
660 QStringList checkBoxes;
661 checkBoxes << QObject::tr( isCGNS ? "CGNS_EXPORT_ELEMS_BY_TYPE" : "SMESH_RENUMBER" );
663 SalomeApp_CheckFileDlg* fd =
664 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
665 fd->setWindowTitle( aTitle );
667 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
669 fd->setNameFilter( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
671 fd->setNameFilter( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
672 if ( !anInitialPath.isEmpty() )
673 fd->setDirectory( anInitialPath );
674 fd->selectFile( aMeshName );
675 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
676 fd->setValidator( fv );
677 fd->SetChecked( option, 0 );
680 aFilename = fd->selectedFile();
681 toOverwrite = fv->isOverwrite( aFilename );
682 option = fd->IsChecked( 0 );
683 SMESHGUI::resourceMgr()->setValue("SMESH", theOptionResource, option );
684 ( isCGNS ? toCreateGroups : toRenumber ) = option;
688 else if ( isSTL ) // Export to STL
690 QMap<QString, int> aFilterMap;
691 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
692 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
695 QMap<QString, int>::const_iterator it = aFilterMap.begin();
696 for ( ; it != aFilterMap.end(); ++it )
697 filters.push_back( it.key() );
699 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
700 fd->setWindowTitle( aTitle );
701 fd->setNameFilters( filters );
702 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
703 if ( !anInitialPath.isEmpty() )
704 fd->setDirectory( anInitialPath );
705 fd->selectFile(aMeshName);
709 aFilename = fd->selectedFile();
710 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
715 else if ( isMED ) // Export to MED
717 int defaultVersion = 0;
718 QMap<QString, int> aFilterMap;
719 //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
720 //QString vmed (aMesh->GetVersionString(-1, 2));
721 SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
722 if ( mvok->length() > 0)
723 defaultVersion = mvok[0]; // the current version to set the default filter on it
724 for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
726 QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
727 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
730 QMap<QString, int>::const_iterator it = aFilterMap.begin();
731 QString aDefaultFilter = it.key();
732 for ( ; it != aFilterMap.end(); ++it ) {
733 filters.push_back( it.key() );
734 if (it.value() == defaultVersion) // explicit default for MED = current MED version
735 aDefaultFilter = it.key();
737 QStringList checkBoxes;
738 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS")
739 << QObject::tr("SMESH_AUTO_DIM")
740 << QObject::tr("SMESH_MED_SAVE_NUMS");
742 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
743 QList< QWidget* > wdgList;
744 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
745 wdgList.append( fieldSelWdg );
747 QWidget* zTolWdg = new QWidget();
748 QCheckBox* zTolCheck = new QCheckBox( QObject::tr( "SMESH_ZTOLERANCE" ), zTolWdg );
749 SMESHGUI_SpinBox* zTolSpin = new SMESHGUI_SpinBox( zTolWdg );
750 QHBoxLayout* zTolLayout = new QHBoxLayout( zTolWdg );
751 zTolLayout->addWidget( zTolCheck );
752 zTolLayout->addWidget( zTolSpin );
753 zTolLayout->setMargin( 0 );
754 zTolSpin->RangeStepAndValidator( 0, 1e+100, 1., "length_precision" );
755 zTolSpin->setValue( zTol );
756 QObject::connect( zTolCheck, SIGNAL( toggled(bool)), zTolSpin, SLOT( setEnabled(bool)));
757 zTolCheck->setChecked( resMgr->booleanValue( "SMESH", "enable_ztolerance", false ));
758 zTolSpin ->setEnabled( zTolCheck->isChecked() );
759 wdgList.append( zTolWdg );
761 SalomeApp_CheckFileDlg* fd =
762 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
763 fd->setWindowTitle( aTitle );
764 fd->setNameFilters( filters );
765 fd->selectNameFilter( aDefaultFilter );
766 fd->SetChecked( toCreateGroups, 0 );
767 fd->SetChecked( toFindOutDim, 1 );
768 fd->SetChecked( saveNumbers, 2 );
769 if ( !anInitialPath.isEmpty() )
770 fd->setDirectory( anInitialPath );
771 fd->selectFile(aMeshName);
774 QListView *lview = fd->findChild<QListView*>("listView");
776 lview->setMinimumHeight(200);
778 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
780 tview->setMinimumHeight(200);
783 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
784 fd->setValidator( fv );
789 //MESSAGE("******* Loop on file dialog ***********");
792 aFilename = fd->selectedFile();
794 aFilename = QString::null;
797 aFormat = aFilterMap[fd->selectedNameFilter()];
798 //MESSAGE("selected version: " << aFormat << " file: " << aFilename.toUtf8().constData());
799 toOverwrite = fv->isOverwrite(aFilename);
800 //MESSAGE("toOverwrite:" << toOverwrite);
802 if ( !aFilename.isEmpty() ) {
804 // append is only possible if the existing file format is compatible
805 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
806 MESSAGE("Append check, isVersionOk:" << isVersionOk);
807 if ( !isVersionOk ) {
808 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
809 QObject::tr("SMESH_WRN_WARNING"),
810 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
811 QObject::tr("SMESH_BUT_YES"),
812 QObject::tr("SMESH_BUT_NO"), 0, 1);
816 //MESSAGE("incompatible MED file version for add, overwrite accepted");
822 //MESSAGE("incompatible MED file version for add, overwrite refused");
825 QStringList aMeshNamesCollisionList;
826 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
827 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
828 QString anExistingMeshName( aMeshNames[ i ] );
829 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
830 QString anExportMeshName = (*aMeshIter).second;
831 if( anExportMeshName == anExistingMeshName ) {
832 aMeshNamesCollisionList.append( anExportMeshName );
837 if( !aMeshNamesCollisionList.isEmpty() ) {
839 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
840 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
841 QObject::tr("SMESH_WRN_WARNING"),
842 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
843 QObject::tr("SMESH_BUT_YES"),
844 QObject::tr("SMESH_BUT_NO"),
845 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
846 MESSAGE("answer collision name " << aRet);
857 toCreateGroups = fd->IsChecked(0);
858 toFindOutDim = fd->IsChecked(1);
859 saveNumbers = fd->IsChecked(2);
860 zTol = zTolCheck->isChecked() ? zTolSpin->value() : -1;
861 fieldSelWdg->GetSelectedFields();
862 if ( resMgr ) resMgr->setValue( "SMESH", "enable_ztolerance", zTolCheck->isChecked() );
864 if ( !fieldSelWdg->parent() )
866 if ( !zTolWdg->parent() )
877 if ( !aFilename.isEmpty() ) {
878 // Check whether the file already exists and delete it if yes
879 QFile aFile( aFilename );
880 if ( aFile.exists() && toOverwrite )
882 SUIT_OverrideCursor wc;
885 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
886 // bool Renumber = false;
887 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
889 // Renumber= resMgr->booleanValue("renumbering");
891 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
892 // aMeshEditor->RenumberNodes();
893 // aMeshEditor->RenumberElements();
894 // if ( SMESHGUI::automaticUpdate() )
895 // SMESH::UpdateView();
897 if ( isMED && isOkToWrite )
899 aMeshIter = aMeshList.begin();
900 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
902 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
903 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
904 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
905 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
907 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
908 toCreateGroups, aFormat,
909 toOverwrite && aMeshIndex == 0, toFindOutDim,
910 fields, geoAssFields.toLatin1().data(), zTol, saveNumbers );
915 if ( aMeshOrGroup->_is_equivalent( aMesh ))
916 aMesh->ExportDAT( aFilename.toUtf8().data(), toRenumber );
918 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data(), toRenumber );
922 if ( aMeshOrGroup->_is_equivalent( aMesh ))
923 aMesh->ExportUNV( aFilename.toUtf8().data(), toRenumber );
925 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data(), toRenumber );
929 if ( aMeshOrGroup->_is_equivalent( aMesh ))
930 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
932 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
936 aMeshIter = aMeshList.begin();
937 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
939 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
940 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
941 aMeshItem->ExportCGNS( aMeshOrGroup,
942 aFilename.toUtf8().data(),
943 toOverwrite && aMeshIndex == 0,
949 toCreateGroups = true;
950 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
953 catch (const SALOME::SALOME_Exception& S_ex)
956 if ( S_ex.details.type == SALOME::COMM && // communicate about too large mesh
957 strncmp( "format=", S_ex.details.sourceFile.in(), 7 ) == 0 )
959 SUIT_MessageBox::critical(SMESHGUI::desktop(),
960 QObject::tr("SMESH_WRN_WARNING"),
961 QObject::tr(S_ex.details.text.in() ));
963 SUIT_MessageBox::warning(SMESHGUI::desktop(),
964 QObject::tr("SMESH_WRN_WARNING"),
965 QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
971 inline void InverseEntityMode(unsigned int& theOutputMode,
972 unsigned int theMode)
974 bool anIsNotPresent = ~theOutputMode & theMode;
976 theOutputMode |= theMode;
978 theOutputMode &= ~theMode;
981 void SetDisplayEntity(int theCommandID)
983 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
984 SALOME_ListIO selected;
986 aSel->selectedObjects( selected );
988 if ( selected.Extent() >= 1 ) {
989 SUIT_OverrideCursor wc;
990 SALOME_ListIteratorOfListIO It( selected );
991 for( ; It.More(); It.Next()){
992 Handle(SALOME_InteractiveObject) IObject = It.Value();
993 if(IObject->hasEntry()){
994 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
995 unsigned int aMode = anActor->GetEntityMode();
996 switch(theCommandID){
997 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
998 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
999 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1000 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1001 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1002 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1005 anActor->SetEntityMode(aMode);
1014 SalomeApp_Application* app =
1015 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1019 LightApp_SelectionMgr* aSel = app->selectionMgr();
1020 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1021 if ( !aSel || !appStudy )
1024 SALOME_ListIO selected;
1025 aSel->selectedObjects( selected );
1026 if ( selected.IsEmpty() )
1029 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1031 _PTR(Study) aStudy = appStudy->studyDS();
1032 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1033 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1034 if ( aMainObject->_is_nil() )
1037 SUIT_OverrideCursor wc;
1039 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1041 QList<SALOMEDS::Color> aReservedColors;
1043 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1044 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1046 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1048 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1049 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1050 #else // old algorithm for auto-colors
1051 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1052 aReservedColors.append( aColor );
1053 #endif // SIMPLE_AUTOCOLOR
1054 aGroupObject->SetColor( aColor );
1056 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1057 if ( aGroupSObject ) {
1060 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1061 switch ( aGroupObject->GetType ()) {
1063 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1065 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1067 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1069 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1071 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1072 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1075 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1076 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1082 SMESH::RepaintCurrentView();
1085 void OverallMeshQuality()
1087 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1088 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1089 SALOME_ListIO selected;
1091 aSel->selectedObjects( selected );
1093 if ( selected.IsEmpty() ) return;
1094 SALOME_ListIteratorOfListIO It( selected );
1095 for ( ; It.More(); It.Next() ) {
1096 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1097 ctrlDlg->showInfo( It.Value() );
1102 QString functorToString( SMESH::Controls::FunctorPtr f )
1104 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1105 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1106 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1107 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1108 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1109 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1110 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1111 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1112 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1113 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1114 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1115 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1116 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1117 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1118 type = QObject::tr( "WARP_ELEMENTS" );
1119 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1120 type = QObject::tr( "TAPER_ELEMENTS" );
1121 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1122 type = QObject::tr( "SKEW_ELEMENTS" );
1123 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1124 type = QObject::tr( "AREA_ELEMENTS" );
1125 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1126 type = QObject::tr( "LENGTH_EDGES" );
1127 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1128 type = QObject::tr( "LENGTH2D_EDGES" );
1129 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1130 type = QObject::tr( "DEFLECTION2D_FACES" );
1131 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1132 type = QObject::tr( "MULTI_BORDERS" );
1133 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1134 type = QObject::tr( "MULTI2D_BORDERS" );
1135 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1136 type = QObject::tr( "FREE_NODES" );
1137 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1138 type = QObject::tr( "FREE_EDGES" );
1139 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1140 type = QObject::tr( "FREE_BORDERS" );
1141 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1142 type = QObject::tr( "FREE_FACES" );
1143 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1144 type = QObject::tr( "BARE_BORDER_VOLUME" );
1145 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1146 type = QObject::tr( "BARE_BORDER_FACE" );
1147 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1148 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1149 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1150 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1151 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1152 type = QObject::tr( "EQUAL_NODE" );
1153 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1154 type = QObject::tr( "EQUAL_EDGE" );
1155 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1156 type = QObject::tr( "EQUAL_FACE" );
1157 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1158 type = QObject::tr( "EQUAL_VOLUME" );
1159 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1160 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1164 void SaveDistribution()
1166 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1167 SALOME_ListIO selected;
1169 aSel->selectedObjects( selected );
1171 if ( selected.Extent() == 1 ) {
1172 Handle(SALOME_InteractiveObject) anIO = selected.First();
1173 if ( anIO->hasEntry() ) {
1174 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1176 anActor->GetScalarBarActor() &&
1177 anActor->GetControlMode() != SMESH_Actor::eNone )
1179 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1180 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1181 if ( aScalarBarActor && aFunctor ) {
1182 SMESH::Controls::NumericalFunctor* aNumFun =
1183 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1185 std::vector<smIdType> elements;
1186 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1187 if ( mesh->_is_nil() ) {
1188 SMESH::SMESH_IDSource_var idSource =
1189 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1190 if ( !idSource->_is_nil() )
1192 SMESH::smIdType_array_var ids = idSource->GetIDs();
1193 elements.resize( ids->length() );
1194 for ( unsigned i = 0; i < elements.size(); ++i )
1195 elements[i] = ids[i];
1198 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1199 vtkLookupTable* lookupTable =
1200 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1201 double * minmax = lookupTable->GetRange();
1202 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1203 std::vector<int> nbEvents;
1204 std::vector<double> funValues;
1205 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1206 elements, minmax, isLogarithmic );
1207 QString anInitialPath = "";
1208 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1209 anInitialPath = QDir::currentPath();
1210 QString aMeshName = anIO->getName();
1212 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1213 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1214 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1215 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1216 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1219 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1221 if ( !aFilename.isEmpty() ) {
1222 QFile f( aFilename );
1223 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1224 QTextStream out( &f );
1225 out << "# Mesh: " << aMeshName << endl;
1226 out << "# Control: " << functorToString( aFunctor ) << endl;
1228 out.setFieldWidth( 10 );
1229 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1230 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1241 void ShowElement( int theCommandID )
1243 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1244 SALOME_ListIO selected;
1246 aSel->selectedObjects( selected );
1248 if ( selected.Extent() == 1 ) {
1249 Handle(SALOME_InteractiveObject) anIO = selected.First();
1250 if ( anIO->hasEntry() ) {
1251 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1253 anActor->GetScalarBarActor() &&
1254 anActor->GetControlMode() != SMESH_Actor::eNone )
1256 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1257 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1258 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1260 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1261 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1268 #ifndef DISABLE_PLOT2DVIEWER
1269 void PlotDistribution()
1271 SalomeApp_Application* app =
1272 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1276 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1277 SALOME_ListIO selected;
1279 aSel->selectedObjects( selected );
1281 if ( selected.Extent() == 1 ) {
1282 Handle(SALOME_InteractiveObject) anIO = selected.First();
1283 if ( anIO->hasEntry() ) {
1284 //Find Actor by entry before getting Plot2d viewer,
1285 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1286 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1288 SUIT_ViewManager* aViewManager =
1289 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1293 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1297 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1301 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1303 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1304 QString functorName = functorToString( anActor->GetFunctor());
1305 QString aHistogramName("%1 : %2");
1306 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1307 aHistogram->setName(aHistogramName);
1308 aHistogram->setHorTitle(functorName);
1309 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1310 aPlot->displayObject(aHistogram, true);
1315 #endif //DISABLE_PLOT2DVIEWER
1317 void DisableAutoColor()
1319 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1320 SALOME_ListIO selected;
1322 aSel->selectedObjects( selected );
1324 if ( selected.Extent() ) {
1325 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1326 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1327 if ( !aMesh->_is_nil() ) {
1328 aMesh->SetAutoColor( false );
1335 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1336 SALOME_ListIO selected;
1338 aSel->selectedObjects( selected );
1339 if ( selected.Extent() )
1341 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1342 _PTR(Study) aStudy = SMESH::getStudy();
1343 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1345 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1346 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1353 // Break link with Shaper model
1354 void breakShaperLink()
1356 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1357 SALOME_ListIO selected;
1359 aSel->selectedObjects(selected);
1360 if (selected.Extent()) {
1361 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1362 _PTR(Study) aStudy = SMESH::getStudy();
1363 std::string aEntry = anIObject->getEntry();
1364 _PTR(SObject) aSObj = aStudy->FindObjectID(aEntry);
1366 std::string aName = aSObj->GetName();
1367 QMessageBox::StandardButton aRes = SUIT_MessageBox::warning(SMESHGUI::desktop(),
1368 QObject::tr("SMESH_WRN_WARNING"),
1369 QObject::tr("MSG_BREAK_SHAPER_LINK").arg(aName.c_str()),
1370 SUIT_MessageBox::Yes | SUIT_MessageBox::No, SUIT_MessageBox::No);
1371 if (aRes == SUIT_MessageBox::Yes) {
1372 SUIT_DataOwnerPtrList aList;
1373 aSel->selected(aList, "ObjectBrowser", true);
1374 SUIT_DataOwner* aOwn = aList.first();
1375 LightApp_DataOwner* sowner = dynamic_cast<LightApp_DataOwner*>(aOwn);
1376 QString aREntry = sowner->entry();
1378 static GEOM::GEOM_Gen_var geomGen;
1379 if (CORBA::is_nil(geomGen)) {
1380 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>
1381 (SUIT_Session::session()->activeApplication());
1383 SALOME_LifeCycleCORBA* ls = new SALOME_LifeCycleCORBA(app->namingService());
1384 Engines::EngineComponent_var comp =
1385 ls->FindOrLoad_Component("FactoryServer", "SHAPERSTUDY");
1386 geomGen = GEOM::GEOM_Gen::_narrow(comp);
1389 if (!CORBA::is_nil(geomGen))
1391 geomGen->BreakLink(aREntry.toStdString().c_str());
1392 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1394 // remove actors whose objects are removed by BreakLink()
1395 QList<SUIT_ViewWindow*> wndList = SMESHGUI::desktop()->windows();
1396 SUIT_ViewWindow* wnd;
1397 foreach(wnd, wndList)
1398 SMESH::UpdateActorsAfterUpdateStudy(wnd);
1406 //================================================================================
1408 * \brief Return true if a mesh icon == ICON_SMESH_TREE_GEOM_MODIF
1409 * which means that the mesh can't be modified. It should be either re-computed
1410 * or breakShaperLink()'ed. Warn the user about it.
1412 //================================================================================
1414 bool warnOnGeomModif()
1416 SALOME_ListIO selected;
1417 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1418 aSel->selectedObjects(selected,"",/*convertReferences=*/false);
1420 SALOME_ListIteratorOfListIO It( selected );
1421 for ( ; It.More(); It.Next() )
1423 Handle(SALOME_InteractiveObject) io = It.Value();
1424 if ( !io->hasEntry() ) continue;
1425 _PTR(SObject) so = SMESH::getStudy()->FindObjectID( io->getEntry() );
1426 SMESH::SMESH_Mesh_var mesh;
1427 while ( mesh->_is_nil() && so && so->GetID() != "0:" )
1429 CORBA::Object_var obj = SMESH::SObjectToObject( so );
1430 SMESH::SMESH_IDSource_var isrc = SMESH::SMESH_IDSource::_narrow( obj );
1431 if ( isrc->_is_nil() )
1432 so = so->GetFather();
1434 mesh = isrc->GetMesh();
1436 if ( mesh->_is_nil() ) continue;
1437 so = SMESH::FindSObject( mesh );
1438 if ( !so ) continue;
1439 _PTR(GenericAttribute) attr;
1440 so->FindAttribute( attr, "AttributePixMap" );
1441 _PTR(AttributePixMap) pixmap = attr;
1442 if ( !pixmap ) continue;
1444 if ( pixmap->GetPixMap() == "ICON_SMESH_TREE_GEOM_MODIF" )
1446 SUIT_MessageBox::warning(SMESHGUI::desktop(),
1447 QObject::tr("SMESH_WRN_WARNING"),
1448 QObject::tr("MSG_WARN_ON_GEOM_MODIF"));
1455 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1457 SALOME_ListIO selected;
1458 SalomeApp_Application* app =
1459 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1463 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1464 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1465 if ( !aSel || !appStudy )
1468 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1469 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1470 aModule->EmitSignalDeactivateDialog();
1471 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1472 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1477 aSel->selectedObjects( selected );
1479 if ( selected.Extent() >= 1 )
1481 switch ( theCommandID ) {
1482 case SMESHOp::OpTransparency:
1484 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1485 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1488 case SMESHOp::OpProperties:
1491 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1492 QColor orientationColor, outlineColor, volumeColor;
1493 int deltaF = 0, deltaV = 0;
1496 double ballScale = 1.0;
1498 int outlineWidth = 1;
1499 double shrinkCoef = 0.0;
1500 double orientationScale = 0.0;
1501 bool orientation3d = false;
1502 VTK::MarkerType markerType = VTK::MT_NONE;
1503 VTK::MarkerScale markerScale = VTK::MS_NONE;
1505 bool hasNodes = false;
1506 int presentEntities = 0;
1507 bool firstTime = true;
1509 SALOME_ListIteratorOfListIO It( selected );
1510 for ( ; It.More(); It.Next() ) {
1511 Handle(SALOME_InteractiveObject) IObject = It.Value();
1512 if ( !IObject->hasEntry() ) continue;
1513 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1514 if ( !anActor || !anActor->GetObject() ) continue;
1517 // nodes: color, marker
1518 anActor->GetNodeColor( color[0], color[1], color[2] );
1519 nodeColor.setRgbF( color[0], color[1], color[2] );
1520 markerType = anActor->GetMarkerType();
1521 markerScale = anActor->GetMarkerScale();
1522 markerId = anActor->GetMarkerTexture();
1523 // edges: color, width
1524 anActor->GetEdgeColor( color[0], color[1], color[2] );
1525 edgeColor.setRgbF( color[0], color[1], color[2] );
1526 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1527 // faces: front color, back color (delta)
1528 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1529 faceColor.setRgbF( color[0], color[1], color[2] );
1530 // faces: front color, back color (delta)
1531 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1532 volumeColor.setRgbF( color[0], color[1], color[2] );
1533 // 0d elements: color, size
1534 anActor->Get0DColor( color[0], color[1], color[2] );
1535 elem0dColor.setRgbF( color[0], color[1], color[2] );
1536 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1537 // balls: color, size
1538 anActor->GetBallColor( color[0], color[1], color[2] );
1539 ballColor.setRgbF( color[0], color[1], color[2] );
1540 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1541 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1543 anActor->GetOutlineColor( color[0], color[1], color[2] );
1544 outlineColor.setRgbF( color[0], color[1], color[2] );
1545 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1546 // orientation vectors: color, scale, 3d flag
1547 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1548 orientationColor.setRgbF( color[0], color[1], color[2] );
1549 orientationScale = anActor->GetFacesOrientationScale();
1550 orientation3d = anActor->GetFacesOrientation3DVectors();
1552 shrinkCoef = anActor->GetShrinkFactor();
1555 firstTime = false; // we only take properties from first object (for performance reasons)
1558 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1559 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1560 presentEntities = presentEntities | SMESH_Actor::eEdges;
1561 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1562 presentEntities = presentEntities | SMESH_Actor::eFaces;
1563 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1564 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1565 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1566 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1567 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1568 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1570 // as we know that all types of elements are present, we can exit the loop
1571 if ( presentEntities == SMESH_Actor::eAllEntity )
1575 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1576 // nodes: color, marker
1577 dlg.setNodeColor( nodeColor );
1578 if( markerType != VTK::MT_USER )
1579 dlg.setNodeMarker( markerType, markerScale );
1581 dlg.setNodeCustomMarker( markerId );
1582 // edges: color, line width
1583 dlg.setEdgeColor( edgeColor );
1584 dlg.setEdgeWidth( edgeWidth );
1585 // faces: front color, back color
1586 dlg.setFaceColor( faceColor, deltaF );
1587 // volumes: normal color, reversed color
1588 dlg.setVolumeColor( volumeColor, deltaV );
1589 // outlines: color, line width
1590 dlg.setOutlineColor( outlineColor );
1591 dlg.setOutlineWidth( outlineWidth );
1592 // 0d elements: color, size
1593 dlg.setElem0dColor( elem0dColor );
1594 dlg.setElem0dSize( elem0dSize );
1595 // balls: color, size
1596 dlg.setBallColor( ballColor );
1597 //dlg.setBallSize( ballSize );
1598 dlg.setBallScale( ballScale );
1599 // orientation: color, scale, 3d flag
1600 dlg.setOrientationColor( orientationColor );
1601 dlg.setOrientationSize( int( orientationScale * 100. ) );
1602 dlg.setOrientation3d( orientation3d );
1603 // shrink: scale factor
1604 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1605 // hide unused controls
1606 dlg.showControls( presentEntities, hasNodes );
1609 nodeColor = dlg.nodeColor();
1610 markerType = dlg.nodeMarkerType();
1611 markerScale = dlg.nodeMarkerScale();
1612 markerId = dlg.nodeMarkerId();
1613 edgeColor = dlg.edgeColor();
1614 edgeWidth = dlg.edgeWidth();
1615 faceColor = dlg.faceColor();
1616 deltaF = dlg.faceColorDelta();
1617 volumeColor = dlg.volumeColor();
1618 deltaV = dlg.volumeColorDelta();
1619 outlineColor = dlg.outlineColor();
1620 outlineWidth = dlg.outlineWidth();
1621 elem0dColor = dlg.elem0dColor();
1622 elem0dSize = dlg.elem0dSize();
1623 ballColor = dlg.ballColor();
1624 // ballSize = dlg.ballSize();
1625 ballScale = dlg.ballScale();
1626 orientationColor = dlg.orientationColor();
1627 orientationScale = dlg.orientationSize() / 100.;
1628 orientation3d = dlg.orientation3d();
1629 shrinkCoef = dlg.shrinkCoef() / 100.;
1631 // store point markers that might be changed by the user
1632 theMarkerMap = dlg.customMarkers();
1634 // set properties from dialog box to the presentations
1635 SALOME_ListIteratorOfListIO It( selected );
1636 for ( ; It.More(); It.Next() ) {
1637 Handle(SALOME_InteractiveObject) IObject = It.Value();
1638 if ( !IObject->hasEntry() ) continue;
1639 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1640 if ( !anActor ) continue;
1642 // nodes: color, marker
1643 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1644 if ( markerType != VTK::MT_USER ) {
1645 anActor->SetMarkerStd( markerType, markerScale );
1648 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1649 if ( iter != theMarkerMap.end() )
1650 anActor->SetMarkerTexture( markerId, iter->second.second );
1652 // volumes: normal color, reversed color (delta)
1653 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1654 // faces: front color, back color (delta)
1655 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1656 // edges: color, width
1657 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1658 anActor->SetLineWidth( edgeWidth );
1660 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1661 anActor->SetOutlineWidth( outlineWidth );
1662 // 0D elements: color, size
1663 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1664 anActor->Set0DSize( elem0dSize );
1665 // balls: color, size
1666 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1667 // anActor->SetBallSize( ballSize );
1668 anActor->SetBallScale( ballScale );
1669 // orientation: color, scale, 3d flag
1670 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1671 anActor->SetFacesOrientationScale( orientationScale );
1672 anActor->SetFacesOrientation3DVectors( orientation3d );
1674 anActor->SetShrinkFactor( shrinkCoef );
1676 // for groups, set also proper color
1677 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1678 if ( !aGroupObject->_is_nil() ) {
1679 SMESH::ElementType anElementType = aGroupObject->GetType();
1681 switch( anElementType ) {
1683 aColor = nodeColor; break;
1685 aColor = edgeColor; break;
1687 aColor = faceColor; break;
1689 aColor = volumeColor; break;
1691 aColor = elem0dColor; break;
1693 aColor = ballColor; break;
1697 if ( aColor.isValid() ) {
1698 SALOMEDS::Color aGroupColor;
1699 aGroupColor.R = aColor.redF();
1700 aGroupColor.G = aColor.greenF();
1701 aGroupColor.B = aColor.blueF();
1702 aGroupObject->SetColor( aGroupColor );
1704 } // if ( !aGroupObject->_is_nil() )
1705 } // for ( ; It.More(); It.Next() )
1706 SMESH::RepaintCurrentView();
1707 } // if ( dlg.exec() )
1709 } // case SMESHOp::OpProperties:
1710 } // switch(theCommandID)
1711 SUIT_OverrideCursor wc;
1712 SALOME_ListIteratorOfListIO It( selected );
1713 for( ; It.More(); It.Next()){
1714 Handle(SALOME_InteractiveObject) IObject = It.Value();
1715 if(IObject->hasEntry()){
1716 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1717 switch(theCommandID){
1718 case SMESHOp::OpDMWireframe:
1719 anActor->SetRepresentation(SMESH_Actor::eEdge);
1721 case SMESHOp::OpDMShading:
1722 anActor->SetRepresentation(SMESH_Actor::eSurface);
1724 case SMESHOp::OpDMShrink:
1725 if(anActor->IsShrunk())
1726 anActor->UnShrink();
1728 anActor->SetShrink();
1730 case SMESHOp::OpDMNodes:
1731 anActor->SetRepresentation(SMESH_Actor::ePoint);
1733 case SMESHOp::OpRepresentationLines:
1734 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1735 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1737 case SMESHOp::OpRepresentationArcs:
1738 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1739 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1745 SMESH::RepaintCurrentView();
1749 int ActionToControl( int theID, bool theReversed )
1751 NCollection_DoubleMap<int,int> ActionControl;
1752 ActionControl.Bind( 0, SMESH_Actor::eNone );
1753 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1754 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1755 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1756 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1757 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1758 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1759 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1760 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1761 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1762 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1763 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1764 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1765 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1766 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1767 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1768 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1769 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1770 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1771 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1772 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1773 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1774 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1775 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1776 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1777 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1778 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1779 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1780 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1783 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1784 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1787 void Control( int theCommandID )
1789 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1790 _PTR(Study) aStudy = SMESH::getStudy();
1792 SALOME_ListIO selected;
1793 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1794 aSel->selectedObjects( selected );
1796 if ( !selected.IsEmpty() ) {
1797 SALOME_ListIteratorOfListIO It(selected);
1798 for ( ; It.More(); It.Next())
1800 Handle(SALOME_InteractiveObject) anIO = It.Value();
1801 if ( !anIO.IsNull() ) {
1802 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1804 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1805 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1806 if ( !anIDSrc->_is_nil() ) {
1807 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1808 if (( !anActor && selected.Extent() == 1 ) &&
1809 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1811 anActor->SetControlMode( aControl );
1812 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1813 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1817 if ( anActor->GetControlMode() != aControl )
1818 anActor->SetControlMode( aControl );
1819 QString functorName = functorToString( anActor->GetFunctor() );
1820 smIdType anEntitiesCount = anActor->GetNumberControlEntities();
1821 if (anEntitiesCount >= 0)
1822 functorName = functorName + ": " + QString::number(anEntitiesCount);
1823 anActor->GetScalarBarActor()->SetTitle( functorName.toUtf8().constData() );
1824 SMESH::RepaintCurrentView();
1825 #ifndef DISABLE_PLOT2DVIEWER
1826 if ( anActor->GetPlot2Histogram() ) {
1827 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1828 QString aHistogramName("%1 : %2");
1829 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1830 aHistogram->setName( aHistogramName );
1831 aHistogram->setHorTitle( functorName );
1832 SMESH::ProcessIn2DViewers( anActor );
1844 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1845 SMESH::MeshObjectType theType,
1846 const QString theInTypeName,
1847 QString & theOutTypeName)
1849 SMESH_TypeFilter aTypeFilter( theType );
1851 if ( !theIO.IsNull() )
1853 entry = theIO->getEntry();
1854 LightApp_DataOwner owner( entry );
1855 if ( aTypeFilter.isOk( &owner )) {
1856 theOutTypeName = theInTypeName;
1864 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1866 _PTR(Study) aStudy = SMESH::getStudy();
1867 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1869 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1870 CORBA::String_var anID = aSComp->GetID().c_str();
1871 if ( !strcmp(anID.in(),theIO->getEntry()) )
1877 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1878 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1879 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1880 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1881 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1889 // QString CheckHomogeneousSelection()
1891 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1892 // SALOME_ListIO selected;
1894 // aSel->selectedObjects( selected );
1896 // QString RefType = CheckTypeObject(selected.First());
1897 // SALOME_ListIteratorOfListIO It(selected);
1898 // for ( ; It.More(); It.Next())
1900 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1901 // QString Type = CheckTypeObject(IObject);
1902 // if ( Type.compare(RefType) != 0 )
1903 // return "Heterogeneous Selection";
1909 uint randomize( uint size )
1911 static bool initialized = false;
1912 if ( !initialized ) {
1913 qsrand( QDateTime::currentDateTime().toTime_t() );
1917 v = uint( (double)( v ) / RAND_MAX * size );
1918 v = qMax( uint(0), qMin ( v, size-1 ) );
1924 void SMESHGUI::OnEditDelete()
1926 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1927 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1928 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1930 _PTR(Study) aStudy = SMESH::getStudy();
1931 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1932 _PTR(GenericAttribute) anAttr;
1933 _PTR(AttributeIOR) anIOR;
1935 const int objectCountLimit = 30; // PAL23599
1936 int objectCount = 0;
1938 QString aParentComponent = QString::null;
1940 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1942 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1943 if ( anIO.IsNull() ) continue;
1945 QString father = "unknown", name;
1947 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1949 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1950 // check if object is reference
1951 _PTR(SObject) aRefSObj;
1952 if ( aSO->ReferencedObject( aRefSObj ) ) {
1953 name = QString::fromStdString ( aRefSObj->GetName() );
1954 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1957 name = anIO->getName();
1960 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
1961 aNameList.append("\n - ");
1962 aNameList.append( name );
1965 if( aParentComponent.isNull() )
1966 aParentComponent = father;
1967 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1968 aParentComponent = "";
1970 if ( objectCount >= objectCountLimit )
1971 aNameList.append("\n - ...");
1973 if ( objectCount == 0 )
1974 return; // No Valid Objects Selected
1976 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1977 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1978 QObject::tr("ERR_ERROR"),
1979 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1982 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1983 if (SUIT_MessageBox::warning
1984 (SMESHGUI::desktop(),
1985 QObject::tr("SMESH_WRN_WARNING"),
1986 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1987 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1988 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1991 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1993 // Put one level of sub-objects of the selected SO's into a list
1994 // in order to get objects inside folders like "Assigned Algorithms"
1995 std::list< _PTR(SObject) > listSO;
1996 SALOME_ListIteratorOfListIO It(selected);
1997 for( ; It.More(); It.Next()) // loop on selected IO's
1999 Handle(SALOME_InteractiveObject) IObject = It.Value();
2000 if(IObject->hasEntry()) {
2001 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
2003 // disable removal of "SMESH" component object
2004 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
2006 if ( engineIOR() == anIOR->Value().c_str() )
2009 //Check the referenced object
2010 _PTR(SObject) aRefSObject;
2011 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
2012 aSO = aRefSObject; // Delete main Object instead of reference
2014 listSO.push_back( aSO );
2016 _PTR(ChildIterator) it = aStudy->NewChildIterator( aSO );
2017 for (it->InitEx(false); it->More(); it->Next())
2018 listSO.push_back( it->Value() );
2021 // Check if none of objects to delete is referred from outside
2022 std::list< _PTR(SObject) >::reverse_iterator ritSO;
2023 std::vector< _PTR(SObject) > subSO;
2024 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2026 _PTR(SObject) SO = *ritSO;
2027 if ( !SO ) continue;
2029 int nbChildren = SO->GetLastChildTag();
2031 subSO.reserve( 1 + nbChildren );
2032 subSO.push_back( SO );
2033 if ( nbChildren > 0 )
2035 _PTR(ChildIterator) it = aStudy->NewChildIterator( SO );
2036 for ( it->InitEx( true ); it->More(); it->Next() )
2037 subSO.push_back( it->Value() );
2039 for ( size_t i = 0; i < subSO.size(); ++i )
2041 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( subSO[i] );
2042 for ( size_t j = 0; j < aReferences.size(); j++ ) {
2043 _PTR(SComponent) aComponent = aReferences[j]->GetFatherComponent();
2044 std::string type = aComponent->ComponentDataType();
2045 if ( type != "SMESH" )
2047 SUIT_MessageBox::warning( anApp->desktop(),
2048 QObject::tr("WRN_WARNING"),
2049 QObject::tr("DEP_OBJECT") );
2050 return; // outside SMESH, there is an object depending on a SMESH object
2056 // Treat SO's in the list starting from the back
2057 aStudyBuilder->NewCommand(); // There is a transaction
2058 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2060 _PTR(SObject) SO = *ritSO;
2061 if ( !SO ) continue;
2062 std::string anEntry = SO->GetID();
2064 /** Erase graphical object and remove all its data **/
2065 if ( SO->FindAttribute( anAttr, "AttributeIOR" )) {
2066 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
2068 /** Remove an object from data structures **/
2069 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
2070 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
2071 if ( !aGroup->_is_nil() ) { // DELETE GROUP
2072 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
2073 aMesh->RemoveGroup( aGroup );
2075 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
2076 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2077 aMesh->RemoveSubMesh( aSubMesh );
2080 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2081 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2082 QString objType = CheckTypeObject(IObject);
2083 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2084 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2085 aStudyBuilder->RemoveObjectWithChildren( SO );
2087 else {// default action: remove SObject from the study
2088 // Find Sub-Meshes and Group and delete corresopning visual objects and actors
2089 _PTR(ChildIterator) it1 = aStudy->NewChildIterator(SO);
2090 for (it1->InitEx(false); it1->More(); it1->Next()) {
2091 _PTR(SObject) SObj = it1->Value();
2092 if (!SObj) continue;
2093 if (SObj->FindAttribute(anAttr, "AttributeIOR")) {
2094 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow(SMESH::SObjectToObject(SObj));
2095 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow(SMESH::SObjectToObject(SObj));
2096 if (!aGroup->_is_nil() || !aSubMesh->_is_nil()) {
2097 SMESH::RemoveVisualObjectWithActors(SObj->GetID().c_str(), true);
2101 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2102 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2104 aStudyBuilder->RemoveObjectWithChildren( SO );
2108 } /* listSO back loop */
2110 aStudyBuilder->CommitCommand();
2112 /* Clear any previous selection */
2114 aSel->setSelectedObjects( l1 );
2116 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2120 SMESHGUI_EXPORT CAM_Module* createModule()
2122 return new SMESHGUI();
2125 SMESHGUI_EXPORT char* getModuleVersion() {
2126 return (char*)SMESH_VERSION_STR;
2130 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2132 //=============================================================================
2136 //=============================================================================
2137 SMESHGUI::SMESHGUI() : SalomeApp_Module( "SMESH" )
2139 if ( CORBA::is_nil( myComponentSMESH ) )
2141 CORBA::Boolean anIsEmbeddedMode;
2142 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2144 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2146 // 0019923: EDF 765 SMESH : default values of hypothesis
2147 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2148 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2149 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2150 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2151 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2153 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2154 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2155 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2157 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2158 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2162 myActiveDialogBox = 0;
2163 myFilterLibraryDlg = 0;
2167 myEventCallbackCommand = vtkCallbackCommand::New();
2168 myEventCallbackCommand->Delete();
2169 myEventCallbackCommand->SetClientData( this );
2170 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2173 /* load resources for all available meshers */
2174 SMESH::InitAvailableHypotheses();
2177 //=============================================================================
2181 //=============================================================================
2182 SMESHGUI::~SMESHGUI()
2186 //=============================================================================
2190 //=============================================================================
2191 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2193 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2195 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2200 //=============================================================================
2204 //=============================================================================
2205 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2207 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2211 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2212 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2213 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2214 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2215 return autoUpdate && !exceeded;
2218 //=============================================================================
2222 //=============================================================================
2223 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2224 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2226 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2230 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2231 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2232 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2234 SMESH::smIdType_array_var info = theMesh->GetMeshInfo();
2235 long nbOdElems = info[SMDSEntity_0D];
2236 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2237 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2238 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2239 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2240 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2241 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2242 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2243 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2244 info[SMDSEntity_Polyhedra] +
2245 info[SMDSEntity_Hexagonal_Prism];
2246 long nbBalls = info[SMDSEntity_Ball];
2248 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2249 *nbElements = requestedSize;
2251 *entities = SMESH_Actor::eAllEntity;
2254 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2256 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2258 if ( incrementalLimit ) {
2261 if ( nbOdElems > 0 ) {
2262 if ( total + nbOdElems > updateLimit ) {
2263 *entities = *entities & ~SMESH_Actor::e0DElements;
2264 *hidden = *hidden | SMESH_Actor::e0DElements;
2271 if ( nbEdges > 0 ) {
2272 if ( total + nbEdges > updateLimit ) {
2273 *entities = *entities & ~SMESH_Actor::eEdges;
2274 *hidden = *hidden | SMESH_Actor::eEdges;
2281 if ( nbFaces > 0 ) {
2282 if ( total + nbFaces > updateLimit ) {
2283 *entities = *entities & ~SMESH_Actor::eFaces;
2284 *hidden = *hidden | SMESH_Actor::eFaces;
2291 if ( nbVolumes > 0 ) {
2292 if ( total + nbVolumes > updateLimit ) {
2293 *entities = *entities & ~SMESH_Actor::eVolumes;
2294 *hidden = *hidden | SMESH_Actor::eVolumes;
2301 if ( nbBalls > 0 ) {
2302 if ( total + nbBalls > updateLimit ) {
2303 *entities = *entities & ~SMESH_Actor::eBallElem;
2304 *hidden = *hidden | SMESH_Actor::eBallElem;
2312 return autoUpdate && !exceeded;
2315 //=============================================================================
2319 //=============================================================================
2320 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2322 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2325 //=============================================================================
2329 //=============================================================================
2330 SMESHGUI* SMESHGUI::GetSMESHGUI()
2332 SMESHGUI* smeshMod = 0;
2333 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2336 CAM_Module* module = app->module( "Mesh" );
2337 smeshMod = dynamic_cast<SMESHGUI*>( module );
2345 Standard_EXPORT SMESHGUI* GetComponentGUI()
2347 return SMESHGUI::GetSMESHGUI();
2351 //=============================================================================
2355 //=============================================================================
2356 void SMESHGUI::SetState(int aState)
2361 //=============================================================================
2365 //=============================================================================
2366 void SMESHGUI::ResetState()
2371 //=============================================================================
2375 //=============================================================================
2376 void SMESHGUI::EmitSignalDeactivateDialog()
2378 emit SignalDeactivateActiveDialog();
2381 //=============================================================================
2385 //=============================================================================
2386 void SMESHGUI::EmitSignalStudyFrameChanged()
2388 emit SignalStudyFrameChanged();
2391 //=============================================================================
2395 //=============================================================================
2396 void SMESHGUI::EmitSignalCloseAllDialogs()
2398 emit SignalCloseAllDialogs();
2401 //=============================================================================
2405 //=============================================================================
2406 void SMESHGUI::EmitSignalVisibilityChanged()
2408 emit SignalVisibilityChanged();
2411 //=============================================================================
2415 //=============================================================================
2416 void SMESHGUI::EmitSignalCloseView()
2418 emit SignalCloseView();
2421 //=============================================================================
2425 //=============================================================================
2426 void SMESHGUI::EmitSignalActivatedViewManager()
2428 emit SignalActivatedViewManager();
2431 //=============================================================================
2435 //=============================================================================
2436 QDialog *SMESHGUI::GetActiveDialogBox()
2438 return myActiveDialogBox;
2441 //=============================================================================
2445 //=============================================================================
2446 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2448 myActiveDialogBox = (QDialog *) aDlg;
2452 //=============================================================================
2456 //=============================================================================
2457 SUIT_Desktop* SMESHGUI::desktop()
2459 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2461 return app->desktop();
2466 //=============================================================================
2470 //=============================================================================
2471 SalomeApp_Study* SMESHGUI::activeStudy()
2473 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2475 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2480 //=============================================================================
2484 //=============================================================================
2485 void SMESHGUI::Modified( bool theIsUpdateActions )
2487 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2488 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2489 appStudy->Modified();
2490 if( theIsUpdateActions )
2491 app->updateActions();
2496 //=============================================================================
2500 //=============================================================================
2501 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2503 /* Here the position is on the bottom right corner - 10 */
2504 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2506 SUIT_Desktop *PP = desktop();
2507 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2508 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2513 * \brief Verifies whether study of operation is locked
2514 * \param theMess - specifies whether message box must be shown if study is locked
2515 * \return State of study.
2517 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2518 * is locked when corresponding message box appears
2520 bool SMESHGUI::isStudyLocked( bool theMessage )
2522 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2525 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2526 QObject::tr( "WRN_WARNING" ),
2527 QObject::tr( "WRN_STUDY_LOCKED" ) );
2533 //=============================================================================
2537 //=============================================================================
2538 bool SMESHGUI::OnGUIEvent( int theCommandID )
2540 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2544 SUIT_ResourceMgr* mgr = resourceMgr();
2548 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2549 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2551 //QAction* act = action( theCommandID );
2553 switch (theCommandID) {
2554 case SMESHOp::OpDelete:
2555 if(isStudyLocked()) break;
2558 case SMESHOp::OpImportDAT:
2559 case SMESHOp::OpImportUNV:
2560 case SMESHOp::OpImportMED:
2561 case SMESHOp::OpImportSTL:
2562 case SMESHOp::OpImportCGNS:
2563 case SMESHOp::OpImportGMF:
2564 case SMESHOp::OpPopupImportDAT:
2565 case SMESHOp::OpPopupImportUNV:
2566 case SMESHOp::OpPopupImportMED:
2567 case SMESHOp::OpPopupImportSTL:
2568 case SMESHOp::OpPopupImportCGNS:
2569 case SMESHOp::OpPopupImportGMF:
2571 if(isStudyLocked()) break;
2572 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2576 case SMESHOp::OpFileInformation:
2578 SALOME_ListIO selected;
2579 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2581 aSel->selectedObjects( selected );
2582 if( selected.Extent() )
2584 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2585 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2586 if ( !aMesh->_is_nil() )
2588 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2594 case SMESHOp::OpExportDAT:
2595 case SMESHOp::OpExportMED:
2596 case SMESHOp::OpExportUNV:
2597 case SMESHOp::OpExportSTL:
2598 case SMESHOp::OpExportCGNS:
2599 case SMESHOp::OpExportGMF:
2600 case SMESHOp::OpPopupExportDAT:
2601 case SMESHOp::OpPopupExportMED:
2602 case SMESHOp::OpPopupExportUNV:
2603 case SMESHOp::OpPopupExportSTL:
2604 case SMESHOp::OpPopupExportCGNS:
2605 case SMESHOp::OpPopupExportGMF:
2607 ::ExportMeshToFile(theCommandID);
2611 case SMESHOp::OpReset: // SCALAR BAR
2613 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2614 SALOME_ListIO selected;
2616 aSel->selectedObjects( selected );
2618 SALOME_ListIteratorOfListIO it(selected);
2619 for( ; it.More(); it.Next()) {
2620 Handle(SALOME_InteractiveObject) anIO = it.Value();
2621 if( anIO->hasEntry() ) {
2622 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2623 anActor->SetControlMode( SMESH_Actor::eNone );
2624 #ifndef DISABLE_PLOT2DVIEWER
2625 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2627 anActor->UpdateFilter();
2631 SMESH::UpdateView();
2634 case SMESHOp::OpScalarBarProperties:
2636 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2639 case SMESHOp::OpShowScalarBar:
2641 // show/hide scalar bar
2642 ::ShowElement(theCommandID);
2645 case SMESHOp::OpSaveDistribution:
2647 // dump control distribution data to the text file
2648 ::SaveDistribution();
2652 case SMESHOp::OpShowDistribution:
2654 // show/hide distribution
2655 ::ShowElement(theCommandID);
2659 #ifndef DISABLE_PLOT2DVIEWER
2660 case SMESHOp::OpPlotDistribution:
2662 // plot distribution
2663 ::PlotDistribution();
2669 case SMESHOp::OpAutoColor:
2673 case SMESHOp::OpDisableAutoColor:
2674 ::DisableAutoColor();
2677 case SMESHOp::OpClipping:
2678 case SMESHOp::OpTransparency:
2679 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2682 case SMESHOp::OpDMWireframe:
2683 case SMESHOp::OpDMShading:
2684 case SMESHOp::OpDMNodes:
2685 case SMESHOp::OpDMShrink:
2686 ::SetDisplayMode(theCommandID, myMarkerMap);
2689 //2D quadratic representation
2690 case SMESHOp::OpRepresentationLines:
2691 case SMESHOp::OpRepresentationArcs:
2692 ::SetDisplayMode(theCommandID, myMarkerMap);
2696 case SMESHOp::OpDE0DElements:
2697 case SMESHOp::OpDEEdges:
2698 case SMESHOp::OpDEFaces:
2699 case SMESHOp::OpDEVolumes:
2700 case SMESHOp::OpDEBalls:
2701 case SMESHOp::OpDEAllEntity:
2702 ::SetDisplayEntity(theCommandID);
2705 // Choose entities to be displayed
2706 case SMESHOp::OpDEChoose:
2708 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2712 case SMESHOp::OpOrientationOnFaces:
2714 SUIT_OverrideCursor wc;
2715 LightApp_SelectionMgr* mgr = selectionMgr();
2716 SALOME_ListIO selected; mgr->selectedObjects( selected );
2718 SALOME_ListIteratorOfListIO it(selected);
2719 for( ; it.More(); it.Next()) {
2720 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2721 if(anIObject->hasEntry()) {
2722 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2723 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2730 case SMESHOp::OpUpdate:
2732 if(isStudyLocked()) break;
2733 SUIT_OverrideCursor wc;
2736 SMESH::UpdateView();
2738 catch (std::bad_alloc&) { // PAL16774 (Crash after display of many groups)
2739 SMESH::OnVisuException();
2741 catch (...) { // PAL16774 (Crash after display of many groups)
2742 SMESH::OnVisuException();
2746 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2747 aSel->selectedObjects( l );
2748 aSel->setSelectedObjects( l );
2752 case SMESHOp::OpHide:
2753 case SMESHOp::OpShow:
2754 case SMESHOp::OpShowOnly:
2756 SUIT_OverrideCursor wc;
2757 SMESH::EDisplaing anAction;
2758 switch (theCommandID) {
2759 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2760 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2761 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2764 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2765 SALOME_ListIO sel_objects, to_process;
2767 aSel->selectedObjects( sel_objects );
2769 if ( theCommandID==SMESHOp::OpShowOnly )
2771 //MESSAGE("anAction = SMESH::eDisplayOnly");
2772 startOperation( myEraseAll );
2775 extractContainers( sel_objects, to_process );
2780 SALOME_ListIteratorOfListIO It( to_process );
2781 for ( ; It.More(); It.Next())
2783 Handle(SALOME_InteractiveObject) IOS = It.Value();
2784 if ( IOS->hasEntry() )
2786 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2787 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2788 break; // PAL16774 (Crash after display of many groups)
2790 if (anAction == SMESH::eDisplayOnly)
2791 anAction = SMESH::eDisplay;
2796 // PAL13338 + PAL15161 -->
2797 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2798 SMESH::UpdateView();
2799 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2801 // PAL13338 + PAL15161 <--
2803 catch (...) { // PAL16774 (Crash after display of many groups)
2804 SMESH::OnVisuException();
2807 if (anAction == SMESH::eErase) {
2809 aSel->setSelectedObjects( l1 );
2812 aSel->setSelectedObjects( to_process );
2814 if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2815 ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2816 vtkwnd->GetRenderer()->AdjustActors();
2821 case SMESHOp::OpNode:
2823 if(isStudyLocked()) break;
2826 EmitSignalDeactivateDialog();
2828 ( new SMESHGUI_NodesDlg( this ) )->show();
2831 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2836 case SMESHOp::OpEditMeshOrSubMesh:
2837 case SMESHOp::OpEditMesh:
2838 case SMESHOp::OpEditSubMesh:
2839 case SMESHOp::OpMeshOrder:
2840 case SMESHOp::OpCreateSubMesh:
2841 if ( warnOnGeomModif() )
2842 break; // action forbidden as geometry modified
2844 case SMESHOp::OpCreateMesh:
2845 case SMESHOp::OpCompute:
2846 case SMESHOp::OpComputeSubMesh:
2847 case SMESHOp::OpPreCompute:
2848 case SMESHOp::OpEvaluate:
2849 case SMESHOp::OpShowErrors:
2850 startOperation( theCommandID );
2852 case SMESHOp::OpRecompute:
2854 if ( isStudyLocked() )
2856 SALOME_ListIO selected;
2857 if ( LightApp_SelectionMgr *sel = selectionMgr() )
2858 sel->selectedObjects( selected );
2859 if ( selected.Extent() == 1 ) {
2860 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO( selected.First() );
2861 if ( !aMesh->_is_nil() )
2863 startOperation( SMESHOp::OpCompute );
2867 case SMESHOp::OpCopyMesh:
2869 if (isStudyLocked()) break;
2870 EmitSignalDeactivateDialog();
2871 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2874 case SMESHOp::OpBuildCompoundMesh:
2876 if (isStudyLocked()) break;
2877 EmitSignalDeactivateDialog();
2878 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2882 case SMESHOp::OpDiagonalInversion:
2883 case SMESHOp::OpUnionOfTwoTriangle:
2887 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2891 if ( isStudyLocked() )
2893 if ( warnOnGeomModif() )
2894 break; // action forbidden as geometry modified
2896 /*Standard_Boolean aRes;
2897 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2898 if ( aMesh->_is_nil() )
2900 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2901 tr( "SMESH_BAD_SELECTION" ) );
2905 EmitSignalDeactivateDialog();
2906 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2907 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2909 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2912 case SMESHOp::OpOrientation:
2913 case SMESHOp::OpUnionOfTriangles:
2914 case SMESHOp::OpCuttingOfQuadrangles:
2915 case SMESHOp::OpSplitVolumes:
2919 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2923 if ( isStudyLocked() )
2925 if ( warnOnGeomModif() )
2926 break; // action forbidden as geometry modified
2928 EmitSignalDeactivateDialog();
2929 SMESHGUI_MultiEditDlg* aDlg = NULL;
2930 if ( theCommandID == SMESHOp::OpOrientation )
2931 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2932 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2933 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2934 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2935 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2937 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2942 case SMESHOp::OpSmoothing:
2944 if(isStudyLocked()) break;
2945 if ( warnOnGeomModif() )
2946 break; // action forbidden as geometry modified
2948 EmitSignalDeactivateDialog();
2949 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2952 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2956 case SMESHOp::OpExtrusion:
2958 if (isStudyLocked()) break;
2959 if ( warnOnGeomModif() )
2960 break; // action forbidden as geometry modified
2962 EmitSignalDeactivateDialog();
2963 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2965 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2969 case SMESHOp::OpExtrusionAlongAPath:
2971 if (isStudyLocked()) break;
2972 if ( warnOnGeomModif() )
2973 break; // action forbidden as geometry modified
2975 EmitSignalDeactivateDialog();
2976 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2978 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2982 case SMESHOp::OpRevolution:
2984 if(isStudyLocked()) break;
2985 if ( warnOnGeomModif() )
2986 break; // action forbidden as geometry modified
2988 EmitSignalDeactivateDialog();
2989 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2992 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2996 case SMESHOp::OpPatternMapping:
2998 if ( isStudyLocked() )
3000 if ( warnOnGeomModif() )
3001 break; // action forbidden as geometry modified
3004 EmitSignalDeactivateDialog();
3005 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
3008 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3012 // Adaptation - begin
3013 #ifndef DISABLE_MG_ADAPT
3014 case SMESHOp::OpMGAdapt:
3016 if ( isStudyLocked() )
3018 EmitSignalDeactivateDialog();
3020 SALOME::GenericObj_wrap< SMESH::MG_ADAPT > model = GetSMESHGen()->CreateMG_ADAPT();
3021 bool isCreation = false;
3022 ( new SMESHGUI_MG_ADAPTDRIVER( this, model, isCreation ))->show();
3026 #ifndef DISABLE_HOMARD_ADAPT
3027 case SMESHOp::OpHomardAdapt:
3029 if ( isStudyLocked() )
3031 EmitSignalDeactivateDialog();
3033 SALOME::GenericObj_wrap< SMESHHOMARD::HOMARD_Gen > homardGen;
3035 homardGen = GetSMESHGen()->CreateHOMARD_ADAPT();
3037 catch ( const SALOME::SALOME_Exception& S_ex ) {
3038 SUIT_MessageBox::critical(SMESHGUI::desktop(),
3039 QObject::tr("SMESH_ERROR"),
3040 QObject::tr(S_ex.details.text.in()));
3042 if (!homardGen->_is_nil()) {
3043 SMESHGUI_HomardAdaptDlg *aDlg = new SMESHGUI_HomardAdaptDlg(homardGen);
3050 case SMESHOp::OpSplitBiQuadratic:
3051 case SMESHOp::OpConvertMeshToQuadratic:
3052 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3053 case SMESHOp::OpReorientFaces:
3054 case SMESHOp::OpCreateGeometryGroup:
3056 if ( warnOnGeomModif() )
3057 break; // action forbidden as geometry modified
3058 startOperation( theCommandID );
3061 case SMESHOp::OpCreateGroup:
3065 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3069 if(isStudyLocked()) break;
3070 if ( warnOnGeomModif() )
3071 break; // action forbidden as geometry modified
3072 EmitSignalDeactivateDialog();
3073 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3075 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3076 SALOME_ListIO selected;
3078 aSel->selectedObjects( selected );
3080 int nbSel = selected.Extent();
3082 // check if mesh is selected
3083 aMesh = SMESH::GetMeshByIO( selected.First() );
3085 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3090 case SMESHOp::OpConstructGroup:
3094 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3098 if(isStudyLocked()) break;
3099 if ( warnOnGeomModif() )
3100 break; // action forbidden as geometry modified
3101 EmitSignalDeactivateDialog();
3103 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3104 SALOME_ListIO selected;
3106 aSel->selectedObjects( selected );
3108 int nbSel = selected.Extent();
3110 // check if submesh is selected
3111 Handle(SALOME_InteractiveObject) IObject = selected.First();
3112 if (IObject->hasEntry()) {
3113 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3115 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3116 if (!aSubMesh->_is_nil()) {
3118 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3119 // get submesh elements list by types
3120 SMESH::smIdType_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3121 SMESH::smIdType_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3122 SMESH::smIdType_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3123 SMESH::smIdType_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3124 // create group for each type o elements
3125 QString aName = IObject->getName();
3126 QStringList anEntryList;
3127 if (aNodes->length() > 0) {
3128 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3129 aGroup->Add(aNodes.inout());
3130 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3131 anEntryList.append( aSObject->GetID().c_str() );
3133 if (aEdges->length() > 0) {
3134 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3135 aGroup->Add(aEdges.inout());
3136 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3137 anEntryList.append( aSObject->GetID().c_str() );
3139 if (aFaces->length() > 0) {
3140 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3141 aGroup->Add(aFaces.inout());
3142 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3143 anEntryList.append( aSObject->GetID().c_str() );
3145 if (aVolumes->length() > 0) {
3146 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3147 aGroup->Add(aVolumes.inout());
3148 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3149 anEntryList.append( aSObject->GetID().c_str() );
3152 anApp->browseObjects( anEntryList );
3154 catch(const SALOME::SALOME_Exception & S_ex){
3155 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3162 SUIT_MessageBox::warning(desktop(),
3163 tr("SMESH_WRN_WARNING"),
3164 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3169 case SMESHOp::OpEditGroup:
3173 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3177 if(isStudyLocked()) break;
3178 if ( warnOnGeomModif() )
3179 break; // action forbidden as geometry modified
3180 EmitSignalDeactivateDialog();
3182 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3183 SALOME_ListIO selected;
3185 aSel->selectedObjects( selected );
3187 SALOME_ListIteratorOfListIO It (selected);
3188 int nbSelectedGroups = 0;
3189 for ( ; It.More(); It.Next() )
3191 SMESH::SMESH_GroupBase_var aGroup =
3192 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3193 if (!aGroup->_is_nil()) {
3195 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3199 if (nbSelectedGroups == 0)
3201 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3207 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3209 if(isStudyLocked()) break;
3210 if (myState == 800) {
3211 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3212 if (aDlg) aDlg->onAdd();
3217 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3219 if(isStudyLocked()) break;
3220 if (myState == 800) {
3221 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3222 if (aDlg) aDlg->onRemove();
3227 case SMESHOp::OpEditGeomGroupAsGroup:
3231 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3235 if(isStudyLocked()) break;
3236 EmitSignalDeactivateDialog();
3238 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3239 SALOME_ListIO selected;
3241 aSel->selectedObjects( selected );
3243 SALOME_ListIteratorOfListIO It (selected);
3244 for ( ; It.More(); It.Next() )
3246 SMESH::SMESH_GroupOnGeom_var aGroup =
3247 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3248 if (!aGroup->_is_nil()) {
3249 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3254 SMESH::SMESH_GroupOnFilter_var aGroup =
3255 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3256 if (!aGroup->_is_nil()) {
3257 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3265 case SMESHOp::OpUnionGroups:
3266 case SMESHOp::OpIntersectGroups:
3267 case SMESHOp::OpCutGroups:
3271 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3275 if ( isStudyLocked() )
3277 if ( warnOnGeomModif() )
3278 break; // action forbidden as geometry modified
3280 EmitSignalDeactivateDialog();
3282 SMESHGUI_GroupOpDlg* aDlg = 0;
3283 if ( theCommandID == SMESHOp::OpUnionGroups )
3284 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3285 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3286 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3288 aDlg = new SMESHGUI_CutGroupsDlg( this );
3295 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3297 if ( isStudyLocked() )
3299 if ( warnOnGeomModif() )
3300 break; // action forbidden as geometry modified
3302 EmitSignalDeactivateDialog();
3303 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3309 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3311 if ( isStudyLocked() )
3313 if ( warnOnGeomModif() )
3314 break; // action forbidden as geometry modified
3316 EmitSignalDeactivateDialog();
3317 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3323 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3327 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3331 if ( isStudyLocked() )
3334 EmitSignalDeactivateDialog();
3336 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3340 case SMESHOp::OpMeshInformation:
3341 case SMESHOp::OpWhatIs:
3343 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3344 EmitSignalDeactivateDialog();
3345 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3346 SALOME_ListIO selected;
3348 aSel->selectedObjects( selected );
3350 if ( selected.Extent() > 1 ) { // a dlg for each IO
3351 SALOME_ListIteratorOfListIO It( selected );
3352 for ( ; It.More(); It.Next() ) {
3353 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3354 dlg->showInfo( It.Value() );
3359 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3365 case SMESHOp::OpFindElementByPoint:
3367 startOperation( theCommandID );
3371 case SMESHOp::OpEditHypothesis:
3373 if(isStudyLocked()) break;
3374 if ( warnOnGeomModif() )
3375 break; // action forbidden as geometry modified
3377 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3378 SALOME_ListIO selected;
3380 aSel->selectedObjects( selected );
3382 int nbSel = selected.Extent();
3385 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3386 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3388 if ( !aHypothesis->_is_nil() )
3390 SMESHGUI_GenericHypothesisCreator* aCreator =
3391 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3394 // set geometry of mesh and sub-mesh to aCreator
3395 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3396 if ( selected.Extent() == 1 )
3398 QString subGeomID, meshGeomID;
3399 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3400 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3402 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3403 aCreator->setShapeEntry( subGeomID );
3404 aCreator->setMainShapeEntry( meshGeomID );
3408 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3418 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3420 if(isStudyLocked()) break;
3421 if ( warnOnGeomModif() )
3422 break; // action forbidden as geometry modified
3423 SUIT_OverrideCursor wc;
3425 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3426 SALOME_ListIO selected;
3428 aSel->selectedObjects( selected, QString::null, false );
3430 SALOME_ListIteratorOfListIO It(selected);
3431 for (int i = 0; It.More(); It.Next(), i++) {
3432 Handle(SALOME_InteractiveObject) IObject = It.Value();
3433 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3436 aSel->setSelectedObjects( l1 );
3441 case SMESHOp::OpElem0D:
3442 case SMESHOp::OpBall:
3443 case SMESHOp::OpEdge:
3444 case SMESHOp::OpTriangle:
3445 case SMESHOp::OpQuadrangle:
3446 case SMESHOp::OpPolygon:
3447 case SMESHOp::OpTetrahedron:
3448 case SMESHOp::OpHexahedron:
3449 case SMESHOp::OpPentahedron:
3450 case SMESHOp::OpPyramid:
3451 case SMESHOp::OpHexagonalPrism:
3453 if(isStudyLocked()) break;
3454 if ( warnOnGeomModif() )
3455 break; // action forbidden as geometry modified
3457 EmitSignalDeactivateDialog();
3458 SMDSAbs_EntityType type = SMDSEntity_Edge;
3459 switch (theCommandID) {
3460 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3461 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3462 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3463 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3464 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3465 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3466 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3467 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3468 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3469 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3472 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3475 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3479 case SMESHOp::OpPolyhedron:
3481 if(isStudyLocked()) break;
3482 if ( warnOnGeomModif() )
3483 break; // action forbidden as geometry modified
3485 EmitSignalDeactivateDialog();
3486 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3489 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3493 case SMESHOp::OpQuadraticEdge:
3494 case SMESHOp::OpQuadraticTriangle:
3495 case SMESHOp::OpBiQuadraticTriangle:
3496 case SMESHOp::OpQuadraticQuadrangle:
3497 case SMESHOp::OpBiQuadraticQuadrangle:
3498 case SMESHOp::OpQuadraticPolygon:
3499 case SMESHOp::OpQuadraticTetrahedron:
3500 case SMESHOp::OpQuadraticPyramid:
3501 case SMESHOp::OpQuadraticPentahedron:
3502 case SMESHOp::OpBiQuadraticPentahedron:
3503 case SMESHOp::OpQuadraticHexahedron:
3504 case SMESHOp::OpTriQuadraticHexahedron:
3506 if(isStudyLocked()) break;
3507 if ( warnOnGeomModif() )
3508 break; // action forbidden as geometry modified
3510 EmitSignalDeactivateDialog();
3511 SMDSAbs_EntityType type = SMDSEntity_Last;
3513 switch (theCommandID) {
3514 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3515 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3516 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3517 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3518 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3519 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3520 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3521 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3522 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3523 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3524 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3525 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3528 if ( type != SMDSEntity_Last )
3529 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3532 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3533 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3537 case SMESHOp::OpRemoveNodes:
3539 if(isStudyLocked()) break;
3540 if ( warnOnGeomModif() )
3541 break; // action forbidden as geometry modified
3543 EmitSignalDeactivateDialog();
3544 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3547 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3548 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3552 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3554 if(isStudyLocked()) break;
3555 if ( warnOnGeomModif() )
3556 break; // action forbidden as geometry modified
3558 EmitSignalDeactivateDialog();
3559 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3563 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3564 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3568 case SMESHOp::OpClearMesh: {
3570 if(isStudyLocked()) break;
3571 if ( warnOnGeomModif() )
3572 break; // action forbidden as geometry modified
3574 SALOME_ListIO selected;
3575 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3576 aSel->selectedObjects( selected );
3578 SUIT_OverrideCursor wc;
3579 SALOME_ListIteratorOfListIO It (selected);
3580 for ( ; It.More(); It.Next() )
3582 Handle(SALOME_InteractiveObject) IOS = It.Value();
3583 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3584 if ( aMesh->_is_nil()) continue;
3587 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3588 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3589 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3590 // hide groups and submeshes
3591 _PTR(ChildIterator) anIter =
3592 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3593 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3595 _PTR(SObject) so = anIter->Value();
3596 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3599 catch (const SALOME::SALOME_Exception& S_ex){
3601 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3605 SMESH::UpdateView();
3609 case SMESHOp::OpRemoveOrphanNodes:
3611 if(isStudyLocked()) break;
3612 if ( warnOnGeomModif() )
3613 break; // action forbidden as geometry modified
3614 SALOME_ListIO selected;
3615 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3616 aSel->selectedObjects( selected );
3617 if ( selected.Extent() == 1 ) {
3618 Handle(SALOME_InteractiveObject) anIO = selected.First();
3619 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3620 if ( !aMesh->_is_nil() ) {
3621 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3622 tr( "SMESH_WARNING" ),
3623 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3624 SUIT_MessageBox::Yes |
3625 SUIT_MessageBox::No,
3626 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3629 SUIT_OverrideCursor wc;
3630 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3631 smIdType removed = aMeshEditor->RemoveOrphanNodes();
3632 SUIT_MessageBox::information(SMESHGUI::desktop(),
3633 tr("SMESH_INFORMATION"),
3634 tr("NB_NODES_REMOVED").arg(removed));
3635 if ( removed > 0 ) {
3636 SMESH::UpdateView();
3637 SMESHGUI::Modified();
3640 catch (const SALOME::SALOME_Exception& S_ex) {
3641 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3650 case SMESHOp::OpRenumberingNodes:
3652 if(isStudyLocked()) break;
3653 if ( warnOnGeomModif() )
3654 break; // action forbidden as geometry modified
3656 EmitSignalDeactivateDialog();
3657 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3661 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3662 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3666 case SMESHOp::OpRenumberingElements:
3668 if(isStudyLocked()) break;
3669 if ( warnOnGeomModif() )
3670 break; // action forbidden as geometry modified
3672 EmitSignalDeactivateDialog();
3673 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3677 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3678 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3682 case SMESHOp::OpTranslation:
3684 if(isStudyLocked()) break;
3685 if ( warnOnGeomModif() )
3686 break; // action forbidden as geometry modified
3688 EmitSignalDeactivateDialog();
3689 ( new SMESHGUI_TranslationDlg( this ) )->show();
3692 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3693 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3697 case SMESHOp::OpRotation:
3699 if(isStudyLocked()) break;
3700 if ( warnOnGeomModif() )
3701 break; // action forbidden as geometry modified
3703 EmitSignalDeactivateDialog();
3704 ( new SMESHGUI_RotationDlg( this ) )->show();
3707 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3708 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3712 case SMESHOp::OpSymmetry:
3714 if(isStudyLocked()) break;
3715 if ( warnOnGeomModif() )
3716 break; // action forbidden as geometry modified
3718 EmitSignalDeactivateDialog();
3719 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3722 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3723 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3727 case SMESHOp::OpScale:
3729 if(isStudyLocked()) break;
3730 if ( warnOnGeomModif() )
3731 break; // action forbidden as geometry modified
3733 EmitSignalDeactivateDialog();
3734 ( new SMESHGUI_ScaleDlg( this ) )->show();
3737 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3738 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3743 case SMESHOp::OpOffset:
3745 if(isStudyLocked()) break;
3746 if ( warnOnGeomModif() )
3747 break; // action forbidden as geometry modified
3749 EmitSignalDeactivateDialog();
3750 ( new SMESHGUI_OffsetDlg( this ) )->show();
3753 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3754 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3759 case SMESHOp::OpSewing:
3761 if(isStudyLocked()) break;
3762 if ( warnOnGeomModif() )
3763 break; // action forbidden as geometry modified
3765 EmitSignalDeactivateDialog();
3766 ( new SMESHGUI_SewingDlg( this ) )->show();
3769 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3770 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3774 case SMESHOp::OpMergeNodes:
3776 if(isStudyLocked()) break;
3777 if ( warnOnGeomModif() )
3778 break; // action forbidden as geometry modified
3780 EmitSignalDeactivateDialog();
3781 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3784 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3785 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3789 case SMESHOp::OpMergeElements:
3791 if (isStudyLocked()) break;
3792 if ( warnOnGeomModif() )
3793 break; // action forbidden as geometry modified
3795 EmitSignalDeactivateDialog();
3796 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3798 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3799 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3804 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3805 if ( warnOnGeomModif() )
3806 break; // action forbidden as geometry modified
3807 startOperation( SMESHOp::OpMoveNode );
3810 case SMESHOp::OpDuplicateNodes:
3812 if(isStudyLocked()) break;
3813 if ( warnOnGeomModif() )
3814 break; // action forbidden as geometry modified
3816 EmitSignalDeactivateDialog();
3817 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3820 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3821 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3826 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3827 if ( warnOnGeomModif() )
3828 break; // action forbidden as geometry modified
3829 startOperation( SMESHOp::OpElem0DOnElemNodes );
3832 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3834 static QList<int> aTypes;
3835 if ( aTypes.isEmpty() )
3837 aTypes.append( SMESH::NODE );
3838 aTypes.append( SMESH::EDGE );
3839 aTypes.append( SMESH::FACE );
3840 aTypes.append( SMESH::VOLUME );
3842 if (!myFilterLibraryDlg)
3843 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3844 else if (myFilterLibraryDlg->isHidden())
3845 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3846 myFilterLibraryDlg->raise();
3850 case SMESHOp::OpFreeNode:
3851 case SMESHOp::OpEqualNode:
3852 case SMESHOp::OpNodeConnectivityNb:
3853 case SMESHOp::OpFreeEdge:
3854 case SMESHOp::OpFreeBorder:
3855 case SMESHOp::OpLength:
3856 case SMESHOp::OpConnection:
3857 case SMESHOp::OpEqualEdge:
3858 case SMESHOp::OpFreeFace:
3859 case SMESHOp::OpBareBorderFace:
3860 case SMESHOp::OpOverConstrainedFace:
3861 case SMESHOp::OpLength2D:
3862 case SMESHOp::OpDeflection2D:
3863 case SMESHOp::OpConnection2D:
3864 case SMESHOp::OpArea:
3865 case SMESHOp::OpTaper:
3866 case SMESHOp::OpAspectRatio:
3867 case SMESHOp::OpMinimumAngle:
3868 case SMESHOp::OpWarpingAngle:
3869 case SMESHOp::OpSkew:
3870 case SMESHOp::OpMaxElementLength2D:
3871 case SMESHOp::OpEqualFace:
3872 case SMESHOp::OpAspectRatio3D:
3873 case SMESHOp::OpVolume:
3874 case SMESHOp::OpMaxElementLength3D:
3875 case SMESHOp::OpBareBorderVolume:
3876 case SMESHOp::OpOverConstrainedVolume:
3877 case SMESHOp::OpEqualVolume:
3880 LightApp_SelectionMgr* mgr = selectionMgr();
3881 SALOME_ListIO selected; mgr->selectedObjects( selected );
3883 if( !selected.IsEmpty() ) {
3884 SUIT_OverrideCursor wc;
3885 ::Control( theCommandID );
3888 SUIT_MessageBox::warning(desktop(),
3889 tr( "SMESH_WRN_WARNING" ),
3890 tr( "SMESH_BAD_SELECTION" ) );
3894 SUIT_MessageBox::warning(desktop(),
3895 tr( "SMESH_WRN_WARNING" ),
3896 tr( "NOT_A_VTK_VIEWER" ) );
3899 case SMESHOp::OpOverallMeshQuality:
3900 OverallMeshQuality();
3902 case SMESHOp::OpNumberingNodes:
3904 SUIT_OverrideCursor wc;
3905 LightApp_SelectionMgr* mgr = selectionMgr();
3906 SALOME_ListIO selected; mgr->selectedObjects( selected );
3908 SALOME_ListIteratorOfListIO it(selected);
3909 for( ; it.More(); it.Next()) {
3910 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3911 if(anIObject->hasEntry()) {
3912 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3913 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3919 case SMESHOp::OpNumberingElements:
3921 SUIT_OverrideCursor wc;
3922 LightApp_SelectionMgr* mgr = selectionMgr();
3923 SALOME_ListIO selected; mgr->selectedObjects( selected );
3925 SALOME_ListIteratorOfListIO it(selected);
3926 for( ; it.More(); it.Next()) {
3927 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3928 if(anIObject->hasEntry())
3929 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3930 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3935 case SMESHOp::OpPropertiesLength:
3936 case SMESHOp::OpPropertiesArea:
3937 case SMESHOp::OpPropertiesVolume:
3938 case SMESHOp::OpMinimumDistance:
3939 case SMESHOp::OpBoundingBox:
3940 case SMESHOp::OpAngle:
3942 int page = SMESHGUI_MeasureDlg::MinDistance;
3943 if ( theCommandID == SMESHOp::OpBoundingBox )
3944 page = SMESHGUI_MeasureDlg::BoundingBox;
3945 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3946 page = SMESHGUI_MeasureDlg::Length;
3947 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3948 page = SMESHGUI_MeasureDlg::Area;
3949 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3950 page = SMESHGUI_MeasureDlg::Volume;
3951 else if ( theCommandID == SMESHOp::OpAngle )
3952 page = SMESHGUI_MeasureDlg::Angle;
3954 EmitSignalDeactivateDialog();
3955 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3959 case SMESHOp::OpSortChild:
3962 case SMESHOp::OpBreakLink:
3963 ::breakShaperLink();
3968 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3969 //updateObjBrowser();
3973 //=============================================================================
3977 //=============================================================================
3978 bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3983 //=============================================================================
3987 //=============================================================================
3988 bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3993 //=============================================================================
3997 //=============================================================================
3998 bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
4003 //=============================================================================
4004 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
4005 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
4007 //=============================================================================
4008 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
4009 SUIT_ViewWindow* wnd )
4011 if(theIO->hasEntry()){
4012 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
4013 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
4017 //=======================================================================
4018 // function : createSMESHAction
4020 //=======================================================================
4021 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
4022 const int key, const bool toggle, const QString& shortcutAction )
4025 QWidget* parent = application()->desktop();
4026 SUIT_ResourceMgr* resMgr = resourceMgr();
4028 if ( !icon_id.isEmpty() )
4029 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4031 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICON_%1" ).arg( po_id ).toLatin1().data() ), false );
4032 if ( !pix.isNull() )
4033 icon = QIcon( pix );
4035 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4036 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4037 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4039 createAction( id, tooltip, icon, menu, status_bar, key, parent,
4040 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4043 //=======================================================================
4044 // function : createPopupItem
4046 //=======================================================================
4047 void SMESHGUI::createPopupItem( const int id,
4048 const QString& clients,
4049 const QString& types,
4050 const QString& theRule,
4053 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4054 popupMgr()->insert( action( id ), pId, 0 );
4056 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4057 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4058 QString rule = "(%1) and (%2) and (%3)";
4059 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4060 if( clients.isEmpty() )
4061 rule = rule.arg( QString( "true" ) );
4063 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4064 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4067 bool cont = myRules.contains( id );
4069 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4071 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4072 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4075 //=======================================================================
4076 // function : initialize
4078 //=======================================================================
4079 void SMESHGUI::initialize( CAM_Application* app )
4081 SalomeApp_Module::initialize( app );
4083 // SUIT_ResourceMgr* mgr = app->resourceMgr();
4085 /* Automatic Update flag */
4086 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4088 // ----- create actions --------------
4090 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4091 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4092 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4093 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
4095 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4097 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
4098 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4099 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4100 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
4102 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4104 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
4106 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
4107 createSMESHAction( SMESHOp::OpExportMED, "MED" );
4108 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
4109 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
4111 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4113 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
4114 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4115 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4116 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4117 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4119 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4121 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
4122 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4123 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
4124 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4125 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
4126 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
4127 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
4128 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
4129 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
4130 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
4131 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
4132 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
4133 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
4134 createSMESHAction( SMESHOp::OpRecompute, "RE_COMPUTE", "ICON_COMPUTE" );
4135 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
4136 createSMESHAction( SMESHOp::OpShowErrors, "SHOW_ERRORS", "ICON_SHOW_ERRORS" );
4137 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
4138 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
4139 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
4140 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
4141 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
4142 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
4143 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4144 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
4145 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
4146 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
4147 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
4148 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
4149 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
4150 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4151 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
4152 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
4153 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
4154 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4155 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
4157 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
4158 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
4159 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
4160 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
4161 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
4162 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
4163 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
4164 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
4165 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
4166 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
4167 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
4168 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
4169 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
4170 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
4171 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
4172 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
4173 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
4174 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
4175 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
4176 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
4177 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
4178 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
4179 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
4180 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4181 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4182 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4183 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4184 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4185 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4187 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4188 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4189 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4190 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4191 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4192 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4193 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4194 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4195 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4196 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4197 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4198 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4199 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4200 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4201 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4202 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4203 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4204 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4205 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4206 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4207 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4208 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4209 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4210 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4211 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4212 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4214 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4215 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4216 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4217 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4219 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4220 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4222 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4223 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4224 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4225 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4226 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4227 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4228 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4229 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4230 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4231 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4232 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4233 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4234 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4235 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4236 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4237 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4238 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4239 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4240 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4241 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4242 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4243 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4244 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4245 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4246 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4248 createSMESHAction( SMESHOp::OpReset, "RESET" );
4249 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4250 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4251 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4252 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4253 #ifndef DISABLE_PLOT2DVIEWER
4254 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4256 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4257 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4258 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4259 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4260 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4261 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4262 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4263 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4264 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4265 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4266 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4267 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4268 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4270 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4271 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4273 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4274 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4275 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4276 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4277 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4278 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4279 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4280 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4281 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4283 // Adaptation - begin
4284 #ifndef DISABLE_MG_ADAPT
4285 createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
4287 #ifndef DISABLE_HOMARD_ADAPT
4288 createSMESHAction( SMESHOp::OpHomardAdapt, "HOMARD_ADAPT", "ICON_HOMARD_ADAPT" );
4292 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4293 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4294 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4295 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4296 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4297 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4299 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4300 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4301 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4303 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4305 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4307 QList<int> aCtrlActions;
4308 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4309 << SMESHOp::OpNodeConnectivityNb // node controls
4310 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4311 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4312 << SMESHOp::OpDeflection2D
4313 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4314 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4315 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4316 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4317 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4318 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4319 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4320 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4321 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4322 aCtrlGroup->setExclusive( true );
4323 for( int i = 0; i < aCtrlActions.size(); i++ )
4324 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4326 // ----- create menu --------------
4327 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4328 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4329 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4330 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4331 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4332 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4333 #if !defined(DISABLE_MG_ADAPT) || !defined(DISABLE_HOMARD_ADAPT)
4334 adaptId = createMenu( tr( "MEN_ADAPT" ), -1, 80, 10 ),
4336 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4337 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4339 createMenu( separator(), fileId );
4341 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4342 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4343 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4344 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4345 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4346 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4347 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4348 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4349 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4350 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4351 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4352 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4353 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4355 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4356 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4357 createMenu( SMESHOp::OpImportMED, importId, -1 );
4358 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4360 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4362 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4363 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4364 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4365 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4366 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4368 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4370 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4371 createMenu( separator(), fileId, 10 );
4373 createMenu( SMESHOp::OpDelete, editId, -1 );
4375 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4377 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4378 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4379 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4380 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4381 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4382 createMenu( separator(), meshId, -1 );
4383 createMenu( SMESHOp::OpCompute, meshId, -1 );
4384 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4385 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4386 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4387 createMenu( separator(), meshId, -1 );
4388 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4389 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4390 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4391 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4392 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4393 createMenu( separator(), meshId, -1 );
4394 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4395 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4396 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4397 createMenu( separator(), meshId, -1 );
4398 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4399 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4400 createMenu( separator(), meshId, -1 );
4401 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4402 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4403 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4404 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4405 createMenu( separator(), meshId, -1 );
4407 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4408 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4409 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4410 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4411 createMenu( SMESHOp::OpLength, edgeId, -1 );
4412 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4413 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4414 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4415 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4416 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4417 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4418 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4419 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4420 createMenu( SMESHOp::OpArea, faceId, -1 );
4421 createMenu( SMESHOp::OpTaper, faceId, -1 );
4422 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4423 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4424 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4425 createMenu( SMESHOp::OpSkew, faceId, -1 );
4426 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4427 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4428 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4429 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4430 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4431 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4432 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4433 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4434 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4435 createMenu( separator(), ctrlId, -1 );
4436 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4437 createMenu( separator(), ctrlId, -1 );
4438 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4440 createMenu( SMESHOp::OpNode, addId, -1 );
4441 createMenu( SMESHOp::OpElem0D, addId, -1 );
4442 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4443 createMenu( SMESHOp::OpBall, addId, -1 );
4444 createMenu( SMESHOp::OpEdge, addId, -1 );
4445 createMenu( SMESHOp::OpTriangle, addId, -1 );
4446 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4447 createMenu( SMESHOp::OpPolygon, addId, -1 );
4448 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4449 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4450 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4451 createMenu( SMESHOp::OpPyramid, addId, -1 );
4452 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4453 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4454 createMenu( separator(), addId, -1 );
4455 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4456 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4457 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4458 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4459 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4460 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4461 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4462 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4463 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4464 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4465 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4466 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4468 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4469 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4470 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4471 createMenu( separator(), removeId, -1 );
4472 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4473 createMenu( separator(), removeId, -1 );
4474 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4476 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4477 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4479 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4480 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4481 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4482 createMenu( SMESHOp::OpRotation, transfId, -1 );
4483 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4484 createMenu( SMESHOp::OpScale, transfId, -1 );
4485 createMenu( SMESHOp::OpOffset, transfId, -1 );
4486 createMenu( SMESHOp::OpSewing, transfId, -1 );
4487 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4489 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4490 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4491 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4492 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4493 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4494 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4495 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4496 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4497 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4498 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4499 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4500 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4501 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4502 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4503 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4504 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4506 // Adaptation - begin
4507 #ifndef DISABLE_MG_ADAPT
4508 createMenu( SMESHOp::OpMGAdapt, adaptId, -1 );
4510 #ifndef DISABLE_HOMARD_ADAPT
4511 createMenu( SMESHOp::OpHomardAdapt, adaptId, -1 );
4515 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4516 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4517 createMenu( SMESHOp::OpAngle, measureId, -1 );
4518 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4519 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4520 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4521 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4523 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4524 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4525 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4526 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4528 // ----- create toolbars --------------
4529 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ) ;
4530 createTool( SMESHOp::OpCreateMesh, meshTb );
4531 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4532 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4533 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4534 createTool( SMESHOp::OpCopyMesh, meshTb );
4535 createTool( separator(), meshTb );
4536 createTool( SMESHOp::OpCompute, meshTb );
4537 createTool( SMESHOp::OpPreCompute, meshTb );
4538 createTool( SMESHOp::OpEvaluate, meshTb );
4539 createTool( SMESHOp::OpMeshOrder, meshTb );
4541 int infoTb = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ) ;
4542 createTool( SMESHOp::OpMeshInformation, infoTb );
4543 //createTool( SMESHOp::OpStdInfo, meshTb );
4544 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4545 createTool( SMESHOp::OpFindElementByPoint, infoTb );
4547 int groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ) ;
4548 createTool( SMESHOp::OpCreateGroup, groupTb );
4549 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4550 createTool( SMESHOp::OpConstructGroup, groupTb );
4551 createTool( SMESHOp::OpEditGroup, groupTb );
4553 int ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ) ;
4554 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4555 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4556 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4558 int ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ) ;
4559 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4560 createTool( SMESHOp::OpLength, ctrl1dTb );
4561 createTool( SMESHOp::OpConnection, ctrl1dTb );
4562 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4564 int ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ) ;
4565 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4566 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4567 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4568 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4569 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4570 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4571 createTool( SMESHOp::OpArea, ctrl2dTb );
4572 createTool( SMESHOp::OpTaper, ctrl2dTb );
4573 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4574 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4575 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4576 createTool( SMESHOp::OpSkew, ctrl2dTb );
4577 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4578 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4579 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4581 int ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ) ;
4582 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4583 createTool( SMESHOp::OpVolume, ctrl3dTb );
4584 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4585 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4586 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4587 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4589 int addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ) ;
4590 createTool( SMESHOp::OpNode, addElemTb );
4591 createTool( SMESHOp::OpElem0D, addElemTb );
4592 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4593 createTool( SMESHOp::OpBall, addElemTb );
4594 createTool( SMESHOp::OpEdge, addElemTb );
4595 createTool( SMESHOp::OpTriangle, addElemTb );
4596 createTool( SMESHOp::OpQuadrangle, addElemTb );
4597 createTool( SMESHOp::OpPolygon, addElemTb );
4598 createTool( SMESHOp::OpTetrahedron, addElemTb );
4599 createTool( SMESHOp::OpHexahedron, addElemTb );
4600 createTool( SMESHOp::OpPentahedron, addElemTb );
4601 createTool( SMESHOp::OpPyramid, addElemTb );
4602 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4603 createTool( SMESHOp::OpPolyhedron, addElemTb );
4605 int addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ) ;
4606 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4607 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4608 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4609 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4610 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4611 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4612 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4613 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4614 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4615 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4616 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4617 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4619 int remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ) ;
4620 createTool( SMESHOp::OpRemoveNodes, remTb );
4621 createTool( SMESHOp::OpRemoveElements, remTb );
4622 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4623 createTool( SMESHOp::OpClearMesh, remTb );
4625 // int renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ) ;
4626 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4627 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4629 int transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ) ;
4630 createTool( SMESHOp::OpMergeNodes, transformTb );
4631 createTool( SMESHOp::OpMergeElements, transformTb );
4632 createTool( SMESHOp::OpTranslation, transformTb );
4633 createTool( SMESHOp::OpRotation, transformTb );
4634 createTool( SMESHOp::OpSymmetry, transformTb );
4635 createTool( SMESHOp::OpScale, transformTb );
4636 createTool( SMESHOp::OpOffset, transformTb );
4637 createTool( SMESHOp::OpSewing, transformTb );
4638 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4640 int modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ) ;
4641 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4642 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4643 createTool( SMESHOp::OpExtrusion, modifyTb );
4644 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4645 createTool( SMESHOp::OpRevolution, modifyTb );
4646 createTool( SMESHOp::OpOrientation, modifyTb );
4647 createTool( SMESHOp::OpReorientFaces, modifyTb );
4648 createTool( SMESHOp::OpMoveNode, modifyTb );
4649 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4650 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4651 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4652 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4653 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4654 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4655 createTool( SMESHOp::OpSmoothing, modifyTb );
4656 createTool( SMESHOp::OpPatternMapping, modifyTb );
4658 // Adaptation - begin
4659 #if !defined(DISABLE_MG_ADAPT) || !defined(DISABLE_HOMARD_ADAPT)
4660 int adaptTb = createTool( tr( "TB_ADAPTATION" ), QString( "SMESHAdaptationToolbar" ) ) ;
4662 #ifndef DISABLE_MG_ADAPT
4663 createTool( SMESHOp::OpMGAdapt, adaptTb );
4665 #ifndef DISABLE_HOMARD_ADAPT
4666 createTool( SMESHOp::OpHomardAdapt, adaptTb );
4670 int measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ) ;
4671 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4673 int dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4674 createTool( SMESHOp::OpUpdate, dispModeTb );
4676 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4677 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4681 OB = "'ObjectBrowser'",
4682 View = "'" + SVTK_Viewer::Type() + "'",
4684 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4685 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4686 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4687 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4688 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4689 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4690 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4691 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4692 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4693 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4694 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4695 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4697 mesh_part = mesh + " " + subMesh + " " + group,
4698 mesh_group = mesh + " " + group,
4699 mesh_submesh = mesh + " " + subMesh,
4700 hyp_alg = hypo + " " + algo;
4702 // popup for object browser
4704 isInvisible("not( isVisible )"),
4705 isEmpty("numberOfNodes = 0"),
4706 isNotEmpty("numberOfNodes <> 0"),
4708 // has nodes, edges, etc in VISIBLE! actor
4709 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4710 hasElems("(count( elemTypes ) > 0)"),
4711 hasDifferentElems("(count( elemTypes ) > 1)"),
4712 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4713 hasBalls("({'BallElem'} in elemTypes)"),
4714 hasElems0d("({'Elem0d'} in elemTypes)"),
4715 hasEdges("({'Edge'} in elemTypes)"),
4716 hasFaces("({'Face'} in elemTypes)"),
4717 hasVolumes("({'Volume'} in elemTypes)"),
4718 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4720 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4721 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4722 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && hasAlgo && hasGeomReference" );
4723 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4724 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4725 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4727 popupMgr()->insert( separator(), -1, 0 );
4728 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4729 createPopupItem( SMESHOp::OpRecompute, OB, mesh, "&& selcount=1 && hasAlgo && (" + isNotEmpty + " || hasErrors )");
4730 createPopupItem( SMESHOp::OpShowErrors, OB, mesh, "&& selcount=1 && hasErrors" );
4731 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
4732 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );
4733 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4734 popupMgr()->insert( separator(), -1, 0 );
4735 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4736 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4737 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1 && " + hasElems );
4738 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4739 popupMgr()->insert( separator(), -1, 0 );
4740 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4741 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4742 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4743 popupMgr()->insert( separator(), -1, 0 );
4744 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4745 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4746 popupMgr()->insert( separator(), -1, 0 );
4747 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
4748 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4750 // Adaptation - begin
4751 popupMgr()->insert( separator(), -1, 0 );
4752 #ifndef DISABLE_MG_ADAPT
4753 createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
4755 #ifndef DISABLE_HOMARD_ADAPT
4756 createPopupItem( SMESHOp::OpHomardAdapt, OB, mesh );
4758 popupMgr()->insert( separator(), -1, 0 );
4761 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4762 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4763 QString only_one_2D = only_one_non_empty + " && dim>1";
4765 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4766 popupMgr()->findMenu( anId )->menuAction()->setIcon( resourceMgr()->loadPixmap( "SMESH", tr( "ICON_EXPORT" )));
4767 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4768 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4769 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4771 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4773 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4774 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4776 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4777 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4778 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4779 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4781 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4783 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4784 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4785 popupMgr()->insert( separator(), -1, 0 );
4787 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4788 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4789 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4792 createPopupItem( SMESHOp::OpEditGroup, View, group );
4793 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4794 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4796 popupMgr()->insert( separator(), -1, 0 );
4797 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4798 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4799 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh, "&& " + hasElems);
4800 popupMgr()->insert( separator(), -1, 0 );
4802 createPopupItem( SMESHOp::OpUpdate, OB + " " + View, mesh_part );
4803 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4804 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4805 popupMgr()->insert( separator(), -1, 0 );
4807 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4808 QString aType = QString( "%1type in {%2}" ).arg( lc );
4809 aType = aType.arg( mesh_part );
4810 QString aMeshInVTK = aClient + "&&" + aType;
4812 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4813 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4814 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4816 //-------------------------------------------------
4818 //-------------------------------------------------
4819 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4821 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4822 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4823 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4825 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4826 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4827 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4829 popupMgr()->insert( separator(), -1, -1 );
4831 //-------------------------------------------------
4833 //-------------------------------------------------
4834 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4836 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4837 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4838 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4840 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4841 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4842 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4844 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4845 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4846 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4848 popupMgr()->insert( separator(), anId, -1 );
4850 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4851 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4852 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4854 //-------------------------------------------------
4856 //-------------------------------------------------
4857 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4859 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4861 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4862 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4863 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4865 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4866 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4867 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4869 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4870 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4871 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4873 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4874 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4875 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4877 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4878 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4879 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4881 popupMgr()->insert( separator(), anId, -1 );
4883 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4884 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4886 popupMgr()->insert( separator(), anId, -1 );
4888 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4889 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4892 //-------------------------------------------------
4893 // Representation of the 2D Quadratic elements
4894 //-------------------------------------------------
4895 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4896 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4897 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4898 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4900 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4901 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4902 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4904 //-------------------------------------------------
4905 // Orientation of faces
4906 //-------------------------------------------------
4907 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4908 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4909 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4911 //-------------------------------------------------
4913 //-------------------------------------------------
4914 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4915 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4917 //-------------------------------------------------
4919 //-------------------------------------------------
4920 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4921 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4923 //-------------------------------------------------
4925 //-------------------------------------------------
4927 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4928 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4929 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4930 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4932 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4934 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4935 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4937 popupMgr()->insert( separator(), anId, -1 );
4939 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4941 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4942 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4943 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4945 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4946 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4947 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4949 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4950 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4951 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4953 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4955 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4956 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4957 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4959 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4960 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4961 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4963 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4964 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4965 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4966 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4967 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4968 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4970 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4972 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4973 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4974 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4976 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4977 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4978 QtxPopupMgr::VisibleRule );
4979 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4981 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4982 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4983 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4985 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4986 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4987 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4989 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4990 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4991 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4993 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4994 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4995 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4997 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4998 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4999 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
5001 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
5002 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5003 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
5005 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
5006 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5007 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
5009 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
5010 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5011 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
5013 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
5014 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5015 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
5017 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
5018 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5019 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
5021 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
5022 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5023 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
5025 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
5026 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5027 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
5029 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
5030 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
5031 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
5033 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
5035 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
5036 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5037 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
5039 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
5040 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5041 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
5043 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
5044 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5045 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5047 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5048 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5049 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5051 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5052 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5053 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5055 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
5056 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5057 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5059 popupMgr()->insert( separator(), anId, -1 );
5061 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5062 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5063 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5064 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5065 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5067 popupMgr()->insert( separator(), anId, -1 );
5069 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5071 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5072 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5074 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5075 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5076 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5078 #ifndef DISABLE_PLOT2DVIEWER
5079 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5080 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5083 //-------------------------------------------------
5085 //-------------------------------------------------
5086 popupMgr()->insert( separator(), -1, -1 );
5087 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5088 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5089 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5090 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5092 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5093 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5095 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5096 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5098 popupMgr()->insert( separator(), -1, -1 );
5100 //-------------------------------------------------
5102 //-------------------------------------------------
5103 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5104 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5106 popupMgr()->insert( separator(), -1, -1 );
5108 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5109 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5110 popupMgr()->insert( separator(), -1, -1 );
5112 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5113 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5115 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5116 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5118 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5119 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5122 //================================================================================
5124 * \brief Return true if SMESH or GEOM objects are selected.
5125 * Is called form LightApp_Module::activateModule() which clear selection if
5126 * not isSelectionCompatible()
5128 //================================================================================
5130 bool SMESHGUI::isSelectionCompatible()
5132 bool isCompatible = true;
5133 SALOME_ListIO selected;
5134 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5135 Sel->selectedObjects( selected );
5137 SALOME_ListIteratorOfListIO It( selected );
5138 for ( ; isCompatible && It.More(); It.Next())
5140 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
5141 ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5142 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
5144 return isCompatible;
5148 bool SMESHGUI::reusableOperation( const int id )
5150 // compute, evaluate and precompute are not reusable operations
5151 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate || id == SMESHOp::OpRecompute ) ? false : SalomeApp_Module::reusableOperation( id );
5156 QString wrap(const QString& text, const QString& tag)
5157 { return QString("<%1>%2</%3>").arg(tag).arg(text).arg(tag);}
5160 bool SMESHGUI::activateModule( SUIT_Study* study )
5162 bool res = SalomeApp_Module::activateModule( study );
5164 setMenuShown( true );
5165 setToolShown( true );
5167 // Fill in Help Panel
5168 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( application() );
5169 app->infoPanel()->setTitle(tr("INFO_WELCOME_TO_SMESH"));
5171 int gb = app->infoPanel()->addGroup(tr("INFO_GRP_CREATE_MESH"));
5174 lab = tr("INFO_DEFINE_ALGOS") + "<br/>";
5175 lab = lab + tr("INFO_DEFINE_HYPOS") + "<br/>";
5176 lab = lab + tr("INFO_COMPUTE") + "<br/>";
5177 lab = lab + tr("INFO_REFINE") + ":";
5178 items << wrap(tr("INFO_REFINE_LOCAL_SIZE"), "li")
5179 << wrap(tr("INFO_REFINE_SUBMESH"), "li");
5180 lab = lab + wrap(items.join(""), "ul");
5183 app->infoPanel()->addLabel(lab, gb);
5185 gb = app->infoPanel()->addGroup(tr("INFO_GRP_IMPORT_MESH"));
5186 items << wrap("UNV", "li")
5187 << wrap("MED", "li")
5188 << wrap("STL", "li")
5189 << wrap("CGNS", "li")
5190 << wrap("GMF", "li");
5191 lab = tr("INFO_AVAILABLE_FORMATS") + ":" + wrap(items.join(""), "ul");
5194 app->infoPanel()->addLabel(lab, gb);
5196 gb = app->infoPanel()->addGroup(tr("INFO_GRP_CHECK_MESH"));
5197 lab = tr("INFO_DISPLAY") + "<br/>";
5198 items << wrap(tr("INFO_QUALITY_AREA"), "li")
5199 << wrap(tr("INFO_QUALITY_VOLUME"), "li")
5200 << wrap(tr("INFO_QUALITY_ASPECT_RATION"), "li")
5201 << wrap("...", "li");
5202 lab = lab + tr("INFO_QUALITY_INFO") + ":" + wrap(items.join(""), "ul");
5204 lab = lab + tr("INFO_CLIPPING");
5206 app->infoPanel()->addLabel(lab, gb);
5209 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5210 PyGILState_STATE gstate = PyGILState_Ensure();
5211 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5212 if ( !pluginsmanager ) {
5216 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5221 PyGILState_Release(gstate);
5222 // end of SMESH plugins loading
5224 // Reset actions accelerator keys
5225 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5227 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5228 GetSMESHGen()->UpdateStudy();
5230 // get all view currently opened in the study and connect their signals to
5231 // the corresponding slots of the class.
5232 SUIT_Desktop* aDesk = study->application()->desktop();
5234 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5235 SUIT_ViewWindow* wnd;
5236 foreach ( wnd, wndList )
5240 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5241 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5247 Py_XDECREF(pluginsmanager);
5251 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5253 setMenuShown( false );
5254 setToolShown( false );
5256 EmitSignalCloseAllDialogs();
5258 // Unset actions accelerator keys
5259 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5261 return SalomeApp_Module::deactivateModule( study );
5264 void SMESHGUI::studyClosed( SUIT_Study* s )
5268 SMESH::RemoveVisuData();
5269 SalomeApp_Module::studyClosed( s );
5272 void SMESHGUI::OnGUIEvent()
5274 const QObject* obj = sender();
5275 if ( !obj || !obj->inherits( "QAction" ) )
5277 int id = actionId((QAction*)obj);
5282 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5284 if ( CORBA::is_nil( myComponentSMESH ) )
5286 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5287 return aGUI.myComponentSMESH;
5289 return myComponentSMESH;
5292 QString SMESHGUI::engineIOR() const
5294 CORBA::ORB_var anORB = getApp()->orb();
5295 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5296 return QString( anIOR.in() );
5299 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5301 SalomeApp_Module::contextMenuPopup( client, menu, title );
5303 selectionMgr()->selectedObjects( lst );
5304 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5305 Handle(SALOME_InteractiveObject) io = lst.First();
5306 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5307 _PTR(Study) study = appStudy->studyDS();
5308 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5310 QString aName = SMESH::fromUtf8( obj->GetName());
5311 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5312 aName.remove(( aName.length() - 1 ), 1 );
5318 LightApp_Selection* SMESHGUI::createSelection() const
5320 return new SMESHGUI_Selection();
5323 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5325 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5326 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5327 aMap.insert( SalomeApp_Application::WT_InfoPanel, Qt::RightDockWidgetArea);
5328 #ifndef DISABLE_PYCONSOLE
5329 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5333 void SMESHGUI::viewManagers( QStringList& list ) const
5335 list.append( SVTK_Viewer::Type() );
5338 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5340 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5341 SMESH::UpdateSelectionProp( this );
5343 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5344 for(int i = 0; i < aViews.count() ; i++){
5345 SUIT_ViewWindow *sf = aViews[i];
5348 EmitSignalActivatedViewManager();
5352 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5354 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5355 myClippingPlaneInfoMap.erase( theViewManager );
5358 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5360 theActor->AddObserver( SMESH::DeleteActorEvent,
5361 myEventCallbackCommand.GetPointer(),
5365 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5366 unsigned long theEvent,
5367 void* theClientData,
5368 void* /*theCallData*/ )
5370 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5371 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5372 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5373 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5374 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5375 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5376 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5377 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5378 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5379 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5380 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5381 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5382 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5383 if( anActor == *anIter3 ) {
5384 anActorList.erase( anIter3 );
5395 void SMESHGUI::createPreferences()
5397 // General tab ------------------------------------------------------------------------
5398 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5400 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5401 setPreferenceProperty( autoUpdate, "columns", 2 );
5402 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5403 setPreferenceProperty( lim, "min", 0 );
5404 setPreferenceProperty( lim, "max", 100000000 );
5405 setPreferenceProperty( lim, "step", 1000 );
5406 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5407 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5409 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5410 setPreferenceProperty( dispgroup, "columns", 2 );
5412 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5414 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5416 modes.append( tr("MEN_WIRE") );
5417 modes.append( tr("MEN_SHADE") );
5418 modes.append( tr("MEN_NODES") );
5419 modes.append( tr("MEN_SHRINK") );
5420 QList<QVariant> indices;
5421 indices.append( 0 );
5422 indices.append( 1 );
5423 indices.append( 2 );
5424 indices.append( 3 );
5425 setPreferenceProperty( dispmode, "strings", modes );
5426 setPreferenceProperty( dispmode, "indexes", indices );
5428 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5429 setPreferenceProperty( arcgroup, "columns", 2 );
5430 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5431 QStringList quadraticModes;
5432 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5433 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5435 indices.append( 0 );
5436 indices.append( 1 );
5437 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5438 setPreferenceProperty( quadraticmode, "indexes", indices );
5440 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5441 "SMESH", "max_angle" );
5442 setPreferenceProperty( maxAngle, "min", 1 );
5443 setPreferenceProperty( maxAngle, "max", 90 );
5445 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5446 setPreferenceProperty( qaGroup, "columns", 2 );
5447 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5448 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5449 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5450 setPreferenceProperty( prec, "min", 0 );
5451 setPreferenceProperty( prec, "max", 100 );
5452 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5453 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5454 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5455 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5456 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5459 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5460 setPreferenceProperty( cinc, "min", 0 );
5461 setPreferenceProperty( cinc, "max", 5 );
5464 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5465 setPreferenceProperty( exportgroup, "columns", 2 );
5466 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5467 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5468 addPreference( tr( "PREF_MED_SAVE_NUMS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "med_save_numbers" );
5469 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5470 setPreferenceProperty( zTol, "precision", 10 );
5471 setPreferenceProperty( zTol, "min", 0.0000000001 );
5472 setPreferenceProperty( zTol, "max", 1000000.0 );
5473 setPreferenceProperty( zTol, "step", 1. );
5474 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5476 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5477 setPreferenceProperty( computeGroup, "columns", 2 );
5478 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5480 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5481 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5482 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5484 indices.append( 0 );
5485 indices.append( 1 );
5486 indices.append( 2 );
5487 setPreferenceProperty( notifyMode, "strings", modes );
5488 setPreferenceProperty( notifyMode, "indexes", indices );
5490 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5491 setPreferenceProperty( infoGroup, "columns", 2 );
5492 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5494 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5495 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5497 indices.append( 0 );
5498 indices.append( 1 );
5499 setPreferenceProperty( elemInfo, "strings", modes );
5500 setPreferenceProperty( elemInfo, "indexes", indices );
5501 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5502 setPreferenceProperty( nodesLim, "min", 0 );
5503 setPreferenceProperty( nodesLim, "max", 10000000 );
5504 setPreferenceProperty( nodesLim, "step", 10000 );
5505 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5506 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5507 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5508 setPreferenceProperty( ctrlLim, "min", 0 );
5509 setPreferenceProperty( ctrlLim, "max", 10000000 );
5510 setPreferenceProperty( ctrlLim, "step", 1000 );
5511 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5512 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5513 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5514 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5515 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5517 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5518 setPreferenceProperty( segGroup, "columns", 2 );
5519 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5520 "SMESH", "segmentation" );
5521 setPreferenceProperty( segLen, "min", 1 );
5522 setPreferenceProperty( segLen, "max", 10000000 );
5523 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5524 "SMESH", "nb_segments_per_edge" );
5525 setPreferenceProperty( nbSeg, "min", 1 );
5526 setPreferenceProperty( nbSeg, "max", 10000000 );
5527 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5529 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5530 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5531 "SMESH", "forget_mesh_on_hyp_modif" );
5534 // Quantities with individual precision settings
5535 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5536 setPreferenceProperty( precGroup, "columns", 2 );
5538 const int nbQuantities = 6;
5539 int precs[nbQuantities], ii = 0;
5540 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5541 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5542 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5543 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5544 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5545 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5546 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5547 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5548 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5549 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5550 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5551 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5553 // Set property for precision value for spinboxes
5554 for ( ii = 0; ii < nbQuantities; ii++ ){
5555 setPreferenceProperty( precs[ii], "min", -14 );
5556 setPreferenceProperty( precs[ii], "max", 14 );
5557 setPreferenceProperty( precs[ii], "precision", 2 );
5560 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5561 setPreferenceProperty( previewGroup, "columns", 2 );
5562 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5563 setPreferenceProperty( chunkSize, "min", 1 );
5564 setPreferenceProperty( chunkSize, "max", 1000 );
5565 setPreferenceProperty( chunkSize, "step", 50 );
5567 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5568 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5570 // Mesh tab ------------------------------------------------------------------------
5571 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5572 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5573 setPreferenceProperty( nodeGroup, "columns", 3 );
5575 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5577 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5579 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5580 QList<QVariant> aMarkerTypeIndicesList;
5581 QList<QVariant> aMarkerTypeIconsList;
5582 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5583 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5584 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5585 aMarkerTypeIndicesList << i;
5586 aMarkerTypeIconsList << pixmap;
5588 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5589 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5591 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5593 QList<QVariant> aMarkerScaleIndicesList;
5594 QStringList aMarkerScaleValuesList;
5595 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5596 aMarkerScaleIndicesList << i;
5597 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5598 aMarkerScaleValuesList << QString::number( i );
5600 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5601 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5603 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5604 //setPreferenceProperty( elemGroup, "columns", 2 );
5606 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5607 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5608 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5609 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5610 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5611 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5612 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5613 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5614 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5617 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5618 setPreferenceProperty( grpGroup, "columns", 2 );
5620 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5621 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5623 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5624 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5625 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5626 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5627 int ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5628 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5629 int ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5630 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5631 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5632 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5633 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5634 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5635 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5636 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5638 setPreferenceProperty( size0d, "min", 1 );
5639 setPreferenceProperty( size0d, "max", 10 );
5641 // setPreferenceProperty( ballSize, "min", 1 );
5642 // setPreferenceProperty( ballSize, "max", 10 );
5644 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5645 setPreferenceProperty( ballDiameter, "max", 1e9 );
5646 setPreferenceProperty( ballDiameter, "step", 0.1 );
5648 setPreferenceProperty( ballScale, "min", 1e-2 );
5649 setPreferenceProperty( ballScale, "max", 1e7 );
5650 setPreferenceProperty( ballScale, "step", 0.5 );
5652 setPreferenceProperty( elemW, "min", 1 );
5653 setPreferenceProperty( elemW, "max", 5 );
5655 setPreferenceProperty( outW, "min", 1 );
5656 setPreferenceProperty( outW, "max", 5 );
5658 setPreferenceProperty( shrink, "min", 0 );
5659 setPreferenceProperty( shrink, "max", 100 );
5661 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5662 setPreferenceProperty( numGroup, "columns", 2 );
5664 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5665 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5667 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5668 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5670 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5671 setPreferenceProperty( orientGroup, "columns", 1 );
5673 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5674 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5676 setPreferenceProperty( orientScale, "min", 0.05 );
5677 setPreferenceProperty( orientScale, "max", 0.5 );
5678 setPreferenceProperty( orientScale, "step", 0.05 );
5680 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5682 // Selection tab ------------------------------------------------------------------------
5683 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5685 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5686 setPreferenceProperty( selGroup, "columns", 2 );
5688 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5689 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5691 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5692 setPreferenceProperty( preGroup, "columns", 2 );
5694 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5696 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5697 setPreferenceProperty( precSelGroup, "columns", 2 );
5699 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5700 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5701 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5703 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5704 setPreferenceProperty( sinc, "min", 0 );
5705 setPreferenceProperty( sinc, "max", 5 );
5707 // Scalar Bar tab ------------------------------------------------------------------------
5708 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5709 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5710 setPreferenceProperty( fontGr, "columns", 2 );
5712 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5713 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5715 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5716 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5718 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5719 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5721 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5722 setPreferenceProperty( numcol, "min", 2 );
5723 setPreferenceProperty( numcol, "max", 256 );
5725 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5726 setPreferenceProperty( numlab, "min", 2 );
5727 setPreferenceProperty( numlab, "max", 65 );
5729 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5730 setPreferenceProperty( orientGr, "columns", 2 );
5731 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5732 QStringList orients;
5733 orients.append( tr( "SMESH_VERTICAL" ) );
5734 orients.append( tr( "SMESH_HORIZONTAL" ) );
5735 indices.clear(); indices.append( 0 ); indices.append( 1 );
5736 setPreferenceProperty( orient, "strings", orients );
5737 setPreferenceProperty( orient, "indexes", indices );
5739 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5740 setPreferenceProperty( posVSizeGr, "columns", 2 );
5741 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5742 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5743 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5744 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5745 setPreferenceProperty( xv, "step", 0.1 );
5746 setPreferenceProperty( xv, "min", 0.0 );
5747 setPreferenceProperty( xv, "max", 1.0 );
5748 setPreferenceProperty( yv, "step", 0.1 );
5749 setPreferenceProperty( yv, "min", 0.0 );
5750 setPreferenceProperty( yv, "max", 1.0 );
5751 setPreferenceProperty( wv, "step", 0.1 );
5752 setPreferenceProperty( wv, "min", 0.0 );
5753 setPreferenceProperty( wv, "max", 1.0 );
5754 setPreferenceProperty( hv, "min", 0.0 );
5755 setPreferenceProperty( hv, "max", 1.0 );
5756 setPreferenceProperty( hv, "step", 0.1 );
5758 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5759 setPreferenceProperty( posHSizeGr, "columns", 2 );
5760 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5761 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5762 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5763 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5764 setPreferenceProperty( xv, "min", 0.0 );
5765 setPreferenceProperty( xv, "max", 1.0 );
5766 setPreferenceProperty( xv, "step", 0.1 );
5767 setPreferenceProperty( xh, "min", 0.0 );
5768 setPreferenceProperty( xh, "max", 1.0 );
5769 setPreferenceProperty( xh, "step", 0.1 );
5770 setPreferenceProperty( yh, "min", 0.0 );
5771 setPreferenceProperty( yh, "max", 1.0 );
5772 setPreferenceProperty( yh, "step", 0.1 );
5773 setPreferenceProperty( wh, "min", 0.0 );
5774 setPreferenceProperty( wh, "max", 1.0 );
5775 setPreferenceProperty( wh, "step", 0.1 );
5776 setPreferenceProperty( hh, "min", 0.0 );
5777 setPreferenceProperty( hh, "max", 1.0 );
5778 setPreferenceProperty( hh, "step", 0.1 );
5780 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5781 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5782 setPreferenceProperty( distributionGr, "columns", 3 );
5784 types.append( tr( "SMESH_MONOCOLOR" ) );
5785 types.append( tr( "SMESH_MULTICOLOR" ) );
5786 indices.clear(); indices.append( 0 ); indices.append( 1 );
5787 setPreferenceProperty( coloringType, "strings", types );
5788 setPreferenceProperty( coloringType, "indexes", indices );
5789 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5791 // Adaptation - begin
5792 #ifndef DISABLE_MG_ADAPT
5793 // Adaptation tab ------------------------------------------------------------------------
5794 int adaptTab = addPreference( tr( "ADAPT_PREF_TAB_GENERAL" ) );
5797 bloc = addPreference( tr( "ADAPT_PREF_MG_ADAPT" ), adaptTab );
5798 setPreferenceProperty( bloc, "columns", 1 );
5799 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_FILE_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_file_mesh_out" );
5800 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_publish_mesh_out" );
5801 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_size_map" );
5802 QStringList aListOfSizeMap;
5803 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_LOCAL" );
5804 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_BACKGROUND" );
5805 aListOfSizeMap << tr( "ADAPT_PREF_NONE" );;
5806 setPreferenceProperty( pref, "strings", aListOfSizeMap );
5807 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_time_step" );
5808 QStringList aListOfTimeStep;
5809 aListOfTimeStep << tr( "ADAPT_PREF_NONE" );
5810 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_LAST" );
5811 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_C" );;
5812 setPreferenceProperty( pref, "strings", aListOfTimeStep );
5817 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5819 if ( sect=="SMESH" ) {
5820 double sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5821 double aTol = 1.00000009999999;
5822 std::string aWarning;
5823 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5825 if ( name == "selection_object_color" ||
5826 name == "selection_element_color" ||
5827 name == "highlight_color" ||
5828 name == "selection_precision_node" ||
5829 name == "selection_precision_element" ||
5830 name == "selection_precision_object" ||
5831 name == "selection_increment")
5833 SMESH::UpdateSelectionProp( this );
5835 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5837 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5838 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5839 if ( sbX1+sbW > aTol ) {
5840 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5843 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5844 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5847 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5849 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5850 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5851 if ( sbY1 + sbH > aTol ) {
5852 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5853 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5854 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5857 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5859 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5860 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5861 if ( sbX1 + sbW > aTol ) {
5862 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5865 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5866 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5869 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5871 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5872 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5873 if ( sbY1 + sbH > aTol ) {
5874 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5877 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5878 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5881 else if ( name == "segmentation" )
5883 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5884 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5886 else if ( name == "nb_segments_per_edge" )
5888 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5889 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5891 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5893 QString val = aResourceMgr->stringValue( "SMESH", name );
5894 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5896 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5898 SMESH::UpdateFontProp( this );
5900 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5902 SMESH::UpdateFontProp( this );
5905 if ( aWarning.size() != 0 ) {
5906 aWarning += "The default values are applied instead.";
5907 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5908 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5909 QObject::tr(aWarning.c_str()));
5914 //================================================================================
5916 * \brief Update something in accordance with update flags
5917 * \param theFlags - update flags
5919 * Update viewer or/and object browser etc. in accordance with update flags ( see
5920 * LightApp_UpdateFlags enumeration ).
5922 //================================================================================
5923 void SMESHGUI::update( const int flags )
5925 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5926 SMESH::UpdateView();
5928 SalomeApp_Module::update( flags );
5931 //================================================================================
5933 * \brief Set default selection mode
5935 * SLOT called when operation committed. Sets default selection mode
5937 //================================================================================
5938 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5940 SVTK_ViewWindow* vtkWnd =
5941 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5943 vtkWnd->SetSelectionMode( ActorSelection );
5946 //================================================================================
5948 * \brief Set default selection mode
5950 * SLOT called when operation aborted. Sets default selection mode
5952 //================================================================================
5953 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5955 SVTK_ViewWindow* vtkWnd =
5956 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5958 vtkWnd->SetSelectionMode( ActorSelection );
5961 //================================================================================
5963 * \brief Creates operation with given identifier
5964 * \param id - identifier of operation to be started
5965 * \return Pointer on created operation or NULL if operation is not created
5967 * Virtual method redefined from the base class creates operation with given id.
5968 * It is called called automatically from startOperation method of base class.
5970 //================================================================================
5971 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5973 LightApp_Operation* op = 0;
5974 // to do : create operation here
5977 case SMESHOp::OpSplitBiQuadratic:
5978 op = new SMESHGUI_SplitBiQuadOp();
5980 case SMESHOp::OpConvertMeshToQuadratic:
5981 op = new SMESHGUI_ConvToQuadOp();
5983 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5984 op = new SMESHGUI_Make2DFrom3DOp();
5986 case SMESHOp::OpReorientFaces:
5987 op = new SMESHGUI_ReorientFacesOp();
5989 case SMESHOp::OpCreateMesh:
5990 op = new SMESHGUI_MeshOp( true, true );
5992 case SMESHOp::OpCreateSubMesh:
5993 op = new SMESHGUI_MeshOp( true, false );
5995 case SMESHOp::OpEditMeshOrSubMesh:
5996 case SMESHOp::OpEditMesh:
5997 case SMESHOp::OpEditSubMesh:
5998 op = new SMESHGUI_MeshOp( false );
6000 case SMESHOp::OpCompute:
6001 case SMESHOp::OpComputeSubMesh:
6002 op = new SMESHGUI_ComputeOp();
6004 case SMESHOp::OpShowErrors:
6005 op = new SMESHGUI_ShowErrorsOp();
6007 case SMESHOp::OpPreCompute:
6008 op = new SMESHGUI_PrecomputeOp();
6010 case SMESHOp::OpEvaluate:
6011 op = new SMESHGUI_EvaluateOp();
6013 case SMESHOp::OpMeshOrder:
6014 op = new SMESHGUI_MeshOrderOp();
6016 case SMESHOp::OpCreateGeometryGroup:
6017 op = new SMESHGUI_GroupOnShapeOp();
6019 case SMESHOp::OpFindElementByPoint:
6020 op = new SMESHGUI_FindElemByPointOp();
6022 case SMESHOp::OpMoveNode: // Make mesh pass through point
6023 op = new SMESHGUI_MakeNodeAtPointOp();
6025 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
6026 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
6033 op = SalomeApp_Module::createOperation( id );
6037 //================================================================================
6039 * \brief Stops current operations and starts a given one
6040 * \param id - The id of the operation to start
6042 //================================================================================
6044 void SMESHGUI::switchToOperation(int id)
6046 activeStudy()->abortAllOperations();
6047 startOperation( id );
6050 LightApp_Displayer* SMESHGUI::displayer()
6053 myDisplayer = new SMESHGUI_Displayer( getApp() );
6057 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
6060 int aTolerance = 64;
6061 int anIterations = 0;
6067 if( anIterations % aPeriod == 0 )
6070 if( aTolerance < 1 )
6074 aHue = (int)( 360.0 * rand() / RAND_MAX );
6077 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
6078 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
6079 for( ; it != itEnd; ++it )
6081 SALOMEDS::Color anAutoColor = *it;
6082 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6085 aQColor.getHsv( &h, &s, &v );
6086 if( abs( h - aHue ) < aTolerance )
6098 aColor.setHsv( aHue, 255, 255 );
6100 SALOMEDS::Color aSColor;
6101 aSColor.R = aColor.redF();
6102 aSColor.G = aColor.greenF();
6103 aSColor.B = aColor.blueF();
6108 const char* gSeparator = "_"; // character used to separate parameter names
6109 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6110 const char* gPathSep = "|"; // character used to separate paths
6113 * \brief Store visual parameters
6115 * This method is called just before the study document is saved.
6116 * Store visual parameters in AttributeParameter attribute(s)
6118 void SMESHGUI::storeVisualParameters (int savePoint)
6121 Kernel_Utils::Localizer loc;
6123 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6124 if (!appStudy || !appStudy->studyDS())
6126 _PTR(Study) studyDS = appStudy->studyDS();
6128 // componentName is used for encoding of entries when storing them in IParameters
6129 std::string componentName = myComponentSMESH->ComponentDataType();
6130 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6131 //if (!aSComponent) return;
6134 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6135 componentName.c_str(),
6137 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6139 // store custom markers
6140 if( !myMarkerMap.empty() )
6142 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6143 for( ; anIter != myMarkerMap.end(); anIter++ )
6145 int anId = anIter->first;
6146 VTK::MarkerData aMarkerData = anIter->second;
6147 std::string aMarkerFileName = aMarkerData.first;
6148 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6149 if( aMarkerTexture.size() < 3 )
6150 continue; // should contain at least width, height and the first value
6152 QString aPropertyName( "texture" );
6153 aPropertyName += gSeparator;
6154 aPropertyName += QString::number( anId );
6156 QString aPropertyValue = aMarkerFileName.c_str();
6157 aPropertyValue += gPathSep;
6159 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6160 ushort aWidth = *aTextureIter++;
6161 ushort aHeight = *aTextureIter++;
6162 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6163 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6164 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6165 aPropertyValue += QString::number( *aTextureIter );
6167 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6171 // viewers counters are used for storing view_numbers in IParameters
6174 // main cycle to store parameters of displayed objects
6175 QList<SUIT_ViewManager*> lst;
6176 QList<SUIT_ViewManager*>::Iterator it;
6177 getApp()->viewManagers(lst);
6178 for (it = lst.begin(); it != lst.end(); it++)
6180 SUIT_ViewManager* vman = *it;
6181 QString vType = vman->getType();
6183 // saving VTK actors properties
6184 if (vType == SVTK_Viewer::Type())
6186 // store the clipping planes attached to the view manager
6187 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6188 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6189 if( anIter != myClippingPlaneInfoMap.end() )
6190 aClippingPlaneInfoList = anIter->second;
6192 if( !aClippingPlaneInfoList.empty() ) {
6193 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6194 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6196 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6197 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6199 QString aPropertyName( "ClippingPlane" );
6200 aPropertyName += gSeparator;
6201 aPropertyName += QString::number( vtkViewers );
6202 aPropertyName += gSeparator;
6203 aPropertyName += QString::number( anId );
6205 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6206 aPropertyValue += gDigitsSep;
6207 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6208 aPropertyValue += gDigitsSep;
6209 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6210 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6211 aPropertyValue += gDigitsSep;
6212 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6213 aPropertyValue += gDigitsSep;
6214 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6215 aPropertyValue += gDigitsSep;
6216 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6217 aPropertyValue += gDigitsSep;
6218 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6219 aPropertyValue += gDigitsSep;
6220 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6221 aPropertyValue += gDigitsSep;
6222 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6224 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6225 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6226 aPropertyValue += gDigitsSep;
6227 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6228 aPropertyValue += gDigitsSep;
6229 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6230 aPropertyValue += gDigitsSep;
6231 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6234 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6238 QVector<SUIT_ViewWindow*> views = vman->getViews();
6239 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6241 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6243 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6244 vtkActorCollection* allActors = aCopy.GetActors();
6245 allActors->InitTraversal();
6246 while (vtkActor* actor = allActors->GetNextActor())
6248 if (actor->GetVisibility()) // store only visible actors
6250 SMESH_Actor* aSmeshActor = 0;
6251 if (actor->IsA("SMESH_Actor"))
6252 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6253 if (aSmeshActor && aSmeshActor->hasIO())
6255 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6258 // entry is "encoded" = it does NOT contain component address,
6259 // since it is a subject to change on next component loading
6260 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6262 std::string param, vtkParam = vType.toLatin1().data();
6263 vtkParam += gSeparator;
6264 vtkParam += QString::number(vtkViewers).toLatin1().data();
6265 vtkParam += gSeparator;
6268 param = vtkParam + "Visibility";
6269 ip->setParameter(entry, param, "On");
6272 param = vtkParam + "Representation";
6273 ip->setParameter(entry, param, QString::number
6274 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6277 param = vtkParam + "IsShrunk";
6278 ip->setParameter(entry, param, QString::number
6279 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6281 // Displayed entities
6282 unsigned int aMode = aSmeshActor->GetEntityMode();
6283 bool isE = aMode & SMESH_Actor::eEdges;
6284 bool isF = aMode & SMESH_Actor::eFaces;
6285 bool isV = aMode & SMESH_Actor::eVolumes;
6286 bool is0d = aMode & SMESH_Actor::e0DElements;
6287 bool isB = aMode & SMESH_Actor::eBallElem;
6289 QString modeStr ("e");
6290 modeStr += gDigitsSep; modeStr += QString::number(isE);
6291 modeStr += gDigitsSep; modeStr += "f";
6292 modeStr += gDigitsSep; modeStr += QString::number(isF);
6293 modeStr += gDigitsSep; modeStr += "v";
6294 modeStr += gDigitsSep; modeStr += QString::number(isV);
6295 modeStr += gDigitsSep; modeStr += "0d";
6296 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6297 modeStr += gDigitsSep; modeStr += "b";
6298 modeStr += gDigitsSep; modeStr += QString::number(isB);
6300 param = vtkParam + "Entities";
6301 ip->setParameter(entry, param, modeStr.toLatin1().data());
6307 aSmeshActor->GetSufaceColor(r, g, b, delta);
6308 QStringList colorStr;
6309 colorStr << "surface";
6310 colorStr << QString::number(r);
6311 colorStr << QString::number(g);
6312 colorStr << QString::number(b);
6314 colorStr << "backsurface";
6315 colorStr << QString::number(delta);
6317 aSmeshActor->GetVolumeColor(r, g, b, delta);
6318 colorStr << "volume";
6319 colorStr << QString::number(r);
6320 colorStr << QString::number(g);
6321 colorStr << QString::number(b);
6322 colorStr << QString::number(delta);
6324 aSmeshActor->GetEdgeColor(r, g, b);
6326 colorStr << QString::number(r);
6327 colorStr << QString::number(g);
6328 colorStr << QString::number(b);
6330 aSmeshActor->GetNodeColor(r, g, b);
6332 colorStr << QString::number(r);
6333 colorStr << QString::number(g);
6334 colorStr << QString::number(b);
6336 aSmeshActor->GetOutlineColor(r, g, b);
6337 colorStr << "outline";
6338 colorStr << QString::number(r);
6339 colorStr << QString::number(g);
6340 colorStr << QString::number(b);
6342 aSmeshActor->Get0DColor(r, g, b);
6343 colorStr << "elem0d";
6344 colorStr << QString::number(r);
6345 colorStr << QString::number(g);
6346 colorStr << QString::number(b);
6348 aSmeshActor->GetBallColor(r, g, b);
6350 colorStr << QString::number(r);
6351 colorStr << QString::number(g);
6352 colorStr << QString::number(b);
6354 aSmeshActor->GetFacesOrientationColor(r, g, b);
6355 colorStr << "orientation";
6356 colorStr << QString::number(r);
6357 colorStr << QString::number(g);
6358 colorStr << QString::number(b);
6360 param = vtkParam + "Colors";
6361 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6364 QStringList sizeStr;
6366 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6367 sizeStr << "outline";
6368 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6369 sizeStr << "elem0d";
6370 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6372 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6373 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6374 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6375 sizeStr << "shrink";
6376 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6377 sizeStr << "orientation";
6378 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6379 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6381 param = vtkParam + "Sizes";
6382 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6387 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6388 if( aMarkerType == VTK::MT_USER ) {
6389 markerStr += "custom";
6390 markerStr += gDigitsSep;
6391 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6395 markerStr += gDigitsSep;
6396 markerStr += QString::number( (int)aMarkerType );
6397 markerStr += gDigitsSep;
6398 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6401 param = vtkParam + "PointMarker";
6402 ip->setParameter(entry, param, markerStr.toLatin1().data());
6405 param = vtkParam + "Opacity";
6406 ip->setParameter(entry, param,
6407 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6410 param = vtkParam + "ClippingPlane";
6412 if( !aClippingPlaneInfoList.empty() ) {
6413 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6414 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6416 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6417 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6418 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6419 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6420 if( aSmeshActor == *anIter2 ) {
6421 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6422 QString::number( anId ).toLatin1().constData() );
6429 ip->setParameter( entry, param, "Off" );
6430 } // if (io->hasEntry())
6431 } // SMESH_Actor && hasIO
6433 } // while.. actors traversal
6437 } // if (SVTK view model)
6438 } // for (viewManagers)
6441 // data structures for clipping planes processing
6445 bool isOpenGLClipping;
6446 vtkIdType RelativeOrientation;
6449 int AbsoluteOrientation;
6450 double X, Y, Z, Dx, Dy, Dz;
6452 typedef std::list<TPlaneData> TPlaneDataList;
6453 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6455 typedef std::list<vtkActor*> TActorList;
6458 TActorList ActorList;
6459 SUIT_ViewManager* ViewManager;
6461 typedef std::list<TPlaneInfo> TPlaneInfoList;
6462 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6465 * \brief Restore visual parameters
6467 * This method is called after the study document is opened.
6468 * Restore visual parameters from AttributeParameter attribute(s)
6470 void SMESHGUI::restoreVisualParameters (int savePoint)
6473 Kernel_Utils::Localizer loc;
6475 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6476 if (!appStudy || !appStudy->studyDS())
6478 _PTR(Study) studyDS = appStudy->studyDS();
6480 // componentName is used for encoding of entries when storing them in IParameters
6481 std::string componentName = myComponentSMESH->ComponentDataType();
6484 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6485 componentName.c_str(),
6487 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6489 // restore custom markers and map of clipping planes
6490 TPlaneDataMap aPlaneDataMap;
6492 std::vector<std::string> properties = ip->getProperties();
6493 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6495 std::string property = *propIt;
6496 QString aPropertyName( property.c_str() );
6497 QString aPropertyValue( ip->getProperty( property ).c_str() );
6499 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6500 if( aPropertyNameList.isEmpty() )
6503 QString aPropertyType = aPropertyNameList[0];
6504 if( aPropertyType == "texture" )
6506 if( aPropertyNameList.size() != 2 )
6510 int anId = aPropertyNameList[1].toInt( &ok );
6511 if( !ok || anId < 1 )
6514 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6515 if( aPropertyValueList.size() != 2 )
6518 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6519 QString aMarkerTextureString = aPropertyValueList[1];
6520 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6521 if( aMarkerTextureStringList.size() != 3 )
6525 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6530 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6534 VTK::MarkerTexture aMarkerTexture;
6535 aMarkerTexture.push_back( aWidth );
6536 aMarkerTexture.push_back( aHeight );
6538 QString aMarkerTextureData = aMarkerTextureStringList[2];
6539 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6541 QChar aChar = aMarkerTextureData.at( i );
6542 if( aChar.isDigit() )
6543 aMarkerTexture.push_back( aChar.digitValue() );
6546 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6548 else if( aPropertyType == "ClippingPlane" )
6550 if( aPropertyNameList.size() != 3 )
6554 int aViewId = aPropertyNameList[1].toInt( &ok );
6555 if( !ok || aViewId < 0 )
6559 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6560 if( !ok || aClippingPlaneId < 0 )
6563 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6564 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6567 TPlaneData aPlaneData;
6568 aPlaneData.AbsoluteOrientation = false;
6569 aPlaneData.RelativeOrientation = 0;
6570 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6571 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6572 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6574 aPlaneData.Id = aClippingPlaneId;
6577 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6582 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6586 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6589 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6594 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6599 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6604 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6609 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6614 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6619 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6623 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6625 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6630 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6635 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6640 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6645 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6646 aPlaneDataList.push_back( aPlaneData );
6650 TPlaneInfoMap aPlaneInfoMap;
6652 std::vector<std::string> entries = ip->getEntries();
6654 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6656 // entry is a normal entry - it should be "decoded" (setting base address of component)
6657 QString entry (ip->decodeEntry(*entIt).c_str());
6659 // Check that the entry corresponds to a real object in the Study
6660 // as the object may be deleted or modified after the visual state is saved.
6661 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6662 if (!so) continue; //Skip the not existent entry
6664 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6665 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6667 std::vector<std::string>::iterator namesIt = paramNames.begin();
6668 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6670 // actors are stored in a map after displaying of them for
6671 // quicker access in the future: map < viewID to actor >
6672 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6674 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6676 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6677 // '_' is used as separator and should not be used in viewer type or parameter names.
6678 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6679 if (lst.size() != 3)
6682 QString viewerTypStr = lst[0];
6683 QString viewIndexStr = lst[1];
6684 QString paramNameStr = lst[2];
6687 int viewIndex = viewIndexStr.toUInt(&ok);
6688 if (!ok) // bad conversion of view index to integer
6692 if (viewerTypStr == SVTK_Viewer::Type())
6694 SMESH_Actor* aSmeshActor = 0;
6695 if (vtkActors.IsBound(viewIndex))
6696 aSmeshActor = vtkActors.Find(viewIndex);
6698 QList<SUIT_ViewManager*> lst;
6699 getApp()->viewManagers(viewerTypStr, lst);
6701 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6702 SUIT_ViewManager* vman = NULL;
6703 if (viewIndex >= 0 && viewIndex < lst.count())
6704 vman = lst.at(viewIndex);
6706 if (paramNameStr == "Visibility")
6708 if (!aSmeshActor && displayer() && vman)
6710 SUIT_ViewModel* vmodel = vman->getViewModel();
6711 // SVTK view model can be casted to SALOME_View
6712 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6714 // store displayed actor in a temporary map for quicker
6715 // access later when restoring other parameters
6716 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6717 vtkRenderer* Renderer = vtkView->getRenderer();
6718 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6719 vtkActorCollection* theActors = aCopy.GetActors();
6720 theActors->InitTraversal();
6721 bool isFound = false;
6722 vtkActor *ac = theActors->GetNextActor();
6723 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6724 if (ac->IsA("SMESH_Actor")) {
6725 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6726 if (aGeomAc->hasIO()) {
6727 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6728 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6730 vtkActors.Bind(viewIndex, aGeomAc);
6736 } // if (paramNameStr == "Visibility")
6739 // the rest properties "work" with SMESH_Actor
6742 QString val ((*valuesIt).c_str());
6745 if (paramNameStr == "Representation") {
6746 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6749 else if (paramNameStr == "IsShrunk") {
6751 if (!aSmeshActor->IsShrunk())
6752 aSmeshActor->SetShrink();
6755 if (aSmeshActor->IsShrunk())
6756 aSmeshActor->UnShrink();
6759 // Displayed entities
6760 else if (paramNameStr == "Entities") {
6761 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6762 int aEntityMode = SMESH_Actor::eAllEntity;
6763 for ( int i = 0; i < mode.count(); i+=2 ) {
6764 if ( i < mode.count()-1 ) {
6765 QString type = mode[i];
6766 bool val = mode[i+1].toInt();
6767 if ( type == "e" && !val )
6768 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6769 else if ( type == "f" && !val )
6770 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6771 else if ( type == "v" && !val )
6772 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6773 else if ( type == "0d" && !val )
6774 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6775 else if ( type == "b" && !val )
6776 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6779 aSmeshActor->SetEntityMode( aEntityMode );
6782 else if (paramNameStr == "Colors") {
6783 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6790 QColor outlineColor;
6791 QColor orientationColor;
6797 // below lines are required to get default values for delta coefficients
6798 // of backface color for faces and color of reversed volumes
6799 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6800 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6801 for ( int i = 0; i < colors.count(); i++ ) {
6802 QString type = colors[i];
6803 if ( type == "surface" ) {
6804 // face color is set by 3 values r:g:b, where
6805 // - r,g,b - is rgb color components
6806 if ( i+1 >= colors.count() ) break; // format error
6807 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6808 if ( i+2 >= colors.count() ) break; // format error
6809 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6810 if ( i+3 >= colors.count() ) break; // format error
6811 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6812 faceColor.setRgbF( r, g, b );
6815 else if ( type == "backsurface" ) {
6816 // backface color can be defined in several ways
6817 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6818 // - in latest versions, it is set as delta coefficient
6819 bool rgbOk = false, deltaOk;
6820 if ( i+1 >= colors.count() ) break; // format error
6821 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6822 int delta = colors[i+1].toInt( &deltaOk );
6824 if ( i+1 < colors.count() ) // index is shifted to 1
6825 g = colors[i+1].toDouble( &rgbOk );
6826 if ( rgbOk ) i++; // shift index
6827 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6828 b = colors[i+1].toDouble( &rgbOk );
6830 // - as currently there's no way to set directly backsurface color as it was before,
6831 // we ignore old dump where r,g,b triple was set
6832 // - also we check that delta parameter is set properly
6833 if ( !rgbOk && deltaOk )
6836 else if ( type == "volume" ) {
6837 // volume color is set by 4 values r:g:b:delta, where
6838 // - r,g,b - is a normal volume rgb color components
6839 // - delta - is a reversed volume color delta coefficient
6840 if ( i+1 >= colors.count() ) break; // format error
6841 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6842 if ( i+2 >= colors.count() ) break; // format error
6843 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6844 if ( i+3 >= colors.count() ) break; // format error
6845 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6846 if ( i+4 >= colors.count() ) break; // format error
6847 int delta = colors[i+4].toInt( &bOk );
6848 if ( !bOk ) break; // format error
6849 volumeColor.setRgbF( r, g, b );
6853 else if ( type == "edge" ) {
6854 // edge color is set by 3 values r:g:b, where
6855 // - r,g,b - is rgb color components
6856 if ( i+1 >= colors.count() ) break; // format error
6857 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6858 if ( i+2 >= colors.count() ) break; // format error
6859 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6860 if ( i+3 >= colors.count() ) break; // format error
6861 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6862 edgeColor.setRgbF( r, g, b );
6865 else if ( type == "node" ) {
6866 // node color is set by 3 values r:g:b, where
6867 // - r,g,b - is rgb color components
6868 if ( i+1 >= colors.count() ) break; // format error
6869 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6870 if ( i+2 >= colors.count() ) break; // format error
6871 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6872 if ( i+3 >= colors.count() ) break; // format error
6873 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6874 nodeColor.setRgbF( r, g, b );
6877 else if ( type == "elem0d" ) {
6878 // 0d element color is set by 3 values r:g:b, where
6879 // - r,g,b - is rgb color components
6880 if ( i+1 >= colors.count() ) break; // format error
6881 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6882 if ( i+2 >= colors.count() ) break; // format error
6883 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6884 if ( i+3 >= colors.count() ) break; // format error
6885 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6886 elem0dColor.setRgbF( r, g, b );
6889 else if ( type == "ball" ) {
6890 // ball color is set by 3 values r:g:b, where
6891 // - r,g,b - is rgb color components
6892 if ( i+1 >= colors.count() ) break; // format error
6893 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6894 if ( i+2 >= colors.count() ) break; // format error
6895 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6896 if ( i+3 >= colors.count() ) break; // format error
6897 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6898 ballColor.setRgbF( r, g, b );
6901 else if ( type == "outline" ) {
6902 // outline color is set by 3 values r:g:b, where
6903 // - r,g,b - is rgb color components
6904 if ( i+1 >= colors.count() ) break; // format error
6905 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6906 if ( i+2 >= colors.count() ) break; // format error
6907 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6908 if ( i+3 >= colors.count() ) break; // format error
6909 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6910 outlineColor.setRgbF( r, g, b );
6913 else if ( type == "orientation" ) {
6914 // orientation color is set by 3 values r:g:b, where
6915 // - r,g,b - is rgb color components
6916 if ( i+1 >= colors.count() ) break; // format error
6917 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6918 if ( i+2 >= colors.count() ) break; // format error
6919 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6920 if ( i+3 >= colors.count() ) break; // format error
6921 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6922 orientationColor.setRgbF( r, g, b );
6927 if ( nodeColor.isValid() )
6928 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6930 if ( edgeColor.isValid() )
6931 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6933 if ( faceColor.isValid() )
6934 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6936 if ( volumeColor.isValid() )
6937 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6938 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6939 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6941 if ( elem0dColor.isValid() )
6942 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6944 if ( ballColor.isValid() )
6945 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6947 if ( outlineColor.isValid() )
6948 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6949 // orientation color
6950 if ( orientationColor.isValid() )
6951 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6954 else if (paramNameStr == "Sizes") {
6955 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6958 int outlineWidth = -1;
6959 int elem0dSize = -1;
6960 //int ballSize = -1;
6961 double ballDiameter = -1.0;
6962 double ballScale = -1.0;
6963 double shrinkSize = -1;
6964 double orientationSize = -1;
6965 bool orientation3d = false;
6966 for ( int i = 0; i < sizes.count(); i++ ) {
6967 QString type = sizes[i];
6968 if ( type == "line" ) {
6969 // line (wireframe) width is given as single integer value
6970 if ( i+1 >= sizes.count() ) break; // format error
6971 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6975 if ( type == "outline" ) {
6976 // outline width is given as single integer value
6977 if ( i+1 >= sizes.count() ) break; // format error
6978 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6982 else if ( type == "elem0d" ) {
6983 // 0d element size is given as single integer value
6984 if ( i+1 >= sizes.count() ) break; // format error
6985 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6989 else if ( type == "ball" ) {
6990 // balls are specified by two values: size:scale, where
6991 // - size - is a integer value specifying size
6992 // - scale - is a double value specifying scale factor
6993 if ( i+1 >= sizes.count() ) break; // format error
6994 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6995 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6996 if ( i+2 >= sizes.count() ) break; // format error
6997 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
7003 else if ( type == "shrink" ) {
7004 // shrink factor is given as single floating point value
7005 if ( i+1 >= sizes.count() ) break; // format error
7006 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
7010 else if ( type == "orientation" ) {
7011 // orientation vectors are specified by two values size:3d, where
7012 // - size - is a floating point value specifying scale factor
7013 // - 3d - is a boolean
7014 if ( i+1 >= sizes.count() ) break; // format error
7015 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
7016 if ( i+2 >= sizes.count() ) break; // format error
7017 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
7018 orientationSize = v1;
7019 orientation3d = (bool)v2;
7023 // line (wireframe) width
7024 if ( lineWidth > 0 )
7025 aSmeshActor->SetLineWidth( lineWidth );
7027 if ( outlineWidth > 0 )
7028 aSmeshActor->SetOutlineWidth( outlineWidth );
7029 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
7030 aSmeshActor->SetOutlineWidth( lineWidth );
7032 if ( elem0dSize > 0 )
7033 aSmeshActor->Set0DSize( elem0dSize );
7035 /*if ( ballSize > 0 )
7036 aSmeshActor->SetBallSize( ballSize );*/
7038 if ( ballDiameter > 0 )
7039 aSmeshActor->SetBallSize( ballDiameter );
7041 if ( ballScale > 0.0 )
7042 aSmeshActor->SetBallScale( ballScale );
7044 if ( shrinkSize > 0 )
7045 aSmeshActor->SetShrinkFactor( shrinkSize );
7046 // orientation vectors
7047 if ( orientationSize > 0 ) {
7048 aSmeshActor->SetFacesOrientationScale( orientationSize );
7049 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
7053 else if (paramNameStr == "PointMarker") {
7054 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
7055 if( data.count() >= 2 ) {
7057 int aParam1 = data[1].toInt( &ok );
7059 if( data[0] == "std" && data.count() == 3 ) {
7060 int aParam2 = data[2].toInt( &ok );
7061 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
7063 else if( data[0] == "custom" ) {
7064 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
7065 if( markerIt != myMarkerMap.end() ) {
7066 VTK::MarkerData aMarkerData = markerIt->second;
7067 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
7074 else if (paramNameStr == "Opacity") {
7075 aSmeshActor->SetOpacity(val.toFloat());
7078 else if (paramNameStr.startsWith("ClippingPlane")) {
7079 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
7080 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
7081 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
7082 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
7083 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7084 // new format - val looks like "Off" or "0" (plane id)
7085 // (note: in new format "Off" value is used only for consistency,
7086 // so it is processed together with values in old format)
7087 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7088 if( anIsOldFormat ) {
7089 if (paramNameStr == "ClippingPlane1" || val == "Off")
7090 aSmeshActor->RemoveAllClippingPlanes();
7092 QList<SUIT_ViewManager*> lst;
7093 getApp()->viewManagers(viewerTypStr, lst);
7094 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7095 if (viewIndex >= 0 && viewIndex < lst.count()) {
7096 SUIT_ViewManager* vman = lst.at(viewIndex);
7097 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7099 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7101 SMESH::TActorList anActorList;
7102 anActorList.push_back( aSmeshActor );
7103 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7104 aPlane->myViewWindow = vtkView;
7105 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7106 aPlane->PlaneMode = aMode;
7107 bool isOpenGLClipping = ( bool )vals[1].toInt();
7108 aPlane->IsOpenGLClipping = isOpenGLClipping;
7109 if ( aMode == SMESH::Absolute ) {
7110 aPlane->myAbsoluteOrientation = vals[2].toInt();
7111 aPlane->X = vals[3].toFloat();
7112 aPlane->Y = vals[4].toFloat();
7113 aPlane->Z = vals[5].toFloat();
7114 aPlane->Dx = vals[6].toFloat();
7115 aPlane->Dy = vals[7].toFloat();
7116 aPlane->Dz = vals[8].toFloat();
7118 else if ( aMode == SMESH::Relative ) {
7119 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7120 aPlane->myDistance = vals[3].toFloat();
7121 aPlane->myAngle[0] = vals[4].toFloat();
7122 aPlane->myAngle[1] = vals[5].toFloat();
7126 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7127 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7128 aClippingPlaneInfo.Plane = aPlane;
7129 aClippingPlaneInfo.ActorList = anActorList;
7130 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7138 int aPlaneId = val.toInt( &ok );
7139 if( ok && aPlaneId >= 0 ) {
7140 bool anIsDefinedPlane = false;
7141 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7142 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7143 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7144 TPlaneInfo& aPlaneInfo = *anIter;
7145 if( aPlaneInfo.PlaneId == aPlaneId ) {
7146 aPlaneInfo.ActorList.push_back( aSmeshActor );
7147 anIsDefinedPlane = true;
7151 if( !anIsDefinedPlane ) {
7152 TPlaneInfo aPlaneInfo;
7153 aPlaneInfo.PlaneId = aPlaneId;
7154 aPlaneInfo.ActorList.push_back( aSmeshActor );
7155 aPlaneInfo.ViewManager = vman;
7157 // to make the list sorted by plane id
7158 anIter = aPlaneInfoList.begin();
7159 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7160 const TPlaneInfo& aPlaneInfoRef = *anIter;
7161 if( aPlaneInfoRef.PlaneId > aPlaneId )
7164 aPlaneInfoList.insert( anIter, aPlaneInfo );
7169 } // if (aSmeshActor)
7170 } // other parameters than Visibility
7172 } // for names/parameters iterator
7173 } // for entries iterator
7175 // take into account planes with empty list of actors referred to them
7176 QList<SUIT_ViewManager*> aVMList;
7177 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7179 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7180 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7181 int aViewId = aPlaneDataIter->first;
7182 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7183 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7185 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7187 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7188 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7189 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7190 const TPlaneData& aPlaneData = *anIter2;
7191 int aPlaneId = aPlaneData.Id;
7193 bool anIsFound = false;
7194 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7195 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7196 const TPlaneInfo& aPlaneInfo = *anIter3;
7197 if( aPlaneInfo.PlaneId == aPlaneId ) {
7204 TPlaneInfo aPlaneInfo; // ActorList field is empty
7205 aPlaneInfo.PlaneId = aPlaneId;
7206 aPlaneInfo.ViewManager = aViewManager;
7208 // to make the list sorted by plane id
7209 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7210 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7211 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7212 if( aPlaneInfoRef.PlaneId > aPlaneId )
7215 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7221 // add clipping planes to actors according to the restored parameters
7222 // and update the clipping plane map
7223 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7224 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7225 int aViewId = anIter1->first;
7226 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7228 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7229 if( anIter2 == aPlaneDataMap.end() )
7231 const TPlaneDataList& aPlaneDataList = anIter2->second;
7233 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7234 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7235 const TPlaneInfo& aPlaneInfo = *anIter3;
7236 int aPlaneId = aPlaneInfo.PlaneId;
7237 const TActorList& anActorList = aPlaneInfo.ActorList;
7238 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7242 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7246 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7248 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7249 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7250 const TPlaneData& aPlaneData = *anIter4;
7251 if( aPlaneData.Id == aPlaneId ) {
7252 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7253 aPlane->myViewWindow = aViewWindow;
7254 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7255 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7256 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7257 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7258 aPlane->X = aPlaneData.X;
7259 aPlane->Y = aPlaneData.Y;
7260 aPlane->Z = aPlaneData.Z;
7261 aPlane->Dx = aPlaneData.Dx;
7262 aPlane->Dy = aPlaneData.Dy;
7263 aPlane->Dz = aPlaneData.Dz;
7265 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7266 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7267 aPlane->myDistance = aPlaneData.Distance;
7268 aPlane->myAngle[0] = aPlaneData.Angle[0];
7269 aPlane->myAngle[1] = aPlaneData.Angle[1];
7272 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7273 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7274 aClippingPlaneInfo.Plane = aPlane;
7275 aClippingPlaneInfo.ActorList = anActorList;
7276 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7287 // update all VTK views
7288 QList<SUIT_ViewManager*> lst;
7289 getApp()->viewManagers(lst);
7290 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7291 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7292 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7293 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7294 // set OpenGL clipping planes
7295 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7296 vtkActorCollection* anAllActors = aCopy.GetActors();
7297 anAllActors->InitTraversal();
7298 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7299 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7300 anActor->SetOpenGLClippingPlane();
7302 vtkView->getRenderer()->ResetCameraClippingRange();
7309 \brief Adds preferences for dfont of VTK viewer
7311 \param pIf group identifier
7312 \param param parameter
7313 \return identifier of preferences
7315 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7317 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7319 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7322 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7323 fam.append( tr( "SMESH_FONT_COURIER" ) );
7324 fam.append( tr( "SMESH_FONT_TIMES" ) );
7326 setPreferenceProperty( tfont, "fonts", fam );
7328 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7329 if ( needSize ) f = f | QtxFontEdit::Size;
7330 setPreferenceProperty( tfont, "features", f );
7336 \brief Actions after hypothesis edition
7337 Updates object browser after hypothesis edition
7339 void SMESHGUI::onHypothesisEdit( int result )
7342 SMESHGUI::Modified();
7343 updateObjBrowser( true );
7347 \brief Actions after choosing menu of control modes
7348 Updates control mode actions according to current selection
7350 void SMESHGUI::onUpdateControlActions()
7352 SALOME_ListIO selected;
7353 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7354 aSel->selectedObjects( selected );
7356 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7357 if ( selected.Extent() ) {
7358 if ( selected.First()->hasEntry() ) {
7359 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7360 aControl = anActor->GetControlMode();
7361 SALOME_ListIteratorOfListIO it(selected);
7362 for ( it.Next(); it.More(); it.Next() ) {
7363 Handle(SALOME_InteractiveObject) anIO = it.Value();
7364 if ( anIO->hasEntry() ) {
7365 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7366 if ( aControl != anActor->GetControlMode() ) {
7367 aControl = SMESH_Actor::eNone;
7377 int anAction = ActionToControl( aControl, true );
7379 action( anAction )->setChecked( true );
7381 QMenu* send = (QMenu*)sender();
7382 QList<QAction*> actions = send->actions();
7383 for ( int i = 0; i < actions.size(); i++ )
7384 actions[i]->setChecked( false );
7390 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7391 \param pview view being closed
7393 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7394 #ifndef DISABLE_PLOT2DVIEWER
7395 //Crear all Plot2d Viewers if need.
7396 SMESH::ClearPlot2Viewers(pview);
7398 EmitSignalCloseView();
7401 void SMESHGUI::message( const QString& msg )
7404 QStringList data = msg.split("/");
7405 if ( data.count() > 0 ) {
7406 if ( data.first() == "mesh_loading" ) {
7408 QString entry = data.count() > 1 ? data[1] : QString();
7409 if ( entry.isEmpty() )
7412 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7414 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7417 name = SMESH::fromUtf8(obj->GetName());
7418 if ( name.isEmpty() )
7421 if ( data.last() == "stop" )
7422 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7424 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7425 QApplication::processEvents();
7431 \brief Connects or disconnects signals about activating and cloning view on the module slots
7432 \param pview view which is connected/disconnected
7434 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7438 SUIT_ViewManager* viewMgr = pview->getViewManager();
7440 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7441 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7443 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7444 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7449 \brief Return \c true if object can be renamed
7451 bool SMESHGUI::renameAllowed( const QString& entry) const {
7452 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7456 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7460 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7465 if(appStudy->isComponent(entry) || obj->isReference())
7468 // check type to prevent renaming of inappropriate objects
7469 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7470 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7471 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7472 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7473 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7474 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7481 Rename object by entry.
7482 \param entry entry of the object
7483 \param name new name of the object
7484 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7486 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7488 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7492 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7497 _PTR(Study) aStudy = appStudy->studyDS();
7502 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7504 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7509 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7510 _PTR(GenericAttribute) anAttr;
7511 _PTR(AttributeName) aName;
7513 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7515 // check type to prevent renaming of inappropriate objects
7516 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7517 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7518 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7519 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7520 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7521 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7522 if ( !name.isEmpty() ) {
7523 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7525 // update name of group object and its actor
7526 Handle(SALOME_InteractiveObject) IObject =
7527 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7529 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7530 if( !aGroupObject->_is_nil() ) {
7531 aGroupObject->SetName( qUtf8Printable(name) );
7532 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7533 anActor->setName( qUtf8Printable(name) );
7543 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7545 static QList<QColor> colors;
7547 if ( colors.isEmpty() ) {
7549 for (int s = 0; s < 2 ; s++)
7551 for (int v = 100; v >= 40; v = v - 20)
7553 for (int h = 0; h < 359 ; h = h + 60)
7555 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7560 static int currentColor = randomize( colors.size() );
7562 SALOMEDS::Color color;
7563 color.R = (double)colors[currentColor].red() / 255.0;
7564 color.G = (double)colors[currentColor].green() / 255.0;
7565 color.B = (double)colors[currentColor].blue() / 255.0;
7567 currentColor = (currentColor+1) % colors.count();