1 // Copyright (C) 2007-2020 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_AdaptDlg.h"
34 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
35 #include "SMESHGUI_AddMeshElementDlg.h"
36 #include "SMESHGUI_AddQuadraticElementDlg.h"
37 #include "SMESHGUI_BuildCompoundDlg.h"
38 #include "SMESHGUI_ClippingDlg.h"
39 #include "SMESHGUI_ComputeDlg.h"
40 #include "SMESHGUI_ConvToQuadOp.h"
41 #include "SMESHGUI_CopyMeshDlg.h"
42 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
43 #include "SMESHGUI_DeleteGroupDlg.h"
44 #include "SMESHGUI_DisplayEntitiesDlg.h"
45 #include "SMESHGUI_Displayer.h"
46 #include "SMESHGUI_DuplicateNodesDlg.h"
47 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
48 #include "SMESHGUI_ExtrusionDlg.h"
49 #include "SMESHGUI_FaceGroupsSeparatedByEdgesDlg.h"
50 #include "SMESHGUI_FieldSelectorWdg.h"
51 #include "SMESHGUI_FileInfoDlg.h"
52 #include "SMESHGUI_FileValidator.h"
53 #include "SMESHGUI_FilterDlg.h"
54 #include "SMESHGUI_FilterLibraryDlg.h"
55 #include "SMESHGUI_FilterUtils.h"
56 #include "SMESHGUI_FindElemByPointDlg.h"
57 #include "SMESHGUI_GEOMGenUtils.h"
58 #include "SMESHGUI_GroupDlg.h"
59 #include "SMESHGUI_GroupOnShapeDlg.h"
60 #include "SMESHGUI_GroupOpDlg.h"
61 #include "SMESHGUI_GroupUtils.h"
62 #include "SMESHGUI_Hypotheses.h"
63 #include "SMESHGUI_HypothesesUtils.h"
64 #include "SMESHGUI_Make2DFrom3DOp.h"
65 #include "SMESHGUI_MakeNodeAtPointDlg.h"
66 #include "SMESHGUI_Measurements.h"
67 #include "SMESHGUI_MergeDlg.h"
68 #include "SMESHGUI_MeshInfo.h"
69 #include "SMESHGUI_MeshOp.h"
70 #include "SMESHGUI_MeshOrderOp.h"
71 #include "SMESHGUI_MeshPatternDlg.h"
72 #include "SMESHGUI_MeshUtils.h"
73 #include "SMESHGUI_MultiEditDlg.h"
74 #include "SMESHGUI_NodesDlg.h"
75 #include "SMESHGUI_OffsetDlg.h"
76 #include "SMESHGUI_Operations.h"
77 #include "SMESHGUI_PatternUtils.h"
78 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
79 #include "SMESHGUI_PropertiesDlg.h"
80 #include "SMESHGUI_RemoveElementsDlg.h"
81 #include "SMESHGUI_RemoveNodesDlg.h"
82 #include "SMESHGUI_RenumberingDlg.h"
83 #include "SMESHGUI_ReorientFacesDlg.h"
84 #include "SMESHGUI_RevolutionDlg.h"
85 #include "SMESHGUI_RotationDlg.h"
86 #include "SMESHGUI_ScaleDlg.h"
87 #include "SMESHGUI_Selection.h"
88 #include "SMESHGUI_SewingDlg.h"
89 #include "SMESHGUI_SingleEditDlg.h"
90 #include "SMESHGUI_SmoothingDlg.h"
91 #include "SMESHGUI_SpinBox.h"
92 #include "SMESHGUI_SplitBiQuad.h"
93 #include "SMESHGUI_SymmetryDlg.h"
94 #include "SMESHGUI_TranslationDlg.h"
95 #include "SMESHGUI_TransparencyDlg.h"
96 #include "SMESHGUI_Utils.h"
97 #include "SMESHGUI_VTKUtils.h"
99 #include "SMESH_version.h"
101 #include "SMESH_Actor.h"
102 #include "SMESH_ActorUtils.h"
103 #include "SMESH_Client.hxx"
104 #include "SMESH_Comment.hxx"
105 #include "SMESH_ControlsDef.hxx"
106 #include "SMESH_ScalarBarActor.h"
107 #include "SMESH_TypeFilter.hxx"
109 // SALOME GUI includes
110 #include <LightApp_DataOwner.h>
111 #include <LightApp_NameDlg.h>
112 #include <LightApp_Preferences.h>
113 #include <LightApp_SelectionMgr.h>
114 #include <LightApp_UpdateFlags.h>
115 #include <QtxFontEdit.h>
116 #include <QtxPopupMgr.h>
117 #include <SALOME_ListIO.hxx>
118 #include <SUIT_Desktop.h>
119 #include <SUIT_FileDlg.h>
120 #include <SUIT_MessageBox.h>
121 #include <SUIT_OverrideCursor.h>
122 #include <SUIT_ResourceMgr.h>
123 #include <SUIT_Session.h>
124 #include <SVTK_Renderer.h>
125 #include <SVTK_ViewManager.h>
126 #include <SVTK_ViewModel.h>
127 #include <SVTK_ViewWindow.h>
128 #include <SalomeApp_Application.h>
129 #include <SalomeApp_CheckFileDlg.h>
130 #include <SalomeApp_DataObject.h>
131 #include <SalomeApp_Study.h>
132 #include <SalomeApp_Tools.h>
133 #include <VTKViewer_Algorithm.h>
135 #ifndef DISABLE_PLOT2DVIEWER
136 #include <SPlot2d_ViewModel.h>
137 #include <SPlot2d_Histogram.h>
141 #include <SALOMEconfig.h>
142 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
143 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
144 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
145 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
148 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
149 #include <QApplication>
151 #include <QDialogButtonBox>
155 #include <QTextStream>
159 #include <boost/shared_ptr.hpp>
162 #include <vtkCallbackCommand.h>
163 #include <vtkCamera.h>
164 #include <vtkLookupTable.h>
165 #include <vtkPlane.h>
166 #include <vtkRenderer.h>
168 // SALOME KERNEL includes
169 #include <SALOMEDSClient_ClientFactory.hxx>
170 #include <SALOMEDSClient_IParameters.hxx>
171 #include <SALOMEDSClient_SComponent.hxx>
172 #include <SALOMEDSClient_StudyBuilder.hxx>
173 #include <SALOMEDS_Study.hxx>
174 #include <SALOMEDS_SObject.hxx>
175 #include "utilities.h"
176 #include <SALOME_LifeCycleCORBA.hxx>
179 #include <Standard_ErrorHandler.hxx>
180 #include <NCollection_DataMap.hxx>
181 #include <NCollection_DoubleMap.hxx>
183 #include <Basics_Utils.hxx>
185 // Below macro, when uncommented, switches on simplified (more performant) algorithm
186 // of auto-color picking up
187 #define SIMPLE_AUTOCOLOR
192 //=============================================================
193 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
196 void ExportMeshToFile(int theCommandID);
198 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap);
200 void SetDisplayEntity(int theCommandID);
202 int ActionToControl( int theID, bool theReversed = false );
204 void Control( int theCommandID );
207 //================================================================================
209 * \brief Reads meshes from file
211 //================================================================================
213 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
217 std::string myExtension;
219 if ( theCommandID == SMESHOp::OpImportMED ||
220 theCommandID == SMESHOp::OpPopupImportMED ) {
221 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
222 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
224 else if ( theCommandID == SMESHOp::OpImportUNV ||
225 theCommandID == SMESHOp::OpPopupImportUNV ) {
226 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
228 else if ( theCommandID == SMESHOp::OpImportDAT ||
229 theCommandID == SMESHOp::OpPopupImportDAT ) {
230 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
232 else if ( theCommandID == SMESHOp::OpImportSTL ||
233 theCommandID == SMESHOp::OpPopupImportSTL ) {
234 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
236 else if ( theCommandID == SMESHOp::OpImportCGNS ||
237 theCommandID == SMESHOp::OpPopupImportCGNS ) {
238 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
240 else if ( theCommandID == SMESHOp::OpImportSAUV ||
241 theCommandID == SMESHOp::OpPopupImportSAUV ) {
242 filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
243 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
245 else if ( theCommandID == SMESHOp::OpImportGMF ||
246 theCommandID == SMESHOp::OpPopupImportGMF ) {
247 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
248 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
251 QString anInitialPath = "";
252 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
253 anInitialPath = QDir::currentPath();
255 QStringList filenames;
256 bool toCreateGroups = true;
258 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
259 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
260 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
261 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
262 // fd->setNameFilters( filter );
263 // fd->SetChecked( true );
265 // filenames << fd->selectedFile();
266 // toCreateGroups = fd->IsChecked();
272 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
275 QObject::tr( "SMESH_IMPORT_MESH" ) );
277 if ( filenames.count() > 0 )
279 SUIT_OverrideCursor wc;
280 _PTR(Study) aStudy = SMESH::getStudy();
283 QStringList anEntryList;
284 bool isEmpty = false;
285 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
287 QString filename = *it;
288 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
290 switch ( theCommandID ) {
291 case SMESHOp::OpImportDAT:
292 case SMESHOp::OpPopupImportDAT:
294 // DAT format (currently unsupported)
295 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
296 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
299 case SMESHOp::OpImportUNV:
300 case SMESHOp::OpPopupImportUNV:
303 aMeshes->length( 1 );
304 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
305 if ( aMeshes[0]->_is_nil() )
306 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
307 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
310 case SMESHOp::OpImportMED:
311 case SMESHOp::OpPopupImportMED:
314 SMESH::DriverMED_ReadStatus res;
315 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
316 if ( res != SMESH::DRS_OK ) {
317 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
318 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
322 case SMESHOp::OpImportSTL:
323 case SMESHOp::OpPopupImportSTL:
326 aMeshes->length( 1 );
327 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
328 if ( aMeshes[0]->_is_nil() ) {
329 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
330 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
334 case SMESHOp::OpImportCGNS:
335 case SMESHOp::OpPopupImportCGNS:
338 SMESH::DriverMED_ReadStatus res;
339 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
340 if ( res != SMESH::DRS_OK ) {
341 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
342 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
346 case SMESHOp::OpImportSAUV:
347 case SMESHOp::OpPopupImportSAUV:
350 SMESH::DriverMED_ReadStatus res;
351 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
352 if ( res != SMESH::DRS_OK ) {
353 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
354 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
358 case SMESHOp::OpImportGMF:
359 case SMESHOp::OpPopupImportGMF:
362 SMESH::ComputeError_var res;
363 aMeshes->length( 1 );
364 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
367 if ( res->code != SMESH::DRS_OK ) {
368 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
369 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
370 if ( strlen( res->comment.in() ) > 0 ) {
371 errors.back() += ": ";
372 errors.back() += res->comment.in();
379 catch ( const SALOME::SALOME_Exception& S_ex ) {
380 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
381 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
384 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
386 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
388 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
389 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
390 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
391 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
392 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
394 anEntryList.append( aMeshSO->GetID().c_str() );
402 // update Object browser
403 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
405 // browse to the published meshes
406 if( LightApp_Application* anApp =
407 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
408 anApp->browseObjects( anEntryList );
410 // show Error message box if there were errors
411 if ( errors.count() > 0 ) {
412 SUIT_MessageBox::critical( SMESHGUI::desktop(),
413 QObject::tr( "SMESH_ERROR" ),
414 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
417 // show warning message box, if some imported mesh is empty
419 SUIT_MessageBox::warning( SMESHGUI::desktop(),
420 QObject::tr( "SMESH_WRN_WARNING" ),
421 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
426 //================================================================================
428 * \brief Export selected meshes or groups into a file
430 //================================================================================
432 void ExportMeshToFile( int theCommandID )
434 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
435 SALOME_ListIO selected;
437 aSel->selectedObjects( selected );
439 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
440 theCommandID == SMESHOp::OpPopupExportDAT );
441 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
442 theCommandID == SMESHOp::OpPopupExportMED );
443 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
444 theCommandID == SMESHOp::OpPopupExportUNV );
445 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
446 theCommandID == SMESHOp::OpPopupExportSTL );
447 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
448 theCommandID == SMESHOp::OpPopupExportCGNS );
449 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
450 theCommandID == SMESHOp::OpPopupExportSAUV );
451 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
452 theCommandID == SMESHOp::OpPopupExportGMF );
454 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
455 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
457 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
458 bool aCheckWarn = true;
460 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
461 // get mesh object from selection and check duplication of their names
462 bool hasDuplicatedMeshNames = false;
463 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
464 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
465 SALOME_ListIteratorOfListIO It( selected );
466 for( ; It.More(); It.Next() )
468 Handle(SALOME_InteractiveObject) anIObject = It.Value();
469 SMESH::SMESH_IDSource_var aMeshItem =
470 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
471 if ( aMeshItem->_is_nil() ) {
472 SUIT_MessageBox::warning( SMESHGUI::desktop(),
473 QObject::tr( "SMESH_WRN_WARNING" ),
474 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
477 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
478 if ( aCheckWarn && !aGroup->_is_nil() )
480 QMessageBox msgBox(SUIT_MessageBox::Warning,
481 QObject::tr("SMESH_WRN_WARNING"),
482 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
483 QMessageBox::StandardButton::NoButton,
484 SMESHGUI::desktop());
485 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
486 msgBox.addButton(QMessageBox::Ok);
487 msgBox.addButton(QMessageBox::Cancel);
488 msgBox.setDefaultButton(QMessageBox::Cancel);
489 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
490 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
491 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
492 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
493 if ( msgBox.exec() != QMessageBox::Ok )
496 if ( dontShowCheckBox.checkState() == Qt::Checked && resMgr )
497 resMgr->setValue( "SMESH", "show_warning", false);
500 QString aMeshName = anIObject->getName();
502 // check for name duplications
503 if ( !hasDuplicatedMeshNames )
504 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
505 if( aMeshName == (*aMeshIter).second ) {
506 hasDuplicatedMeshNames = true;
511 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
514 if( hasDuplicatedMeshNames && isMED ) {
515 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
516 QObject::tr("SMESH_WRN_WARNING"),
517 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
518 QObject::tr("SMESH_BUT_YES"),
519 QObject::tr("SMESH_BUT_NO"), 0, 1);
524 aMeshIter = aMeshList.begin();
525 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
526 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
527 QString aMeshName = (*aMeshIter).second;
529 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
531 // check for equal group names within each mesh
532 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
533 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
534 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
535 int aRet = SUIT_MessageBox::warning
536 (SMESHGUI::desktop(),
537 QObject::tr("SMESH_WRN_WARNING"),
538 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
539 QObject::tr("SMESH_BUT_YES"),
540 QObject::tr("SMESH_BUT_NO"), 0, 1);
547 // Warn the user about presence of not supported elements
549 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
553 notSupportedElemTypes.push_back( SMESH::Entity_0D );
554 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
559 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
560 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
561 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
562 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
563 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
564 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
565 notSupportedElemTypes.push_back( SMESH::Entity_0D );
566 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
571 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
572 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
573 notSupportedElemTypes.push_back( SMESH::Entity_0D );
574 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
579 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
584 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
585 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
586 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
587 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
588 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
589 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
590 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
591 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
596 notSupportedElemTypes.push_back( SMESH::Entity_0D );
597 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
598 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
599 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
600 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
601 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
602 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
603 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
604 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
605 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
607 if ( ! notSupportedElemTypes.empty() )
609 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
610 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
611 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
612 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
614 if ( !presentNotSupported.empty() )
617 const char* typeMsg[] = {
618 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
619 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
620 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
621 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
622 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
623 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
624 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
625 "SMESH_BIQUADRATIC_PENTAHEDRONS",
626 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
628 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
629 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
630 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
632 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
633 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
634 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
635 if ( iType != presentNotSupported.size() - 1 )
636 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
638 int aRet = SUIT_MessageBox::warning
639 (SMESHGUI::desktop(),
640 QObject::tr("SMESH_WRN_WARNING"),
641 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
642 QObject::tr("SMESH_BUT_YES"),
643 QObject::tr("SMESH_BUT_NO"), 0, 1);
648 // Get parameters of export operation
651 int aFormat =-1; // for MED version used for write
652 bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
654 // Init the parameters with the default values
655 bool aIsASCII_STL = true;
656 bool toCreateGroups = false;
658 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
659 bool toOverwrite = true;
660 bool toFindOutDim = true;
661 double zTol = resMgr ? resMgr->doubleValue( "SMESH", "med_ztolerance", 0. ) : 0.;
663 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
664 QString anInitialPath = "";
665 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
666 anInitialPath = QDir::currentPath();
668 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
670 // Get a file name to write in and additional options
671 if ( isUNV || isDAT || isGMF ) // Export w/o options
674 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
676 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
678 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
679 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
680 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
681 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
682 anInitialPath + QString("/") + aMeshName,
683 aFilter, aTitle, false);
685 else if ( isCGNS )// Export to CGNS
687 const char* theByTypeResource = "cgns_group_elems_by_type";
688 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
690 QStringList checkBoxes;
691 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
693 SalomeApp_CheckFileDlg* fd =
694 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
695 fd->setWindowTitle( aTitle );
696 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
697 if ( !anInitialPath.isEmpty() )
698 fd->setDirectory( anInitialPath );
699 fd->selectFile(aMeshName);
700 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
701 fd->setValidator( fv );
702 fd->SetChecked( toCreateGroups, 0 );
705 aFilename = fd->selectedFile();
706 toOverwrite = fv->isOverwrite(aFilename);
707 toCreateGroups = fd->IsChecked(0);
708 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
712 else if ( isSTL ) // Export to STL
714 QMap<QString, int> aFilterMap;
715 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
716 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
719 QMap<QString, int>::const_iterator it = aFilterMap.begin();
720 for ( ; it != aFilterMap.end(); ++it )
721 filters.push_back( it.key() );
723 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
724 fd->setWindowTitle( aTitle );
725 fd->setNameFilters( filters );
726 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
727 if ( !anInitialPath.isEmpty() )
728 fd->setDirectory( anInitialPath );
729 fd->selectFile(aMeshName);
733 aFilename = fd->selectedFile();
734 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
739 else if ( isMED || isSAUV ) // Export to MED or SAUV
741 int defaultVersion = 0;
742 QMap<QString, int> aFilterMap;
744 //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
745 //QString vmed (aMesh->GetVersionString(-1, 2));
746 SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
747 if ( mvok->length() > 0)
748 defaultVersion = mvok[0]; // the current version to set the default filter on it
749 for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
751 QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
752 MESSAGE("MED version: " << vs.toStdString());
753 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
757 aFilterMap.insert("All files (*)", -1 );
758 aFilterMap.insert("SAUV files (*.sauv)", defaultVersion ); // 0 = default filter (defaultVersion)
759 aFilterMap.insert("SAUV files (*.sauve)", -1 );
762 QMap<QString, int>::const_iterator it = aFilterMap.begin();
763 QString aDefaultFilter = it.key();
764 for ( ; it != aFilterMap.end(); ++it ) {
765 filters.push_back( it.key() );
766 if (it.value() == defaultVersion) // explicit default for MED = current MED version
767 aDefaultFilter = it.key();
769 QStringList checkBoxes;
770 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
772 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
773 QList< QWidget* > wdgList;
774 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
775 wdgList.append( fieldSelWdg );
777 QWidget* zTolWdg = new QWidget();
778 QCheckBox* zTolCheck = new QCheckBox( QObject::tr( "SMESH_ZTOLERANCE" ), zTolWdg );
779 SMESHGUI_SpinBox* zTolSpin = new SMESHGUI_SpinBox( zTolWdg );
780 QHBoxLayout* zTolLayout = new QHBoxLayout( zTolWdg );
781 zTolLayout->addWidget( zTolCheck );
782 zTolLayout->addWidget( zTolSpin );
783 zTolLayout->setMargin( 0 );
784 zTolSpin->RangeStepAndValidator( 0, 1e+100, 1., "length_precision" );
785 zTolSpin->setValue( zTol );
786 QObject::connect( zTolCheck, SIGNAL( toggled(bool)), zTolSpin, SLOT( setEnabled(bool)));
787 zTolCheck->setChecked( resMgr->booleanValue( "SMESH", "enable_ztolerance", false ));
788 zTolSpin ->setEnabled( zTolCheck->isChecked() );
789 wdgList.append( zTolWdg );
791 SalomeApp_CheckFileDlg* fd =
792 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
793 fd->setWindowTitle( aTitle );
794 fd->setNameFilters( filters );
795 fd->selectNameFilter( aDefaultFilter );
796 fd->SetChecked( toCreateGroups, 0 );
797 fd->SetChecked( toFindOutDim, 1 );
798 if ( !anInitialPath.isEmpty() )
799 fd->setDirectory( anInitialPath );
800 fd->selectFile(aMeshName);
803 QListView *lview = fd->findChild<QListView*>("listView");
805 lview->setMinimumHeight(200);
807 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
809 tview->setMinimumHeight(200);
812 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
813 fd->setValidator( fv );
818 //MESSAGE("******* Loop on file dialog ***********");
821 aFilename = fd->selectedFile();
823 aFilename = QString::null;
826 aFormat = aFilterMap[fd->selectedNameFilter()];
827 //MESSAGE("selected version: " << aFormat << " file: " << aFilename.toUtf8().constData());
828 toOverwrite = fv->isOverwrite(aFilename);
829 //MESSAGE("toOverwrite:" << toOverwrite);
831 if ( !aFilename.isEmpty() ) {
833 // append is only possible if the existing file format is compatible
834 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
835 MESSAGE("Append check, isVersionOk:" << isVersionOk);
836 if ( !isVersionOk ) {
837 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
838 QObject::tr("SMESH_WRN_WARNING"),
839 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
840 QObject::tr("SMESH_BUT_YES"),
841 QObject::tr("SMESH_BUT_NO"), 0, 1);
845 //MESSAGE("incompatible MED file version for add, overwrite accepted");
851 //MESSAGE("incompatible MED file version for add, overwrite refused");
854 QStringList aMeshNamesCollisionList;
855 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
856 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
857 QString anExistingMeshName( aMeshNames[ i ] );
858 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
859 QString anExportMeshName = (*aMeshIter).second;
860 if( anExportMeshName == anExistingMeshName ) {
861 aMeshNamesCollisionList.append( anExportMeshName );
866 if( !aMeshNamesCollisionList.isEmpty() ) {
868 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
869 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
870 QObject::tr("SMESH_WRN_WARNING"),
871 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
872 QObject::tr("SMESH_BUT_YES"),
873 QObject::tr("SMESH_BUT_NO"),
874 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
875 MESSAGE("answer collision name " << aRet);
886 toCreateGroups = fd->IsChecked(0);
887 toFindOutDim = fd->IsChecked(1);
888 zTol = zTolCheck->isChecked() ? zTolSpin->value() : -1;
889 fieldSelWdg->GetSelectedFields();
890 if ( resMgr ) resMgr->setValue( "SMESH", "enable_ztolerance", zTolCheck->isChecked() );
892 if ( !fieldSelWdg->parent() )
894 if ( !zTolWdg->parent() )
905 if ( !aFilename.isEmpty() ) {
906 // Check whether the file already exists and delete it if yes
907 QFile aFile( aFilename );
908 if ( aFile.exists() && toOverwrite )
910 SUIT_OverrideCursor wc;
913 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
914 // bool Renumber = false;
915 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
917 // Renumber= resMgr->booleanValue("renumbering");
919 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
920 // aMeshEditor->RenumberNodes();
921 // aMeshEditor->RenumberElements();
922 // if ( SMESHGUI::automaticUpdate() )
923 // SMESH::UpdateView();
925 if ( isMED && isOkToWrite)
927 MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
928 aMeshIter = aMeshList.begin();
929 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
931 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
932 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
933 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
934 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
935 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
936 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ) && zTol < 0 )
937 aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
938 toOverwrite && aMeshIndex == 0, toFindOutDim );
940 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
941 toCreateGroups, aFormat,
942 toOverwrite && aMeshIndex == 0, toFindOutDim,
943 fields, geoAssFields.toLatin1().data(), zTol );
948 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
950 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
951 if( !aMeshItem->_is_nil() )
952 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
957 if ( aMeshOrGroup->_is_equivalent( aMesh ))
958 aMesh->ExportDAT( aFilename.toUtf8().data() );
960 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
964 if ( aMeshOrGroup->_is_equivalent( aMesh ))
965 aMesh->ExportUNV( aFilename.toUtf8().data() );
967 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
971 if ( aMeshOrGroup->_is_equivalent( aMesh ))
972 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
974 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
978 aMeshIter = aMeshList.begin();
979 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
981 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
982 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
983 aMeshItem->ExportCGNS( aMeshOrGroup,
984 aFilename.toUtf8().data(),
985 toOverwrite && aMeshIndex == 0,
991 toCreateGroups = true;
992 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
995 catch (const SALOME::SALOME_Exception& S_ex){
997 SUIT_MessageBox::warning(SMESHGUI::desktop(),
998 QObject::tr("SMESH_WRN_WARNING"),
999 QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
1005 inline void InverseEntityMode(unsigned int& theOutputMode,
1006 unsigned int theMode)
1008 bool anIsNotPresent = ~theOutputMode & theMode;
1010 theOutputMode |= theMode;
1012 theOutputMode &= ~theMode;
1015 void SetDisplayEntity(int theCommandID)
1017 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1018 SALOME_ListIO selected;
1020 aSel->selectedObjects( selected );
1022 if ( selected.Extent() >= 1 ) {
1023 SUIT_OverrideCursor wc;
1024 SALOME_ListIteratorOfListIO It( selected );
1025 for( ; It.More(); It.Next()){
1026 Handle(SALOME_InteractiveObject) IObject = It.Value();
1027 if(IObject->hasEntry()){
1028 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1029 unsigned int aMode = anActor->GetEntityMode();
1030 switch(theCommandID){
1031 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1032 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1033 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1034 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1035 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1036 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1039 anActor->SetEntityMode(aMode);
1048 SalomeApp_Application* app =
1049 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1053 LightApp_SelectionMgr* aSel = app->selectionMgr();
1054 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1055 if ( !aSel || !appStudy )
1058 SALOME_ListIO selected;
1059 aSel->selectedObjects( selected );
1060 if ( selected.IsEmpty() )
1063 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1065 _PTR(Study) aStudy = appStudy->studyDS();
1066 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1067 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1068 if ( aMainObject->_is_nil() )
1071 SUIT_OverrideCursor wc;
1073 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1075 QList<SALOMEDS::Color> aReservedColors;
1077 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1078 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1080 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1082 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1083 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1084 #else // old algorithm for auto-colors
1085 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1086 aReservedColors.append( aColor );
1087 #endif // SIMPLE_AUTOCOLOR
1088 aGroupObject->SetColor( aColor );
1090 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1091 if ( aGroupSObject ) {
1094 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1095 switch ( aGroupObject->GetType ()) {
1097 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1099 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1101 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1103 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1105 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1106 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1109 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1110 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1116 SMESH::RepaintCurrentView();
1119 void OverallMeshQuality()
1121 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1122 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1123 SALOME_ListIO selected;
1125 aSel->selectedObjects( selected );
1127 if ( selected.IsEmpty() ) return;
1128 SALOME_ListIteratorOfListIO It( selected );
1129 for ( ; It.More(); It.Next() ) {
1130 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1131 ctrlDlg->showInfo( It.Value() );
1136 QString functorToString( SMESH::Controls::FunctorPtr f )
1138 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1139 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1140 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1141 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1142 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1143 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1144 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1145 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1146 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1147 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1148 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1149 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1150 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1151 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1152 type = QObject::tr( "WARP_ELEMENTS" );
1153 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1154 type = QObject::tr( "TAPER_ELEMENTS" );
1155 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1156 type = QObject::tr( "SKEW_ELEMENTS" );
1157 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1158 type = QObject::tr( "AREA_ELEMENTS" );
1159 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1160 type = QObject::tr( "LENGTH_EDGES" );
1161 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1162 type = QObject::tr( "LENGTH2D_EDGES" );
1163 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1164 type = QObject::tr( "DEFLECTION2D_FACES" );
1165 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1166 type = QObject::tr( "MULTI_BORDERS" );
1167 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1168 type = QObject::tr( "MULTI2D_BORDERS" );
1169 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1170 type = QObject::tr( "FREE_NODES" );
1171 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1172 type = QObject::tr( "FREE_EDGES" );
1173 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1174 type = QObject::tr( "FREE_BORDERS" );
1175 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1176 type = QObject::tr( "FREE_FACES" );
1177 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1178 type = QObject::tr( "BARE_BORDER_VOLUME" );
1179 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1180 type = QObject::tr( "BARE_BORDER_FACE" );
1181 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1182 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1183 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1184 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1185 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1186 type = QObject::tr( "EQUAL_NODE" );
1187 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1188 type = QObject::tr( "EQUAL_EDGE" );
1189 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1190 type = QObject::tr( "EQUAL_FACE" );
1191 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1192 type = QObject::tr( "EQUAL_VOLUME" );
1193 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1194 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1198 void SaveDistribution()
1200 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1201 SALOME_ListIO selected;
1203 aSel->selectedObjects( selected );
1205 if ( selected.Extent() == 1 ) {
1206 Handle(SALOME_InteractiveObject) anIO = selected.First();
1207 if ( anIO->hasEntry() ) {
1208 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1210 anActor->GetScalarBarActor() &&
1211 anActor->GetControlMode() != SMESH_Actor::eNone )
1213 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1214 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1215 if ( aScalarBarActor && aFunctor ) {
1216 SMESH::Controls::NumericalFunctor* aNumFun =
1217 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1219 std::vector<int> elements;
1220 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1221 if ( mesh->_is_nil() ) {
1222 SMESH::SMESH_IDSource_var idSource =
1223 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1224 if ( !idSource->_is_nil() )
1226 SMESH::long_array_var ids = idSource->GetIDs();
1227 elements.resize( ids->length() );
1228 for ( unsigned i = 0; i < elements.size(); ++i )
1229 elements[i] = ids[i];
1232 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1233 vtkLookupTable* lookupTable =
1234 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1235 double * minmax = lookupTable->GetRange();
1236 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1237 std::vector<int> nbEvents;
1238 std::vector<double> funValues;
1239 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1240 elements, minmax, isLogarithmic );
1241 QString anInitialPath = "";
1242 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1243 anInitialPath = QDir::currentPath();
1244 QString aMeshName = anIO->getName();
1246 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1247 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1248 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1249 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1250 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1253 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1255 if ( !aFilename.isEmpty() ) {
1256 QFile f( aFilename );
1257 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1258 QTextStream out( &f );
1259 out << "# Mesh: " << aMeshName << endl;
1260 out << "# Control: " << functorToString( aFunctor ) << endl;
1262 out.setFieldWidth( 10 );
1263 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1264 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1275 void ShowElement( int theCommandID )
1277 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1278 SALOME_ListIO selected;
1280 aSel->selectedObjects( selected );
1282 if ( selected.Extent() == 1 ) {
1283 Handle(SALOME_InteractiveObject) anIO = selected.First();
1284 if ( anIO->hasEntry() ) {
1285 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1287 anActor->GetScalarBarActor() &&
1288 anActor->GetControlMode() != SMESH_Actor::eNone )
1290 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1291 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1292 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1294 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1295 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1302 #ifndef DISABLE_PLOT2DVIEWER
1303 void PlotDistribution()
1305 SalomeApp_Application* app =
1306 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1310 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1311 SALOME_ListIO selected;
1313 aSel->selectedObjects( selected );
1315 if ( selected.Extent() == 1 ) {
1316 Handle(SALOME_InteractiveObject) anIO = selected.First();
1317 if ( anIO->hasEntry() ) {
1318 //Find Actor by entry before getting Plot2d viewer,
1319 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1320 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1322 SUIT_ViewManager* aViewManager =
1323 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1327 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1331 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1335 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1337 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1338 QString functorName = functorToString( anActor->GetFunctor());
1339 QString aHistogramName("%1 : %2");
1340 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1341 aHistogram->setName(aHistogramName);
1342 aHistogram->setHorTitle(functorName);
1343 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1344 aPlot->displayObject(aHistogram, true);
1349 #endif //DISABLE_PLOT2DVIEWER
1351 void DisableAutoColor()
1353 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1354 SALOME_ListIO selected;
1356 aSel->selectedObjects( selected );
1358 if ( selected.Extent() ) {
1359 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1360 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1361 if ( !aMesh->_is_nil() ) {
1362 aMesh->SetAutoColor( false );
1369 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1370 SALOME_ListIO selected;
1372 aSel->selectedObjects( selected );
1373 if ( selected.Extent() )
1375 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1376 _PTR(Study) aStudy = SMESH::getStudy();
1377 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1379 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1380 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1387 // Break link with Shaper model
1388 void breakShaperLink()
1390 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1391 SALOME_ListIO selected;
1393 aSel->selectedObjects(selected);
1394 if (selected.Extent()) {
1395 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1396 _PTR(Study) aStudy = SMESH::getStudy();
1397 std::string aEntry = anIObject->getEntry();
1398 _PTR(SObject) aSObj = aStudy->FindObjectID(aEntry);
1400 std::string aName = aSObj->GetName();
1401 QMessageBox::StandardButton aRes = SUIT_MessageBox::warning(SMESHGUI::desktop(),
1402 QObject::tr("SMESH_WRN_WARNING"),
1403 QObject::tr("MSG_BREAK_SHAPER_LINK").arg(aName.c_str()),
1404 SUIT_MessageBox::Yes | SUIT_MessageBox::No, SUIT_MessageBox::No);
1405 if (aRes == SUIT_MessageBox::Yes) {
1406 SUIT_DataOwnerPtrList aList;
1407 aSel->selected(aList, "ObjectBrowser", true);
1408 SUIT_DataOwner* aOwn = aList.first();
1409 LightApp_DataOwner* sowner = dynamic_cast<LightApp_DataOwner*>(aOwn);
1410 QString aREntry = sowner->entry();
1412 static GEOM::GEOM_Gen_var geomGen;
1413 if (CORBA::is_nil(geomGen)) {
1414 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>
1415 (SUIT_Session::session()->activeApplication());
1417 SALOME_LifeCycleCORBA* ls = new SALOME_LifeCycleCORBA(app->namingService());
1418 Engines::EngineComponent_var comp =
1419 ls->FindOrLoad_Component("FactoryServer", "SHAPERSTUDY");
1420 geomGen = GEOM::GEOM_Gen::_narrow(comp);
1423 if (!CORBA::is_nil(geomGen))
1425 geomGen->BreakLink(aREntry.toStdString().c_str());
1426 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1428 // remove actors whose objects are removed by BreakLink()
1429 QList<SUIT_ViewWindow*> wndList = SMESHGUI::desktop()->windows();
1430 SUIT_ViewWindow* wnd;
1431 foreach(wnd, wndList)
1432 SMESH::UpdateActorsAfterUpdateStudy(wnd);
1440 //================================================================================
1442 * \brief Return true if a mesh icon == ICON_SMESH_TREE_GEOM_MODIF
1443 * which means that the mesh can't be modified. It should be either re-computed
1444 * or breakShaperLink()'ed. Warn the user about it.
1446 //================================================================================
1448 bool warnOnGeomModif()
1450 SALOME_ListIO selected;
1451 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1452 aSel->selectedObjects(selected,"",/*convertReferences=*/false);
1454 SALOME_ListIteratorOfListIO It( selected );
1455 for ( ; It.More(); It.Next() )
1457 Handle(SALOME_InteractiveObject) io = It.Value();
1458 if ( !io->hasEntry() ) continue;
1459 _PTR(SObject) so = SMESH::getStudy()->FindObjectID( io->getEntry() );
1460 SMESH::SMESH_Mesh_var mesh;
1461 while ( mesh->_is_nil() && so && so->GetID() != "0:" )
1463 CORBA::Object_var obj = SMESH::SObjectToObject( so );
1464 SMESH::SMESH_IDSource_var isrc = SMESH::SMESH_IDSource::_narrow( obj );
1465 if ( isrc->_is_nil() )
1466 so = so->GetFather();
1468 mesh = isrc->GetMesh();
1470 if ( mesh->_is_nil() ) continue;
1471 so = SMESH::FindSObject( mesh );
1472 if ( !so ) continue;
1473 _PTR(GenericAttribute) attr;
1474 so->FindAttribute( attr, "AttributePixMap" );
1475 _PTR(AttributePixMap) pixmap = attr;
1476 if ( !pixmap ) continue;
1478 if ( pixmap->GetPixMap() == "ICON_SMESH_TREE_GEOM_MODIF" )
1480 SUIT_MessageBox::warning(SMESHGUI::desktop(),
1481 QObject::tr("SMESH_WRN_WARNING"),
1482 QObject::tr("MSG_WARN_ON_GEOM_MODIF"));
1489 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1491 SALOME_ListIO selected;
1492 SalomeApp_Application* app =
1493 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1497 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1498 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1499 if ( !aSel || !appStudy )
1502 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1503 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1504 aModule->EmitSignalDeactivateDialog();
1505 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1506 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1511 aSel->selectedObjects( selected );
1513 if ( selected.Extent() >= 1 )
1515 switch ( theCommandID ) {
1516 case SMESHOp::OpTransparency:
1518 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1519 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1522 case SMESHOp::OpProperties:
1525 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1526 QColor orientationColor, outlineColor, volumeColor;
1527 int deltaF = 0, deltaV = 0;
1530 double ballScale = 1.0;
1532 int outlineWidth = 1;
1533 double shrinkCoef = 0.0;
1534 double orientationScale = 0.0;
1535 bool orientation3d = false;
1536 VTK::MarkerType markerType = VTK::MT_NONE;
1537 VTK::MarkerScale markerScale = VTK::MS_NONE;
1539 bool hasNodes = false;
1540 int presentEntities = 0;
1541 bool firstTime = true;
1543 SALOME_ListIteratorOfListIO It( selected );
1544 for ( ; It.More(); It.Next() ) {
1545 Handle(SALOME_InteractiveObject) IObject = It.Value();
1546 if ( !IObject->hasEntry() ) continue;
1547 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1548 if ( !anActor || !anActor->GetObject() ) continue;
1551 // nodes: color, marker
1552 anActor->GetNodeColor( color[0], color[1], color[2] );
1553 nodeColor.setRgbF( color[0], color[1], color[2] );
1554 markerType = anActor->GetMarkerType();
1555 markerScale = anActor->GetMarkerScale();
1556 markerId = anActor->GetMarkerTexture();
1557 // edges: color, width
1558 anActor->GetEdgeColor( color[0], color[1], color[2] );
1559 edgeColor.setRgbF( color[0], color[1], color[2] );
1560 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1561 // faces: front color, back color (delta)
1562 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1563 faceColor.setRgbF( color[0], color[1], color[2] );
1564 // faces: front color, back color (delta)
1565 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1566 volumeColor.setRgbF( color[0], color[1], color[2] );
1567 // 0d elements: color, size
1568 anActor->Get0DColor( color[0], color[1], color[2] );
1569 elem0dColor.setRgbF( color[0], color[1], color[2] );
1570 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1571 // balls: color, size
1572 anActor->GetBallColor( color[0], color[1], color[2] );
1573 ballColor.setRgbF( color[0], color[1], color[2] );
1574 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1575 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1577 anActor->GetOutlineColor( color[0], color[1], color[2] );
1578 outlineColor.setRgbF( color[0], color[1], color[2] );
1579 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1580 // orientation vectors: color, scale, 3d flag
1581 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1582 orientationColor.setRgbF( color[0], color[1], color[2] );
1583 orientationScale = anActor->GetFacesOrientationScale();
1584 orientation3d = anActor->GetFacesOrientation3DVectors();
1586 shrinkCoef = anActor->GetShrinkFactor();
1589 firstTime = false; // we only take properties from first object (for performance reasons)
1592 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1593 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1594 presentEntities = presentEntities | SMESH_Actor::eEdges;
1595 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1596 presentEntities = presentEntities | SMESH_Actor::eFaces;
1597 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1598 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1599 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1600 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1601 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1602 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1604 // as we know that all types of elements are present, we can exit the loop
1605 if ( presentEntities == SMESH_Actor::eAllEntity )
1609 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1610 // nodes: color, marker
1611 dlg.setNodeColor( nodeColor );
1612 if( markerType != VTK::MT_USER )
1613 dlg.setNodeMarker( markerType, markerScale );
1615 dlg.setNodeCustomMarker( markerId );
1616 // edges: color, line width
1617 dlg.setEdgeColor( edgeColor );
1618 dlg.setEdgeWidth( edgeWidth );
1619 // faces: front color, back color
1620 dlg.setFaceColor( faceColor, deltaF );
1621 // volumes: normal color, reversed color
1622 dlg.setVolumeColor( volumeColor, deltaV );
1623 // outlines: color, line width
1624 dlg.setOutlineColor( outlineColor );
1625 dlg.setOutlineWidth( outlineWidth );
1626 // 0d elements: color, size
1627 dlg.setElem0dColor( elem0dColor );
1628 dlg.setElem0dSize( elem0dSize );
1629 // balls: color, size
1630 dlg.setBallColor( ballColor );
1631 //dlg.setBallSize( ballSize );
1632 dlg.setBallScale( ballScale );
1633 // orientation: color, scale, 3d flag
1634 dlg.setOrientationColor( orientationColor );
1635 dlg.setOrientationSize( int( orientationScale * 100. ) );
1636 dlg.setOrientation3d( orientation3d );
1637 // shrink: scale factor
1638 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1639 // hide unused controls
1640 dlg.showControls( presentEntities, hasNodes );
1643 nodeColor = dlg.nodeColor();
1644 markerType = dlg.nodeMarkerType();
1645 markerScale = dlg.nodeMarkerScale();
1646 markerId = dlg.nodeMarkerId();
1647 edgeColor = dlg.edgeColor();
1648 edgeWidth = dlg.edgeWidth();
1649 faceColor = dlg.faceColor();
1650 deltaF = dlg.faceColorDelta();
1651 volumeColor = dlg.volumeColor();
1652 deltaV = dlg.volumeColorDelta();
1653 outlineColor = dlg.outlineColor();
1654 outlineWidth = dlg.outlineWidth();
1655 elem0dColor = dlg.elem0dColor();
1656 elem0dSize = dlg.elem0dSize();
1657 ballColor = dlg.ballColor();
1658 // ballSize = dlg.ballSize();
1659 ballScale = dlg.ballScale();
1660 orientationColor = dlg.orientationColor();
1661 orientationScale = dlg.orientationSize() / 100.;
1662 orientation3d = dlg.orientation3d();
1663 shrinkCoef = dlg.shrinkCoef() / 100.;
1665 // store point markers that might be changed by the user
1666 theMarkerMap = dlg.customMarkers();
1668 // set properties from dialog box to the presentations
1669 SALOME_ListIteratorOfListIO It( selected );
1670 for ( ; It.More(); It.Next() ) {
1671 Handle(SALOME_InteractiveObject) IObject = It.Value();
1672 if ( !IObject->hasEntry() ) continue;
1673 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1674 if ( !anActor ) continue;
1676 // nodes: color, marker
1677 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1678 if ( markerType != VTK::MT_USER ) {
1679 anActor->SetMarkerStd( markerType, markerScale );
1682 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1683 if ( iter != theMarkerMap.end() )
1684 anActor->SetMarkerTexture( markerId, iter->second.second );
1686 // volumes: normal color, reversed color (delta)
1687 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1688 // faces: front color, back color (delta)
1689 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1690 // edges: color, width
1691 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1692 anActor->SetLineWidth( edgeWidth );
1694 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1695 anActor->SetOutlineWidth( outlineWidth );
1696 // 0D elements: color, size
1697 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1698 anActor->Set0DSize( elem0dSize );
1699 // balls: color, size
1700 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1701 // anActor->SetBallSize( ballSize );
1702 anActor->SetBallScale( ballScale );
1703 // orientation: color, scale, 3d flag
1704 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1705 anActor->SetFacesOrientationScale( orientationScale );
1706 anActor->SetFacesOrientation3DVectors( orientation3d );
1708 anActor->SetShrinkFactor( shrinkCoef );
1710 // for groups, set also proper color
1711 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1712 if ( !aGroupObject->_is_nil() ) {
1713 SMESH::ElementType anElementType = aGroupObject->GetType();
1715 switch( anElementType ) {
1717 aColor = nodeColor; break;
1719 aColor = edgeColor; break;
1721 aColor = faceColor; break;
1723 aColor = volumeColor; break;
1725 aColor = elem0dColor; break;
1727 aColor = ballColor; break;
1731 if ( aColor.isValid() ) {
1732 SALOMEDS::Color aGroupColor;
1733 aGroupColor.R = aColor.redF();
1734 aGroupColor.G = aColor.greenF();
1735 aGroupColor.B = aColor.blueF();
1736 aGroupObject->SetColor( aGroupColor );
1738 } // if ( !aGroupObject->_is_nil() )
1739 } // for ( ; It.More(); It.Next() )
1740 SMESH::RepaintCurrentView();
1741 } // if ( dlg.exec() )
1743 } // case SMESHOp::OpProperties:
1744 } // switch(theCommandID)
1745 SUIT_OverrideCursor wc;
1746 SALOME_ListIteratorOfListIO It( selected );
1747 for( ; It.More(); It.Next()){
1748 Handle(SALOME_InteractiveObject) IObject = It.Value();
1749 if(IObject->hasEntry()){
1750 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1751 switch(theCommandID){
1752 case SMESHOp::OpDMWireframe:
1753 anActor->SetRepresentation(SMESH_Actor::eEdge);
1755 case SMESHOp::OpDMShading:
1756 anActor->SetRepresentation(SMESH_Actor::eSurface);
1758 case SMESHOp::OpDMShrink:
1759 if(anActor->IsShrunk())
1760 anActor->UnShrink();
1762 anActor->SetShrink();
1764 case SMESHOp::OpDMNodes:
1765 anActor->SetRepresentation(SMESH_Actor::ePoint);
1767 case SMESHOp::OpRepresentationLines:
1768 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1769 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1771 case SMESHOp::OpRepresentationArcs:
1772 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1773 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1779 SMESH::RepaintCurrentView();
1783 int ActionToControl( int theID, bool theReversed )
1785 NCollection_DoubleMap<int,int> ActionControl;
1786 ActionControl.Bind( 0, SMESH_Actor::eNone );
1787 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1788 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1789 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1790 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1791 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1792 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1793 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1794 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1795 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1796 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1797 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1798 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1799 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1800 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1801 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1802 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1803 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1804 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1805 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1806 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1807 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1808 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1809 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1810 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1811 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1812 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1813 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1814 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1817 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1818 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1821 void Control( int theCommandID )
1823 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1824 _PTR(Study) aStudy = SMESH::getStudy();
1826 SALOME_ListIO selected;
1827 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1828 aSel->selectedObjects( selected );
1830 if ( !selected.IsEmpty() ) {
1831 SALOME_ListIteratorOfListIO It(selected);
1832 for ( ; It.More(); It.Next())
1834 Handle(SALOME_InteractiveObject) anIO = It.Value();
1835 if ( !anIO.IsNull() ) {
1836 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1838 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1839 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1840 if ( !anIDSrc->_is_nil() ) {
1841 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1842 if (( !anActor && selected.Extent() == 1 ) &&
1843 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1845 anActor->SetControlMode( aControl );
1846 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1847 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1851 if ( anActor->GetControlMode() != aControl )
1852 anActor->SetControlMode( aControl );
1853 QString functorName = functorToString( anActor->GetFunctor() );
1854 int anEntitiesCount = anActor->GetNumberControlEntities();
1855 if (anEntitiesCount >= 0)
1856 functorName = functorName + ": " + QString::number(anEntitiesCount);
1857 anActor->GetScalarBarActor()->SetTitle( functorName.toUtf8().constData() );
1858 SMESH::RepaintCurrentView();
1859 #ifndef DISABLE_PLOT2DVIEWER
1860 if ( anActor->GetPlot2Histogram() ) {
1861 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1862 QString aHistogramName("%1 : %2");
1863 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1864 aHistogram->setName( aHistogramName );
1865 aHistogram->setHorTitle( functorName );
1866 SMESH::ProcessIn2DViewers( anActor );
1878 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1879 SMESH::MeshObjectType theType,
1880 const QString theInTypeName,
1881 QString & theOutTypeName)
1883 SMESH_TypeFilter aTypeFilter( theType );
1885 if ( !theIO.IsNull() )
1887 entry = theIO->getEntry();
1888 LightApp_DataOwner owner( entry );
1889 if ( aTypeFilter.isOk( &owner )) {
1890 theOutTypeName = theInTypeName;
1898 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1900 _PTR(Study) aStudy = SMESH::getStudy();
1901 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1903 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1904 CORBA::String_var anID = aSComp->GetID().c_str();
1905 if ( !strcmp(anID.in(),theIO->getEntry()) )
1911 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1912 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1913 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1914 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1915 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1923 // QString CheckHomogeneousSelection()
1925 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1926 // SALOME_ListIO selected;
1928 // aSel->selectedObjects( selected );
1930 // QString RefType = CheckTypeObject(selected.First());
1931 // SALOME_ListIteratorOfListIO It(selected);
1932 // for ( ; It.More(); It.Next())
1934 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1935 // QString Type = CheckTypeObject(IObject);
1936 // if ( Type.compare(RefType) != 0 )
1937 // return "Heterogeneous Selection";
1943 uint randomize( uint size )
1945 static bool initialized = false;
1946 if ( !initialized ) {
1947 qsrand( QDateTime::currentDateTime().toTime_t() );
1951 v = uint( (double)( v ) / RAND_MAX * size );
1952 v = qMax( uint(0), qMin ( v, size-1 ) );
1958 void SMESHGUI::OnEditDelete()
1960 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1961 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1962 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1964 _PTR(Study) aStudy = SMESH::getStudy();
1965 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1966 _PTR(GenericAttribute) anAttr;
1967 _PTR(AttributeIOR) anIOR;
1969 const int objectCountLimit = 30; // PAL23599
1970 int objectCount = 0;
1972 QString aParentComponent = QString::null;
1974 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1976 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1977 if ( anIO.IsNull() ) continue;
1979 QString father = "unknown", name;
1981 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1983 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1984 // check if object is reference
1985 _PTR(SObject) aRefSObj;
1986 if ( aSO->ReferencedObject( aRefSObj ) ) {
1987 name = QString::fromStdString ( aRefSObj->GetName() );
1988 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1991 name = anIO->getName();
1994 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
1995 aNameList.append("\n - ");
1996 aNameList.append( name );
1999 if( aParentComponent.isNull() )
2000 aParentComponent = father;
2001 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
2002 aParentComponent = "";
2004 if ( objectCount >= objectCountLimit )
2005 aNameList.append("\n - ...");
2007 if ( objectCount == 0 )
2008 return; // No Valid Objects Selected
2010 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
2011 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2012 QObject::tr("ERR_ERROR"),
2013 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
2016 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
2017 if (SUIT_MessageBox::warning
2018 (SMESHGUI::desktop(),
2019 QObject::tr("SMESH_WRN_WARNING"),
2020 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
2021 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
2022 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
2025 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2027 // Put one level of sub-objects of the selected SO's into a list
2028 // in order to get objects inside folders like "Assigned Algorithms"
2029 std::list< _PTR(SObject) > listSO;
2030 SALOME_ListIteratorOfListIO It(selected);
2031 for( ; It.More(); It.Next()) // loop on selected IO's
2033 Handle(SALOME_InteractiveObject) IObject = It.Value();
2034 if(IObject->hasEntry()) {
2035 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
2037 // disable removal of "SMESH" component object
2038 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
2040 if ( engineIOR() == anIOR->Value().c_str() )
2043 //Check the referenced object
2044 _PTR(SObject) aRefSObject;
2045 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
2046 aSO = aRefSObject; // Delete main Object instead of reference
2048 listSO.push_back( aSO );
2050 _PTR(ChildIterator) it = aStudy->NewChildIterator( aSO );
2051 for (it->InitEx(false); it->More(); it->Next())
2052 listSO.push_back( it->Value() );
2055 // Check if none of objects to delete is referred from outside
2056 std::list< _PTR(SObject) >::reverse_iterator ritSO;
2057 std::vector< _PTR(SObject) > subSO;
2058 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2060 _PTR(SObject) SO = *ritSO;
2061 if ( !SO ) continue;
2063 int nbChildren = SO->GetLastChildTag();
2065 subSO.reserve( 1 + nbChildren );
2066 subSO.push_back( SO );
2067 if ( nbChildren > 0 )
2069 _PTR(ChildIterator) it = aStudy->NewChildIterator( SO );
2070 for ( it->InitEx( true ); it->More(); it->Next() )
2071 subSO.push_back( it->Value() );
2073 for ( size_t i = 0; i < subSO.size(); ++i )
2075 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( subSO[i] );
2076 for ( size_t j = 0; j < aReferences.size(); j++ ) {
2077 _PTR(SComponent) aComponent = aReferences[j]->GetFatherComponent();
2078 std::string type = aComponent->ComponentDataType();
2079 if ( type != "SMESH" )
2081 SUIT_MessageBox::warning( anApp->desktop(),
2082 QObject::tr("WRN_WARNING"),
2083 QObject::tr("DEP_OBJECT") );
2084 return; // outside SMESH, there is an object depending on a SMESH object
2090 // Treat SO's in the list starting from the back
2091 aStudyBuilder->NewCommand(); // There is a transaction
2092 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2094 _PTR(SObject) SO = *ritSO;
2095 if ( !SO ) continue;
2096 std::string anEntry = SO->GetID();
2098 /** Erase graphical object and remove all its data **/
2099 if ( SO->FindAttribute( anAttr, "AttributeIOR" )) {
2100 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
2102 /** Remove an object from data structures **/
2103 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
2104 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
2105 if ( !aGroup->_is_nil() ) { // DELETE GROUP
2106 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
2107 aMesh->RemoveGroup( aGroup );
2109 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
2110 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2111 aMesh->RemoveSubMesh( aSubMesh );
2114 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2115 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2116 QString objType = CheckTypeObject(IObject);
2117 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2118 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2119 aStudyBuilder->RemoveObjectWithChildren( SO );
2121 else {// default action: remove SObject from the study
2122 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2123 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2125 aStudyBuilder->RemoveObjectWithChildren( SO );
2129 } /* listSO back loop */
2131 aStudyBuilder->CommitCommand();
2133 /* Clear any previous selection */
2135 aSel->setSelectedObjects( l1 );
2137 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2141 SMESHGUI_EXPORT CAM_Module* createModule()
2143 return new SMESHGUI();
2146 SMESHGUI_EXPORT char* getModuleVersion() {
2147 return (char*)SMESH_VERSION_STR;
2151 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2153 //=============================================================================
2157 //=============================================================================
2158 SMESHGUI::SMESHGUI() :
2159 SalomeApp_Module( "SMESH" )
2161 if ( CORBA::is_nil( myComponentSMESH ) )
2163 CORBA::Boolean anIsEmbeddedMode;
2164 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2165 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2167 // 0019923: EDF 765 SMESH : default values of hypothesis
2168 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2169 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2170 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2171 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2172 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2174 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2175 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2176 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2178 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2179 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2183 myActiveDialogBox = 0;
2184 myFilterLibraryDlg = 0;
2188 myEventCallbackCommand = vtkCallbackCommand::New();
2189 myEventCallbackCommand->Delete();
2190 myEventCallbackCommand->SetClientData( this );
2191 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2194 /* load resources for all available meshers */
2195 SMESH::InitAvailableHypotheses();
2198 //=============================================================================
2202 //=============================================================================
2203 SMESHGUI::~SMESHGUI()
2207 //=============================================================================
2211 //=============================================================================
2212 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2214 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2216 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2221 //=============================================================================
2225 //=============================================================================
2226 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2228 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2232 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2233 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2234 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2235 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2236 return autoUpdate && !exceeded;
2239 //=============================================================================
2243 //=============================================================================
2244 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2245 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2247 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2251 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2252 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2253 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2255 SMESH::long_array_var info = theMesh->GetMeshInfo();
2256 long nbOdElems = info[SMDSEntity_0D];
2257 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2258 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2259 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2260 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2261 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2262 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2263 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2264 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2265 info[SMDSEntity_Polyhedra] +
2266 info[SMDSEntity_Hexagonal_Prism];
2267 long nbBalls = info[SMDSEntity_Ball];
2269 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2270 *nbElements = requestedSize;
2272 *entities = SMESH_Actor::eAllEntity;
2275 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2277 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2279 if ( incrementalLimit ) {
2282 if ( nbOdElems > 0 ) {
2283 if ( total + nbOdElems > updateLimit ) {
2284 *entities = *entities & ~SMESH_Actor::e0DElements;
2285 *hidden = *hidden | SMESH_Actor::e0DElements;
2292 if ( nbEdges > 0 ) {
2293 if ( total + nbEdges > updateLimit ) {
2294 *entities = *entities & ~SMESH_Actor::eEdges;
2295 *hidden = *hidden | SMESH_Actor::eEdges;
2302 if ( nbFaces > 0 ) {
2303 if ( total + nbFaces > updateLimit ) {
2304 *entities = *entities & ~SMESH_Actor::eFaces;
2305 *hidden = *hidden | SMESH_Actor::eFaces;
2312 if ( nbVolumes > 0 ) {
2313 if ( total + nbVolumes > updateLimit ) {
2314 *entities = *entities & ~SMESH_Actor::eVolumes;
2315 *hidden = *hidden | SMESH_Actor::eVolumes;
2322 if ( nbBalls > 0 ) {
2323 if ( total + nbBalls > updateLimit ) {
2324 *entities = *entities & ~SMESH_Actor::eBallElem;
2325 *hidden = *hidden | SMESH_Actor::eBallElem;
2333 return autoUpdate && !exceeded;
2336 //=============================================================================
2340 //=============================================================================
2341 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2343 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2346 //=============================================================================
2350 //=============================================================================
2351 SMESHGUI* SMESHGUI::GetSMESHGUI()
2353 SMESHGUI* smeshMod = 0;
2354 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2357 CAM_Module* module = app->module( "Mesh" );
2358 smeshMod = dynamic_cast<SMESHGUI*>( module );
2366 Standard_EXPORT SMESHGUI* GetComponentGUI()
2368 return SMESHGUI::GetSMESHGUI();
2372 //=============================================================================
2376 //=============================================================================
2377 void SMESHGUI::SetState(int aState)
2382 //=============================================================================
2386 //=============================================================================
2387 void SMESHGUI::ResetState()
2392 //=============================================================================
2396 //=============================================================================
2397 void SMESHGUI::EmitSignalDeactivateDialog()
2399 emit SignalDeactivateActiveDialog();
2402 //=============================================================================
2406 //=============================================================================
2407 void SMESHGUI::EmitSignalStudyFrameChanged()
2409 emit SignalStudyFrameChanged();
2412 //=============================================================================
2416 //=============================================================================
2417 void SMESHGUI::EmitSignalCloseAllDialogs()
2419 emit SignalCloseAllDialogs();
2422 //=============================================================================
2426 //=============================================================================
2427 void SMESHGUI::EmitSignalVisibilityChanged()
2429 emit SignalVisibilityChanged();
2432 //=============================================================================
2436 //=============================================================================
2437 void SMESHGUI::EmitSignalCloseView()
2439 emit SignalCloseView();
2442 //=============================================================================
2446 //=============================================================================
2447 void SMESHGUI::EmitSignalActivatedViewManager()
2449 emit SignalActivatedViewManager();
2452 //=============================================================================
2456 //=============================================================================
2457 QDialog *SMESHGUI::GetActiveDialogBox()
2459 return myActiveDialogBox;
2462 //=============================================================================
2466 //=============================================================================
2467 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2469 myActiveDialogBox = (QDialog *) aDlg;
2473 //=============================================================================
2477 //=============================================================================
2478 SUIT_Desktop* SMESHGUI::desktop()
2480 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2482 return app->desktop();
2487 //=============================================================================
2491 //=============================================================================
2492 SalomeApp_Study* SMESHGUI::activeStudy()
2494 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2496 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2501 //=============================================================================
2505 //=============================================================================
2506 void SMESHGUI::Modified( bool theIsUpdateActions )
2508 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2509 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2510 appStudy->Modified();
2511 if( theIsUpdateActions )
2512 app->updateActions();
2517 //=============================================================================
2521 //=============================================================================
2522 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2524 /* Here the position is on the bottom right corner - 10 */
2525 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2527 SUIT_Desktop *PP = desktop();
2528 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2529 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2534 * \brief Verifies whether study of operation is locked
2535 * \param theMess - specifies whether message box must be shown if study is locked
2536 * \return State of study.
2538 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2539 * is locked when corresponding message box appears
2541 bool SMESHGUI::isStudyLocked( bool theMessage )
2543 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2546 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2547 QObject::tr( "WRN_WARNING" ),
2548 QObject::tr( "WRN_STUDY_LOCKED" ) );
2554 //=============================================================================
2558 //=============================================================================
2559 bool SMESHGUI::OnGUIEvent( int theCommandID )
2561 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2565 SUIT_ResourceMgr* mgr = resourceMgr();
2569 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2570 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2572 //QAction* act = action( theCommandID );
2574 switch (theCommandID) {
2575 case SMESHOp::OpDelete:
2576 if(isStudyLocked()) break;
2579 case SMESHOp::OpImportDAT:
2580 case SMESHOp::OpImportUNV:
2581 case SMESHOp::OpImportMED:
2582 case SMESHOp::OpImportSTL:
2583 case SMESHOp::OpImportCGNS:
2584 case SMESHOp::OpImportSAUV:
2585 case SMESHOp::OpImportGMF:
2586 case SMESHOp::OpPopupImportDAT:
2587 case SMESHOp::OpPopupImportUNV:
2588 case SMESHOp::OpPopupImportMED:
2589 case SMESHOp::OpPopupImportSTL:
2590 case SMESHOp::OpPopupImportCGNS:
2591 case SMESHOp::OpPopupImportSAUV:
2592 case SMESHOp::OpPopupImportGMF:
2594 if(isStudyLocked()) break;
2595 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2599 case SMESHOp::OpFileInformation:
2601 SALOME_ListIO selected;
2602 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2604 aSel->selectedObjects( selected );
2605 if( selected.Extent() )
2607 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2608 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2609 if ( !aMesh->_is_nil() )
2611 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2617 case SMESHOp::OpExportDAT:
2618 case SMESHOp::OpExportMED:
2619 case SMESHOp::OpExportUNV:
2620 case SMESHOp::OpExportSTL:
2621 case SMESHOp::OpExportCGNS:
2622 case SMESHOp::OpExportSAUV:
2623 case SMESHOp::OpExportGMF:
2624 case SMESHOp::OpPopupExportDAT:
2625 case SMESHOp::OpPopupExportMED:
2626 case SMESHOp::OpPopupExportUNV:
2627 case SMESHOp::OpPopupExportSTL:
2628 case SMESHOp::OpPopupExportCGNS:
2629 case SMESHOp::OpPopupExportSAUV:
2630 case SMESHOp::OpPopupExportGMF:
2632 ::ExportMeshToFile(theCommandID);
2636 case SMESHOp::OpReset: // SCALAR BAR
2638 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2639 SALOME_ListIO selected;
2641 aSel->selectedObjects( selected );
2643 SALOME_ListIteratorOfListIO it(selected);
2644 for( ; it.More(); it.Next()) {
2645 Handle(SALOME_InteractiveObject) anIO = it.Value();
2646 if( anIO->hasEntry() ) {
2647 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2648 anActor->SetControlMode( SMESH_Actor::eNone );
2649 #ifndef DISABLE_PLOT2DVIEWER
2650 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2652 anActor->UpdateFilter();
2656 SMESH::UpdateView();
2659 case SMESHOp::OpScalarBarProperties:
2661 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2664 case SMESHOp::OpShowScalarBar:
2666 // show/hide scalar bar
2667 ::ShowElement(theCommandID);
2670 case SMESHOp::OpSaveDistribution:
2672 // dump control distribution data to the text file
2673 ::SaveDistribution();
2677 case SMESHOp::OpShowDistribution:
2679 // show/hide distribution
2680 ::ShowElement(theCommandID);
2684 #ifndef DISABLE_PLOT2DVIEWER
2685 case SMESHOp::OpPlotDistribution:
2687 // plot distribution
2688 ::PlotDistribution();
2694 case SMESHOp::OpAutoColor:
2698 case SMESHOp::OpDisableAutoColor:
2699 ::DisableAutoColor();
2702 case SMESHOp::OpClipping:
2703 case SMESHOp::OpTransparency:
2704 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2707 case SMESHOp::OpDMWireframe:
2708 case SMESHOp::OpDMShading:
2709 case SMESHOp::OpDMNodes:
2710 case SMESHOp::OpDMShrink:
2711 ::SetDisplayMode(theCommandID, myMarkerMap);
2714 //2D quadratic representation
2715 case SMESHOp::OpRepresentationLines:
2716 case SMESHOp::OpRepresentationArcs:
2717 ::SetDisplayMode(theCommandID, myMarkerMap);
2721 case SMESHOp::OpDE0DElements:
2722 case SMESHOp::OpDEEdges:
2723 case SMESHOp::OpDEFaces:
2724 case SMESHOp::OpDEVolumes:
2725 case SMESHOp::OpDEBalls:
2726 case SMESHOp::OpDEAllEntity:
2727 ::SetDisplayEntity(theCommandID);
2730 // Choose entities to be displayed
2731 case SMESHOp::OpDEChoose:
2733 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2737 case SMESHOp::OpOrientationOnFaces:
2739 SUIT_OverrideCursor wc;
2740 LightApp_SelectionMgr* mgr = selectionMgr();
2741 SALOME_ListIO selected; mgr->selectedObjects( selected );
2743 SALOME_ListIteratorOfListIO it(selected);
2744 for( ; it.More(); it.Next()) {
2745 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2746 if(anIObject->hasEntry()) {
2747 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2748 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2755 case SMESHOp::OpUpdate:
2757 if(isStudyLocked()) break;
2758 SUIT_OverrideCursor wc;
2761 SMESH::UpdateView();
2763 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2764 SMESH::OnVisuException();
2766 catch (...) { // PAL16774 (Crash after display of many groups)
2767 SMESH::OnVisuException();
2771 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2772 aSel->selectedObjects( l );
2773 aSel->setSelectedObjects( l );
2777 case SMESHOp::OpHide:
2778 case SMESHOp::OpShow:
2779 case SMESHOp::OpShowOnly:
2781 SUIT_OverrideCursor wc;
2782 SMESH::EDisplaing anAction;
2783 switch (theCommandID) {
2784 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2785 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2786 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2789 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2790 SALOME_ListIO sel_objects, to_process;
2792 aSel->selectedObjects( sel_objects );
2794 if ( theCommandID==SMESHOp::OpShowOnly )
2796 //MESSAGE("anAction = SMESH::eDisplayOnly");
2797 startOperation( myEraseAll );
2800 extractContainers( sel_objects, to_process );
2805 SALOME_ListIteratorOfListIO It( to_process );
2806 for ( ; It.More(); It.Next())
2808 Handle(SALOME_InteractiveObject) IOS = It.Value();
2809 if ( IOS->hasEntry() )
2811 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2812 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2813 break; // PAL16774 (Crash after display of many groups)
2815 if (anAction == SMESH::eDisplayOnly)
2816 anAction = SMESH::eDisplay;
2821 // PAL13338 + PAL15161 -->
2822 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2823 SMESH::UpdateView();
2824 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2826 // PAL13338 + PAL15161 <--
2828 catch (...) { // PAL16774 (Crash after display of many groups)
2829 SMESH::OnVisuException();
2832 if (anAction == SMESH::eErase) {
2834 aSel->setSelectedObjects( l1 );
2837 aSel->setSelectedObjects( to_process );
2839 if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2840 ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2841 vtkwnd->GetRenderer()->AdjustActors();
2846 case SMESHOp::OpNode:
2848 if(isStudyLocked()) break;
2851 EmitSignalDeactivateDialog();
2853 ( new SMESHGUI_NodesDlg( this ) )->show();
2856 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2861 case SMESHOp::OpEditMeshOrSubMesh:
2862 case SMESHOp::OpEditMesh:
2863 case SMESHOp::OpEditSubMesh:
2864 case SMESHOp::OpMeshOrder:
2865 case SMESHOp::OpCreateSubMesh:
2866 if ( warnOnGeomModif() )
2867 break; // action forbiden as geometry modified
2869 case SMESHOp::OpCreateMesh:
2870 case SMESHOp::OpCompute:
2871 case SMESHOp::OpComputeSubMesh:
2872 case SMESHOp::OpPreCompute:
2873 case SMESHOp::OpEvaluate:
2874 startOperation( theCommandID );
2876 case SMESHOp::OpCopyMesh:
2878 if (isStudyLocked()) break;
2879 EmitSignalDeactivateDialog();
2880 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2883 case SMESHOp::OpBuildCompoundMesh:
2885 if (isStudyLocked()) break;
2886 EmitSignalDeactivateDialog();
2887 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2891 case SMESHOp::OpDiagonalInversion:
2892 case SMESHOp::OpUnionOfTwoTriangle:
2896 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2900 if ( isStudyLocked() )
2902 if ( warnOnGeomModif() )
2903 break; // action forbiden as geometry modified
2905 /*Standard_Boolean aRes;
2906 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2907 if ( aMesh->_is_nil() )
2909 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2910 tr( "SMESH_BAD_SELECTION" ) );
2914 EmitSignalDeactivateDialog();
2915 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2916 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2918 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2921 case SMESHOp::OpOrientation:
2922 case SMESHOp::OpUnionOfTriangles:
2923 case SMESHOp::OpCuttingOfQuadrangles:
2924 case SMESHOp::OpSplitVolumes:
2928 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2932 if ( isStudyLocked() )
2934 if ( warnOnGeomModif() )
2935 break; // action forbiden as geometry modified
2937 EmitSignalDeactivateDialog();
2938 SMESHGUI_MultiEditDlg* aDlg = NULL;
2939 if ( theCommandID == SMESHOp::OpOrientation )
2940 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2941 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2942 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2943 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2944 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2946 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2951 case SMESHOp::OpSmoothing:
2953 if(isStudyLocked()) break;
2954 if ( warnOnGeomModif() )
2955 break; // action forbiden as geometry modified
2957 EmitSignalDeactivateDialog();
2958 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2961 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2965 case SMESHOp::OpExtrusion:
2967 if (isStudyLocked()) break;
2968 if ( warnOnGeomModif() )
2969 break; // action forbiden as geometry modified
2971 EmitSignalDeactivateDialog();
2972 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2974 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2978 case SMESHOp::OpExtrusionAlongAPath:
2980 if (isStudyLocked()) break;
2981 if ( warnOnGeomModif() )
2982 break; // action forbiden as geometry modified
2984 EmitSignalDeactivateDialog();
2985 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2987 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2991 case SMESHOp::OpRevolution:
2993 if(isStudyLocked()) break;
2994 if ( warnOnGeomModif() )
2995 break; // action forbiden as geometry modified
2997 EmitSignalDeactivateDialog();
2998 ( new SMESHGUI_RevolutionDlg( this ) )->show();
3001 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3005 case SMESHOp::OpPatternMapping:
3007 if ( isStudyLocked() )
3009 if ( warnOnGeomModif() )
3010 break; // action forbiden as geometry modified
3013 EmitSignalDeactivateDialog();
3014 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
3017 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3022 // Adaptation - begin
3023 case SMESHOp::OpUniformRefinement:
3024 case SMESHOp::OpHONewCase:
3025 case SMESHOp::OpHOCaseFollow:
3026 case SMESHOp::OpHONewIter:
3027 case SMESHOp::OpHOIterCompute:
3028 case SMESHOp::OpHOIterComputePublish:
3029 case SMESHOp::OpHOEdit:
3030 case SMESHOp::OpHODelete:
3031 case SMESHOp::OpMGAdapt:
3033 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3034 SMESHGUI_AdaptDlg *aDlg = new SMESHGUI_AdaptDlg( this, theCommandID, aMesh);
3039 case SMESHOp::OpSplitBiQuadratic:
3040 case SMESHOp::OpConvertMeshToQuadratic:
3041 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3042 case SMESHOp::OpReorientFaces:
3043 case SMESHOp::OpCreateGeometryGroup:
3045 if ( warnOnGeomModif() )
3046 break; // action forbiden as geometry modified
3047 startOperation( theCommandID );
3050 case SMESHOp::OpCreateGroup:
3054 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3058 if(isStudyLocked()) break;
3059 if ( warnOnGeomModif() )
3060 break; // action forbiden as geometry modified
3061 EmitSignalDeactivateDialog();
3062 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3064 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3065 SALOME_ListIO selected;
3067 aSel->selectedObjects( selected );
3069 int nbSel = selected.Extent();
3071 // check if mesh is selected
3072 aMesh = SMESH::GetMeshByIO( selected.First() );
3074 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3079 case SMESHOp::OpConstructGroup:
3083 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3087 if(isStudyLocked()) break;
3088 if ( warnOnGeomModif() )
3089 break; // action forbiden as geometry modified
3090 EmitSignalDeactivateDialog();
3092 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3093 SALOME_ListIO selected;
3095 aSel->selectedObjects( selected );
3097 int nbSel = selected.Extent();
3099 // check if submesh is selected
3100 Handle(SALOME_InteractiveObject) IObject = selected.First();
3101 if (IObject->hasEntry()) {
3102 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3104 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3105 if (!aSubMesh->_is_nil()) {
3107 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3108 // get submesh elements list by types
3109 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3110 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3111 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3112 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3113 // create group for each type o elements
3114 QString aName = IObject->getName();
3115 QStringList anEntryList;
3116 if (aNodes->length() > 0) {
3117 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3118 aGroup->Add(aNodes.inout());
3119 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3120 anEntryList.append( aSObject->GetID().c_str() );
3122 if (aEdges->length() > 0) {
3123 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3124 aGroup->Add(aEdges.inout());
3125 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3126 anEntryList.append( aSObject->GetID().c_str() );
3128 if (aFaces->length() > 0) {
3129 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3130 aGroup->Add(aFaces.inout());
3131 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3132 anEntryList.append( aSObject->GetID().c_str() );
3134 if (aVolumes->length() > 0) {
3135 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3136 aGroup->Add(aVolumes.inout());
3137 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3138 anEntryList.append( aSObject->GetID().c_str() );
3141 anApp->browseObjects( anEntryList );
3143 catch(const SALOME::SALOME_Exception & S_ex){
3144 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3151 SUIT_MessageBox::warning(desktop(),
3152 tr("SMESH_WRN_WARNING"),
3153 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3158 case SMESHOp::OpEditGroup:
3162 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3166 if(isStudyLocked()) break;
3167 if ( warnOnGeomModif() )
3168 break; // action forbiden as geometry modified
3169 EmitSignalDeactivateDialog();
3171 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3172 SALOME_ListIO selected;
3174 aSel->selectedObjects( selected );
3176 SALOME_ListIteratorOfListIO It (selected);
3177 int nbSelectedGroups = 0;
3178 for ( ; It.More(); It.Next() )
3180 SMESH::SMESH_GroupBase_var aGroup =
3181 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3182 if (!aGroup->_is_nil()) {
3184 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3188 if (nbSelectedGroups == 0)
3190 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3196 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3198 if(isStudyLocked()) break;
3199 if (myState == 800) {
3200 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3201 if (aDlg) aDlg->onAdd();
3206 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3208 if(isStudyLocked()) break;
3209 if (myState == 800) {
3210 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3211 if (aDlg) aDlg->onRemove();
3216 case SMESHOp::OpEditGeomGroupAsGroup:
3220 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3224 if(isStudyLocked()) break;
3225 EmitSignalDeactivateDialog();
3227 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3228 SALOME_ListIO selected;
3230 aSel->selectedObjects( selected );
3232 SALOME_ListIteratorOfListIO It (selected);
3233 for ( ; It.More(); It.Next() )
3235 SMESH::SMESH_GroupOnGeom_var aGroup =
3236 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3237 if (!aGroup->_is_nil()) {
3238 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3243 SMESH::SMESH_GroupOnFilter_var aGroup =
3244 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3245 if (!aGroup->_is_nil()) {
3246 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3254 case SMESHOp::OpUnionGroups:
3255 case SMESHOp::OpIntersectGroups:
3256 case SMESHOp::OpCutGroups:
3260 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3264 if ( isStudyLocked() )
3266 if ( warnOnGeomModif() )
3267 break; // action forbiden as geometry modified
3269 EmitSignalDeactivateDialog();
3271 SMESHGUI_GroupOpDlg* aDlg = 0;
3272 if ( theCommandID == SMESHOp::OpUnionGroups )
3273 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3274 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3275 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3277 aDlg = new SMESHGUI_CutGroupsDlg( this );
3284 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3286 if ( isStudyLocked() )
3288 if ( warnOnGeomModif() )
3289 break; // action forbiden as geometry modified
3291 EmitSignalDeactivateDialog();
3292 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3298 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3300 if ( isStudyLocked() )
3302 if ( warnOnGeomModif() )
3303 break; // action forbiden as geometry modified
3305 EmitSignalDeactivateDialog();
3306 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3312 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3316 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3320 if ( isStudyLocked() )
3323 EmitSignalDeactivateDialog();
3325 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3329 case SMESHOp::OpMeshInformation:
3330 case SMESHOp::OpWhatIs:
3332 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3333 EmitSignalDeactivateDialog();
3334 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3335 SALOME_ListIO selected;
3337 aSel->selectedObjects( selected );
3339 if ( selected.Extent() > 1 ) { // a dlg for each IO
3340 SALOME_ListIteratorOfListIO It( selected );
3341 for ( ; It.More(); It.Next() ) {
3342 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3343 dlg->showInfo( It.Value() );
3348 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3354 case SMESHOp::OpFindElementByPoint:
3356 startOperation( theCommandID );
3360 case SMESHOp::OpEditHypothesis:
3362 if(isStudyLocked()) break;
3363 if ( warnOnGeomModif() )
3364 break; // action forbiden as geometry modified
3366 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3367 SALOME_ListIO selected;
3369 aSel->selectedObjects( selected );
3371 int nbSel = selected.Extent();
3374 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3375 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3377 if ( !aHypothesis->_is_nil() )
3379 SMESHGUI_GenericHypothesisCreator* aCreator =
3380 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3383 // set geometry of mesh and sub-mesh to aCreator
3384 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3385 if ( selected.Extent() == 1 )
3387 QString subGeomID, meshGeomID;
3388 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3389 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3391 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3392 aCreator->setShapeEntry( subGeomID );
3393 aCreator->setMainShapeEntry( meshGeomID );
3397 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3407 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3409 if(isStudyLocked()) break;
3410 if ( warnOnGeomModif() )
3411 break; // action forbiden as geometry modified
3412 SUIT_OverrideCursor wc;
3414 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3415 SALOME_ListIO selected;
3417 aSel->selectedObjects( selected, QString::null, false );
3419 SALOME_ListIteratorOfListIO It(selected);
3420 for (int i = 0; It.More(); It.Next(), i++) {
3421 Handle(SALOME_InteractiveObject) IObject = It.Value();
3422 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3425 aSel->setSelectedObjects( l1 );
3430 case SMESHOp::OpElem0D:
3431 case SMESHOp::OpBall:
3432 case SMESHOp::OpEdge:
3433 case SMESHOp::OpTriangle:
3434 case SMESHOp::OpQuadrangle:
3435 case SMESHOp::OpPolygon:
3436 case SMESHOp::OpTetrahedron:
3437 case SMESHOp::OpHexahedron:
3438 case SMESHOp::OpPentahedron:
3439 case SMESHOp::OpPyramid:
3440 case SMESHOp::OpHexagonalPrism:
3442 if(isStudyLocked()) break;
3443 if ( warnOnGeomModif() )
3444 break; // action forbiden as geometry modified
3446 EmitSignalDeactivateDialog();
3447 SMDSAbs_EntityType type = SMDSEntity_Edge;
3448 switch (theCommandID) {
3449 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3450 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3451 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3452 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3453 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3454 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3455 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3456 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3457 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3458 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3461 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3464 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3468 case SMESHOp::OpPolyhedron:
3470 if(isStudyLocked()) break;
3471 if ( warnOnGeomModif() )
3472 break; // action forbiden as geometry modified
3474 EmitSignalDeactivateDialog();
3475 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3478 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3482 case SMESHOp::OpQuadraticEdge:
3483 case SMESHOp::OpQuadraticTriangle:
3484 case SMESHOp::OpBiQuadraticTriangle:
3485 case SMESHOp::OpQuadraticQuadrangle:
3486 case SMESHOp::OpBiQuadraticQuadrangle:
3487 case SMESHOp::OpQuadraticPolygon:
3488 case SMESHOp::OpQuadraticTetrahedron:
3489 case SMESHOp::OpQuadraticPyramid:
3490 case SMESHOp::OpQuadraticPentahedron:
3491 case SMESHOp::OpBiQuadraticPentahedron:
3492 case SMESHOp::OpQuadraticHexahedron:
3493 case SMESHOp::OpTriQuadraticHexahedron:
3495 if(isStudyLocked()) break;
3496 if ( warnOnGeomModif() )
3497 break; // action forbiden as geometry modified
3499 EmitSignalDeactivateDialog();
3500 SMDSAbs_EntityType type = SMDSEntity_Last;
3502 switch (theCommandID) {
3503 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3504 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3505 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3506 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3507 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3508 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3509 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3510 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3511 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3512 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3513 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3514 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3517 if ( type != SMDSEntity_Last )
3518 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3521 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3522 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3526 case SMESHOp::OpRemoveNodes:
3528 if(isStudyLocked()) break;
3529 if ( warnOnGeomModif() )
3530 break; // action forbiden as geometry modified
3532 EmitSignalDeactivateDialog();
3533 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3536 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3537 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3541 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3543 if(isStudyLocked()) break;
3544 if ( warnOnGeomModif() )
3545 break; // action forbiden as geometry modified
3547 EmitSignalDeactivateDialog();
3548 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3552 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3553 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3557 case SMESHOp::OpClearMesh: {
3559 if(isStudyLocked()) break;
3560 if ( warnOnGeomModif() )
3561 break; // action forbiden as geometry modified
3563 SALOME_ListIO selected;
3564 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3565 aSel->selectedObjects( selected );
3567 SUIT_OverrideCursor wc;
3568 SALOME_ListIteratorOfListIO It (selected);
3569 for ( ; It.More(); It.Next() )
3571 Handle(SALOME_InteractiveObject) IOS = It.Value();
3572 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3573 if ( aMesh->_is_nil()) continue;
3576 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3577 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3578 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3579 // hide groups and submeshes
3580 _PTR(ChildIterator) anIter =
3581 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3582 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3584 _PTR(SObject) so = anIter->Value();
3585 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3588 catch (const SALOME::SALOME_Exception& S_ex){
3590 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3594 SMESH::UpdateView();
3598 case SMESHOp::OpRemoveOrphanNodes:
3600 if(isStudyLocked()) break;
3601 if ( warnOnGeomModif() )
3602 break; // action forbiden as geometry modified
3603 SALOME_ListIO selected;
3604 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3605 aSel->selectedObjects( selected );
3606 if ( selected.Extent() == 1 ) {
3607 Handle(SALOME_InteractiveObject) anIO = selected.First();
3608 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3609 if ( !aMesh->_is_nil() ) {
3610 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3611 tr( "SMESH_WARNING" ),
3612 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3613 SUIT_MessageBox::Yes |
3614 SUIT_MessageBox::No,
3615 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3618 SUIT_OverrideCursor wc;
3619 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3620 int removed = aMeshEditor->RemoveOrphanNodes();
3621 SUIT_MessageBox::information(SMESHGUI::desktop(),
3622 tr("SMESH_INFORMATION"),
3623 tr("NB_NODES_REMOVED").arg(removed));
3624 if ( removed > 0 ) {
3625 SMESH::UpdateView();
3626 SMESHGUI::Modified();
3629 catch (const SALOME::SALOME_Exception& S_ex) {
3630 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3639 case SMESHOp::OpRenumberingNodes:
3641 if(isStudyLocked()) break;
3642 if ( warnOnGeomModif() )
3643 break; // action forbiden as geometry modified
3645 EmitSignalDeactivateDialog();
3646 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3650 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3651 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3655 case SMESHOp::OpRenumberingElements:
3657 if(isStudyLocked()) break;
3658 if ( warnOnGeomModif() )
3659 break; // action forbiden as geometry modified
3661 EmitSignalDeactivateDialog();
3662 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3666 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3667 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3671 case SMESHOp::OpTranslation:
3673 if(isStudyLocked()) break;
3674 if ( warnOnGeomModif() )
3675 break; // action forbiden as geometry modified
3677 EmitSignalDeactivateDialog();
3678 ( new SMESHGUI_TranslationDlg( this ) )->show();
3681 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3682 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3686 case SMESHOp::OpRotation:
3688 if(isStudyLocked()) break;
3689 if ( warnOnGeomModif() )
3690 break; // action forbiden as geometry modified
3692 EmitSignalDeactivateDialog();
3693 ( new SMESHGUI_RotationDlg( this ) )->show();
3696 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3697 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3701 case SMESHOp::OpSymmetry:
3703 if(isStudyLocked()) break;
3704 if ( warnOnGeomModif() )
3705 break; // action forbiden as geometry modified
3707 EmitSignalDeactivateDialog();
3708 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3711 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3712 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3716 case SMESHOp::OpScale:
3718 if(isStudyLocked()) break;
3719 if ( warnOnGeomModif() )
3720 break; // action forbiden as geometry modified
3722 EmitSignalDeactivateDialog();
3723 ( new SMESHGUI_ScaleDlg( this ) )->show();
3726 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3727 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3732 case SMESHOp::OpOffset:
3734 if(isStudyLocked()) break;
3735 if ( warnOnGeomModif() )
3736 break; // action forbiden as geometry modified
3738 EmitSignalDeactivateDialog();
3739 ( new SMESHGUI_OffsetDlg( this ) )->show();
3742 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3743 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3748 case SMESHOp::OpSewing:
3750 if(isStudyLocked()) break;
3751 if ( warnOnGeomModif() )
3752 break; // action forbiden as geometry modified
3754 EmitSignalDeactivateDialog();
3755 ( new SMESHGUI_SewingDlg( this ) )->show();
3758 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3759 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3763 case SMESHOp::OpMergeNodes:
3765 if(isStudyLocked()) break;
3766 if ( warnOnGeomModif() )
3767 break; // action forbiden as geometry modified
3769 EmitSignalDeactivateDialog();
3770 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3773 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3774 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3778 case SMESHOp::OpMergeElements:
3780 if (isStudyLocked()) break;
3781 if ( warnOnGeomModif() )
3782 break; // action forbiden as geometry modified
3784 EmitSignalDeactivateDialog();
3785 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3787 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3788 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3793 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3794 if ( warnOnGeomModif() )
3795 break; // action forbiden as geometry modified
3796 startOperation( SMESHOp::OpMoveNode );
3799 case SMESHOp::OpDuplicateNodes:
3801 if(isStudyLocked()) break;
3802 if ( warnOnGeomModif() )
3803 break; // action forbiden as geometry modified
3805 EmitSignalDeactivateDialog();
3806 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3809 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3810 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3815 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3816 if ( warnOnGeomModif() )
3817 break; // action forbiden as geometry modified
3818 startOperation( SMESHOp::OpElem0DOnElemNodes );
3821 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3823 static QList<int> aTypes;
3824 if ( aTypes.isEmpty() )
3826 aTypes.append( SMESH::NODE );
3827 aTypes.append( SMESH::EDGE );
3828 aTypes.append( SMESH::FACE );
3829 aTypes.append( SMESH::VOLUME );
3831 if (!myFilterLibraryDlg)
3832 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3833 else if (myFilterLibraryDlg->isHidden())
3834 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3835 myFilterLibraryDlg->raise();
3839 case SMESHOp::OpFreeNode:
3840 case SMESHOp::OpEqualNode:
3841 case SMESHOp::OpNodeConnectivityNb:
3842 case SMESHOp::OpFreeEdge:
3843 case SMESHOp::OpFreeBorder:
3844 case SMESHOp::OpLength:
3845 case SMESHOp::OpConnection:
3846 case SMESHOp::OpEqualEdge:
3847 case SMESHOp::OpFreeFace:
3848 case SMESHOp::OpBareBorderFace:
3849 case SMESHOp::OpOverConstrainedFace:
3850 case SMESHOp::OpLength2D:
3851 case SMESHOp::OpDeflection2D:
3852 case SMESHOp::OpConnection2D:
3853 case SMESHOp::OpArea:
3854 case SMESHOp::OpTaper:
3855 case SMESHOp::OpAspectRatio:
3856 case SMESHOp::OpMinimumAngle:
3857 case SMESHOp::OpWarpingAngle:
3858 case SMESHOp::OpSkew:
3859 case SMESHOp::OpMaxElementLength2D:
3860 case SMESHOp::OpEqualFace:
3861 case SMESHOp::OpAspectRatio3D:
3862 case SMESHOp::OpVolume:
3863 case SMESHOp::OpMaxElementLength3D:
3864 case SMESHOp::OpBareBorderVolume:
3865 case SMESHOp::OpOverConstrainedVolume:
3866 case SMESHOp::OpEqualVolume:
3869 LightApp_SelectionMgr* mgr = selectionMgr();
3870 SALOME_ListIO selected; mgr->selectedObjects( selected );
3872 if( !selected.IsEmpty() ) {
3873 SUIT_OverrideCursor wc;
3874 ::Control( theCommandID );
3877 SUIT_MessageBox::warning(desktop(),
3878 tr( "SMESH_WRN_WARNING" ),
3879 tr( "SMESH_BAD_SELECTION" ) );
3883 SUIT_MessageBox::warning(desktop(),
3884 tr( "SMESH_WRN_WARNING" ),
3885 tr( "NOT_A_VTK_VIEWER" ) );
3888 case SMESHOp::OpOverallMeshQuality:
3889 OverallMeshQuality();
3891 case SMESHOp::OpNumberingNodes:
3893 SUIT_OverrideCursor wc;
3894 LightApp_SelectionMgr* mgr = selectionMgr();
3895 SALOME_ListIO selected; mgr->selectedObjects( selected );
3897 SALOME_ListIteratorOfListIO it(selected);
3898 for( ; it.More(); it.Next()) {
3899 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3900 if(anIObject->hasEntry()) {
3901 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3902 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3908 case SMESHOp::OpNumberingElements:
3910 SUIT_OverrideCursor wc;
3911 LightApp_SelectionMgr* mgr = selectionMgr();
3912 SALOME_ListIO selected; mgr->selectedObjects( selected );
3914 SALOME_ListIteratorOfListIO it(selected);
3915 for( ; it.More(); it.Next()) {
3916 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3917 if(anIObject->hasEntry())
3918 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3919 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3924 case SMESHOp::OpPropertiesLength:
3925 case SMESHOp::OpPropertiesArea:
3926 case SMESHOp::OpPropertiesVolume:
3927 case SMESHOp::OpMinimumDistance:
3928 case SMESHOp::OpBoundingBox:
3929 case SMESHOp::OpAngle:
3931 int page = SMESHGUI_MeasureDlg::MinDistance;
3932 if ( theCommandID == SMESHOp::OpBoundingBox )
3933 page = SMESHGUI_MeasureDlg::BoundingBox;
3934 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3935 page = SMESHGUI_MeasureDlg::Length;
3936 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3937 page = SMESHGUI_MeasureDlg::Area;
3938 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3939 page = SMESHGUI_MeasureDlg::Volume;
3940 else if ( theCommandID == SMESHOp::OpAngle )
3941 page = SMESHGUI_MeasureDlg::Angle;
3943 EmitSignalDeactivateDialog();
3944 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3948 case SMESHOp::OpSortChild:
3951 case SMESHOp::OpBreakLink:
3952 ::breakShaperLink();
3957 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3958 //updateObjBrowser();
3962 //=============================================================================
3966 //=============================================================================
3967 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3972 //=============================================================================
3976 //=============================================================================
3977 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3982 //=============================================================================
3986 //=============================================================================
3987 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3992 //=============================================================================
3993 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3994 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3996 //=============================================================================
3997 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3998 SUIT_ViewWindow* wnd )
4000 if(theIO->hasEntry()){
4001 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
4002 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
4006 //=======================================================================
4007 // function : createSMESHAction
4009 //=======================================================================
4010 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
4011 const int key, const bool toggle, const QString& shortcutAction )
4014 QWidget* parent = application()->desktop();
4015 SUIT_ResourceMgr* resMgr = resourceMgr();
4017 if ( !icon_id.isEmpty() )
4018 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4020 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
4021 if ( !pix.isNull() )
4022 icon = QIcon( pix );
4024 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4025 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4026 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4028 createAction( id, tooltip, icon, menu, status_bar, key, parent,
4029 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4032 //=======================================================================
4033 // function : createPopupItem
4035 //=======================================================================
4036 void SMESHGUI::createPopupItem( const int id,
4037 const QString& clients,
4038 const QString& types,
4039 const QString& theRule,
4042 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4043 popupMgr()->insert( action( id ), pId, 0 );
4045 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4046 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4047 QString rule = "(%1) and (%2) and (%3)";
4048 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4049 if( clients.isEmpty() )
4050 rule = rule.arg( QString( "true" ) );
4052 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4053 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4056 bool cont = myRules.contains( id );
4058 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4060 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4061 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4064 //=======================================================================
4065 // function : initialize
4067 //=======================================================================
4068 void SMESHGUI::initialize( CAM_Application* app )
4070 SalomeApp_Module::initialize( app );
4072 // SUIT_ResourceMgr* mgr = app->resourceMgr();
4074 /* Automatic Update flag */
4075 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4077 // ----- create actions --------------
4079 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4080 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4081 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4082 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
4084 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4086 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
4087 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
4088 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4089 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4090 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
4092 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4094 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
4095 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
4097 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
4098 createSMESHAction( SMESHOp::OpExportMED, "MED" );
4099 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
4100 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
4102 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4104 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
4105 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
4106 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4107 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4108 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4109 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4111 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4113 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
4114 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
4115 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4116 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
4117 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4118 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
4119 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
4120 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
4121 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
4122 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
4123 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
4124 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
4125 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
4126 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
4127 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
4128 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
4129 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
4130 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
4131 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
4132 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
4133 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
4134 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4135 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
4136 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
4137 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
4138 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
4139 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
4140 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
4141 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4142 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
4143 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
4144 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
4145 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4146 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
4148 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
4149 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
4150 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
4151 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
4152 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
4153 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
4154 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
4155 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
4156 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
4157 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
4158 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
4159 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
4160 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
4161 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
4162 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
4163 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
4164 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
4165 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
4166 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
4167 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
4168 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
4169 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
4170 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
4171 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4172 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4173 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4174 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4175 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4176 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4178 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4179 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4180 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4181 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4182 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4183 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4184 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4185 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4186 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4187 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4188 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4189 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4190 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4191 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4192 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4193 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4194 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4195 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4196 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4197 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4198 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4199 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4200 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4201 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4202 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4203 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4205 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4206 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4207 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4208 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4210 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4211 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4213 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4214 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4215 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4216 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4217 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4218 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4219 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4220 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4221 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4222 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4223 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4224 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4225 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4226 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4227 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4228 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4229 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4230 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4231 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4232 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4233 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4234 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4235 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4236 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4237 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4239 createSMESHAction( SMESHOp::OpReset, "RESET" );
4240 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4241 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4242 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4243 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4244 #ifndef DISABLE_PLOT2DVIEWER
4245 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4247 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4248 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4249 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4250 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4251 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4252 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4253 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4254 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4255 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4256 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4257 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4258 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4259 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4261 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4262 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4264 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4265 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4266 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4267 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4268 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4269 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4270 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4271 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4272 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4275 createSMESHAction( SMESHOp::OpUniformRefinement, "REF_ALL", "ICON_REF_ALL" );
4276 createSMESHAction( SMESHOp::OpHONewCase, "HOMARD_CREATE_CASE", "ICON_HOMARD_CREATE_CASE" );
4277 createSMESHAction( SMESHOp::OpHOCaseFollow, "HOMARD_FOLLOW_ITERATION", "ICON_HOMARD_FOLLOW_ITERATION" );
4278 createSMESHAction( SMESHOp::OpHONewIter, "HOMARD_NEW_ITERATION", "ICON_HOMARD_NEW_ITERATION" );
4279 createSMESHAction( SMESHOp::OpHOIterCompute, "HOMARD_COMPUTE", "ICON_HOMARD_COMPUTE" );
4280 createSMESHAction( SMESHOp::OpHOIterComputePublish, "HOMARD_COMPUTE_PUBLISH", "ICON_HOMARD_COMPUTE_PUBLISH" );
4281 createSMESHAction( SMESHOp::OpHOEdit, "EDIT", "ICON_DLG_EDIT_MESH" );
4282 createSMESHAction( SMESHOp::OpHODelete, "DELETE", "ICON_DELETE" );
4283 createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
4285 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4286 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4287 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4288 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4289 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4290 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4292 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4293 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4294 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4296 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4298 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4300 QList<int> aCtrlActions;
4301 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4302 << SMESHOp::OpNodeConnectivityNb // node controls
4303 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4304 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4305 << SMESHOp::OpDeflection2D
4306 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4307 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4308 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4309 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4310 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4311 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4312 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4313 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4314 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4315 aCtrlGroup->setExclusive( true );
4316 for( int i = 0; i < aCtrlActions.size(); i++ )
4317 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4319 // ----- create menu --------------
4320 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4321 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4322 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4323 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4324 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4325 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4326 adaptId = createMenu( tr( "MEN_ADAPT" ), -1, 80, 10 ),
4327 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4328 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4330 createMenu( separator(), fileId );
4332 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4333 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4334 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4335 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4336 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4337 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4338 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4339 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4340 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4341 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4342 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4343 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4344 refHomardId = createMenu( tr( "MEN_REF_HOMARD" ), adaptId, -1, 10 ),
4345 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4347 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4348 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4349 createMenu( SMESHOp::OpImportMED, importId, -1 );
4350 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4352 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4354 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4355 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4356 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4357 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4358 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4359 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4361 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4363 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4364 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4365 createMenu( separator(), fileId, 10 );
4367 createMenu( SMESHOp::OpDelete, editId, -1 );
4369 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4371 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4372 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4373 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4374 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4375 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4376 createMenu( separator(), meshId, -1 );
4377 createMenu( SMESHOp::OpCompute, meshId, -1 );
4378 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4379 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4380 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4381 createMenu( separator(), meshId, -1 );
4382 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4383 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4384 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4385 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4386 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4387 createMenu( separator(), meshId, -1 );
4388 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4389 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4390 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4391 createMenu( separator(), meshId, -1 );
4392 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4393 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4394 createMenu( separator(), meshId, -1 );
4395 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4396 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4397 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4398 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4399 createMenu( separator(), meshId, -1 );
4401 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4402 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4403 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4404 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4405 createMenu( SMESHOp::OpLength, edgeId, -1 );
4406 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4407 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4408 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4409 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4410 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4411 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4412 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4413 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4414 createMenu( SMESHOp::OpArea, faceId, -1 );
4415 createMenu( SMESHOp::OpTaper, faceId, -1 );
4416 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4417 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4418 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4419 createMenu( SMESHOp::OpSkew, faceId, -1 );
4420 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4421 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4422 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4423 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4424 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4425 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4426 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4427 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4428 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4429 createMenu( separator(), ctrlId, -1 );
4430 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4431 createMenu( separator(), ctrlId, -1 );
4432 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4434 createMenu( SMESHOp::OpNode, addId, -1 );
4435 createMenu( SMESHOp::OpElem0D, addId, -1 );
4436 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4437 createMenu( SMESHOp::OpBall, addId, -1 );
4438 createMenu( SMESHOp::OpEdge, addId, -1 );
4439 createMenu( SMESHOp::OpTriangle, addId, -1 );
4440 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4441 createMenu( SMESHOp::OpPolygon, addId, -1 );
4442 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4443 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4444 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4445 createMenu( SMESHOp::OpPyramid, addId, -1 );
4446 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4447 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4448 createMenu( separator(), addId, -1 );
4449 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4450 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4451 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4452 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4453 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4454 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4455 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4456 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4457 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4458 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4459 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4460 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4462 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4463 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4464 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4465 createMenu( separator(), removeId, -1 );
4466 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4467 createMenu( separator(), removeId, -1 );
4468 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4470 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4471 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4473 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4474 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4475 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4476 createMenu( SMESHOp::OpRotation, transfId, -1 );
4477 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4478 createMenu( SMESHOp::OpScale, transfId, -1 );
4479 createMenu( SMESHOp::OpOffset, transfId, -1 );
4480 createMenu( SMESHOp::OpSewing, transfId, -1 );
4481 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4483 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4484 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4485 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4486 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4487 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4488 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4489 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4490 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4491 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4492 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4493 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4494 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4495 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4496 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4497 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4498 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4500 createMenu( SMESHOp::OpUniformRefinement, adaptId, -1 );
4501 createMenu( SMESHOp::OpHONewCase, refHomardId, -1 );
4502 createMenu( SMESHOp::OpHOCaseFollow, refHomardId, -1 );
4503 createMenu( separator(), refHomardId, -1 );
4504 createMenu( SMESHOp::OpHONewIter, refHomardId, -1 );
4505 createMenu( SMESHOp::OpHOIterCompute, refHomardId, -1 );
4506 createMenu( SMESHOp::OpHOIterComputePublish, refHomardId, -1 );
4507 createMenu( separator(), refHomardId, -1 );
4508 createMenu( SMESHOp::OpHOEdit, refHomardId, -1 );
4509 createMenu( SMESHOp::OpHODelete, refHomardId, -1 );
4510 createMenu( SMESHOp::OpMGAdapt, adaptId, -1 );
4512 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4513 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4514 createMenu( SMESHOp::OpAngle, measureId, -1 );
4515 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4516 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4517 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4518 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4520 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4521 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4522 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4523 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4525 // ----- create toolbars --------------
4526 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4527 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4528 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4529 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4530 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4531 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4532 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4533 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4534 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4535 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4536 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4537 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4538 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4539 // adaptTb = createTool( tr( "TB_ADAPTATION" ),QString( "SMESHAdaptationToolbar" ) ),
4540 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4541 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4543 createTool( SMESHOp::OpCreateMesh, meshTb );
4544 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4545 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4546 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4547 createTool( SMESHOp::OpCopyMesh, meshTb );
4548 createTool( separator(), meshTb );
4549 createTool( SMESHOp::OpCompute, meshTb );
4550 createTool( SMESHOp::OpPreCompute, meshTb );
4551 createTool( SMESHOp::OpEvaluate, meshTb );
4552 createTool( SMESHOp::OpMeshOrder, meshTb );
4554 createTool( SMESHOp::OpCreateGroup, groupTb );
4555 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4556 createTool( SMESHOp::OpConstructGroup, groupTb );
4557 createTool( SMESHOp::OpEditGroup, groupTb );
4559 createTool( SMESHOp::OpMeshInformation, info );
4560 //createTool( SMESHOp::OpStdInfo, meshTb );
4561 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4562 createTool( SMESHOp::OpFindElementByPoint, info );
4564 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4565 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4566 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4568 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4569 createTool( SMESHOp::OpLength, ctrl1dTb );
4570 createTool( SMESHOp::OpConnection, ctrl1dTb );
4571 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4573 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4574 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4575 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4576 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4577 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4578 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4579 createTool( SMESHOp::OpArea, ctrl2dTb );
4580 createTool( SMESHOp::OpTaper, ctrl2dTb );
4581 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4582 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4583 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4584 createTool( SMESHOp::OpSkew, ctrl2dTb );
4585 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4586 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4587 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4589 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4590 createTool( SMESHOp::OpVolume, ctrl3dTb );
4591 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4592 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4593 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4594 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4596 createTool( SMESHOp::OpNode, addElemTb );
4597 createTool( SMESHOp::OpElem0D, addElemTb );
4598 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4599 createTool( SMESHOp::OpBall, addElemTb );
4600 createTool( SMESHOp::OpEdge, addElemTb );
4601 createTool( SMESHOp::OpTriangle, addElemTb );
4602 createTool( SMESHOp::OpQuadrangle, addElemTb );
4603 createTool( SMESHOp::OpPolygon, addElemTb );
4604 createTool( SMESHOp::OpTetrahedron, addElemTb );
4605 createTool( SMESHOp::OpHexahedron, addElemTb );
4606 createTool( SMESHOp::OpPentahedron, addElemTb );
4607 createTool( SMESHOp::OpPyramid, addElemTb );
4608 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4609 createTool( SMESHOp::OpPolyhedron, addElemTb );
4611 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4612 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4613 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4614 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4615 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4616 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4617 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4618 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4619 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4620 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4621 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4622 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4624 createTool( SMESHOp::OpRemoveNodes, remTb );
4625 createTool( SMESHOp::OpRemoveElements, remTb );
4626 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4627 createTool( SMESHOp::OpClearMesh, remTb );
4629 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4630 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4632 createTool( SMESHOp::OpMergeNodes, transformTb );
4633 createTool( SMESHOp::OpMergeElements, transformTb );
4634 createTool( SMESHOp::OpTranslation, transformTb );
4635 createTool( SMESHOp::OpRotation, transformTb );
4636 createTool( SMESHOp::OpSymmetry, transformTb );
4637 createTool( SMESHOp::OpScale, transformTb );
4638 createTool( SMESHOp::OpOffset, transformTb );
4639 createTool( SMESHOp::OpSewing, transformTb );
4640 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4642 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4643 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4644 createTool( SMESHOp::OpExtrusion, modifyTb );
4645 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4646 createTool( SMESHOp::OpRevolution, modifyTb );
4647 createTool( SMESHOp::OpOrientation, modifyTb );
4648 createTool( SMESHOp::OpReorientFaces, modifyTb );
4649 createTool( SMESHOp::OpMoveNode, modifyTb );
4650 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4651 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4652 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4653 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4654 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4655 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4656 createTool( SMESHOp::OpSmoothing, modifyTb );
4657 createTool( SMESHOp::OpPatternMapping, modifyTb );
4659 // createTool( SMESHOp::OpUniformRefinement, adaptTb );
4660 // createTool( SMESHOp::OpHOMARDRefinement, adaptTb );
4661 // createTool( SMESHOp::OpMGAdapt, adaptTb );
4663 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4665 createTool( SMESHOp::OpUpdate, dispModeTb );
4667 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4668 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4672 OB = "'ObjectBrowser'",
4673 View = "'" + SVTK_Viewer::Type() + "'",
4675 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4676 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4677 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4678 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4679 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4680 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4681 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4682 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4683 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4684 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4685 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4686 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4688 mesh_part = mesh + " " + subMesh + " " + group,
4689 mesh_group = mesh + " " + group,
4690 mesh_submesh = mesh + " " + subMesh,
4691 hyp_alg = hypo + " " + algo;
4693 // popup for object browser
4695 isInvisible("not( isVisible )"),
4696 isEmpty("numberOfNodes = 0"),
4697 isNotEmpty("numberOfNodes <> 0"),
4699 // has nodes, edges, etc in VISIBLE! actor
4700 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4701 hasElems("(count( elemTypes ) > 0)"),
4702 hasDifferentElems("(count( elemTypes ) > 1)"),
4703 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4704 hasBalls("({'BallElem'} in elemTypes)"),
4705 hasElems0d("({'Elem0d'} in elemTypes)"),
4706 hasEdges("({'Edge'} in elemTypes)"),
4707 hasFaces("({'Face'} in elemTypes)"),
4708 hasVolumes("({'Volume'} in elemTypes)"),
4709 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4711 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4712 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4713 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4714 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4715 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4716 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4718 popupMgr()->insert( separator(), -1, 0 );
4719 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4720 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4721 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4722 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4723 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4724 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4725 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4726 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4727 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4728 popupMgr()->insert( separator(), -1, 0 );
4729 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4730 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4731 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4732 popupMgr()->insert( separator(), -1, 0 );
4733 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4734 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4735 popupMgr()->insert( separator(), -1, 0 );
4736 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4737 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4738 popupMgr()->insert( separator(), -1, 0 );
4739 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4740 //popupMgr()->insert( separator(), -1, 0 );
4741 // createPopupItem( SMESHOp::OpUniformRefinement, OB, mesh );
4742 // createPopupItem( SMESHOp::OpHOMARDRefinement, OB, mesh );
4743 // createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
4745 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4746 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4747 QString only_one_2D = only_one_non_empty + " && dim>1";
4749 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4750 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4751 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4752 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4754 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4756 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4757 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4758 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4759 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4760 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4762 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4763 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4764 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4765 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4767 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4769 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4770 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4771 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4772 popupMgr()->insert( separator(), -1, 0 );
4775 createPopupItem( SMESHOp::OpEditGroup, View, group );
4776 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4777 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4779 popupMgr()->insert( separator(), -1, 0 );
4780 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4781 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4782 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4783 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4784 popupMgr()->insert( separator(), -1, 0 );
4786 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4787 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4788 popupMgr()->insert( separator(), -1, 0 );
4790 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4791 QString aType = QString( "%1type in {%2}" ).arg( lc );
4792 aType = aType.arg( mesh_part );
4793 QString aMeshInVTK = aClient + "&&" + aType;
4795 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4796 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4797 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4799 //-------------------------------------------------
4801 //-------------------------------------------------
4802 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4804 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4805 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4806 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4808 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4809 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4810 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4812 popupMgr()->insert( separator(), -1, -1 );
4814 //-------------------------------------------------
4816 //-------------------------------------------------
4817 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4819 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4820 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4821 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4823 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4824 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4825 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4827 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4828 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4829 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4831 popupMgr()->insert( separator(), anId, -1 );
4833 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4834 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4835 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4837 //-------------------------------------------------
4839 //-------------------------------------------------
4840 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4842 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4844 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4845 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4846 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4848 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4849 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4850 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4852 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4853 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4854 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4856 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4857 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4858 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4860 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4861 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4862 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4864 popupMgr()->insert( separator(), anId, -1 );
4866 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4867 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4869 popupMgr()->insert( separator(), anId, -1 );
4871 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4872 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4875 //-------------------------------------------------
4876 // Representation of the 2D Quadratic elements
4877 //-------------------------------------------------
4878 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4879 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4880 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4881 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4883 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4884 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4885 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4887 //-------------------------------------------------
4888 // Orientation of faces
4889 //-------------------------------------------------
4890 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4891 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4892 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4894 //-------------------------------------------------
4896 //-------------------------------------------------
4897 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4898 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4900 //-------------------------------------------------
4902 //-------------------------------------------------
4903 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4904 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4906 //-------------------------------------------------
4908 //-------------------------------------------------
4910 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4911 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4912 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4913 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4915 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4917 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4918 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4920 popupMgr()->insert( separator(), anId, -1 );
4922 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4924 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4925 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4926 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4928 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4929 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4930 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4932 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4933 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4934 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4936 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4938 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4939 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4940 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4942 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4943 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4944 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4946 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4947 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4948 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4949 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4950 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4951 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4953 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4955 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4956 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4957 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4959 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4960 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4961 QtxPopupMgr::VisibleRule );
4962 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4964 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4965 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4966 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4968 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4969 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4970 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4972 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4973 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4974 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4976 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4977 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4978 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4980 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4981 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4982 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4984 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4985 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4986 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4988 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4989 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4990 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4992 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4993 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4994 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4996 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4997 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4998 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
5000 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
5001 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5002 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
5004 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
5005 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5006 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
5008 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
5009 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5010 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
5012 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
5013 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
5014 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
5016 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
5018 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
5019 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5020 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
5022 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
5023 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5024 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
5026 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
5027 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5028 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5030 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5031 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5032 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5034 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5035 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5036 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5038 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
5039 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5040 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5042 popupMgr()->insert( separator(), anId, -1 );
5044 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5045 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5046 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5047 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5048 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5050 popupMgr()->insert( separator(), anId, -1 );
5052 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5054 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5055 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5057 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5058 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5059 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5061 #ifndef DISABLE_PLOT2DVIEWER
5062 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5063 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5066 //-------------------------------------------------
5068 //-------------------------------------------------
5069 popupMgr()->insert( separator(), -1, -1 );
5070 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5071 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5072 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5073 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5075 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5076 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5078 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5079 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5081 popupMgr()->insert( separator(), -1, -1 );
5083 //-------------------------------------------------
5085 //-------------------------------------------------
5086 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5087 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5089 popupMgr()->insert( separator(), -1, -1 );
5091 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5092 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5093 popupMgr()->insert( separator(), -1, -1 );
5095 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5096 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5098 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5099 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5101 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5102 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5105 //================================================================================
5107 * \brief Return true if SMESH or GEOM objects are selected.
5108 * Is called form LightApp_Module::activateModule() which clear selection if
5109 * not isSelectionCompatible()
5111 //================================================================================
5113 bool SMESHGUI::isSelectionCompatible()
5115 bool isCompatible = true;
5116 SALOME_ListIO selected;
5117 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5118 Sel->selectedObjects( selected );
5120 SALOME_ListIteratorOfListIO It( selected );
5121 for ( ; isCompatible && It.More(); It.Next())
5123 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
5124 ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5125 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
5127 return isCompatible;
5131 bool SMESHGUI::reusableOperation( const int id )
5133 // compute, evaluate and precompute are not reusable operations
5134 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
5137 bool SMESHGUI::activateModule( SUIT_Study* study )
5139 bool res = SalomeApp_Module::activateModule( study );
5141 setMenuShown( true );
5142 setToolShown( true );
5144 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5145 PyGILState_STATE gstate = PyGILState_Ensure();
5146 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5147 if ( !pluginsmanager ) {
5151 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5156 PyGILState_Release(gstate);
5157 // end of SMESH plugins loading
5159 // Reset actions accelerator keys
5160 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5162 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5163 GetSMESHGen()->UpdateStudy();
5165 // get all view currently opened in the study and connect their signals to
5166 // the corresponding slots of the class.
5167 SUIT_Desktop* aDesk = study->application()->desktop();
5169 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5170 SUIT_ViewWindow* wnd;
5171 foreach ( wnd, wndList )
5175 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5176 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5182 Py_XDECREF(pluginsmanager);
5186 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5188 setMenuShown( false );
5189 setToolShown( false );
5191 EmitSignalCloseAllDialogs();
5193 // Unset actions accelerator keys
5194 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5196 return SalomeApp_Module::deactivateModule( study );
5199 void SMESHGUI::studyClosed( SUIT_Study* s )
5203 SMESH::RemoveVisuData();
5204 SalomeApp_Module::studyClosed( s );
5207 void SMESHGUI::OnGUIEvent()
5209 const QObject* obj = sender();
5210 if ( !obj || !obj->inherits( "QAction" ) )
5212 int id = actionId((QAction*)obj);
5217 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5219 if ( CORBA::is_nil( myComponentSMESH ) )
5221 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5222 return aGUI.myComponentSMESH;
5224 return myComponentSMESH;
5227 QString SMESHGUI::engineIOR() const
5229 CORBA::ORB_var anORB = getApp()->orb();
5230 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5231 return QString( anIOR.in() );
5234 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5236 SalomeApp_Module::contextMenuPopup( client, menu, title );
5238 selectionMgr()->selectedObjects( lst );
5239 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5240 Handle(SALOME_InteractiveObject) io = lst.First();
5241 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5242 _PTR(Study) study = appStudy->studyDS();
5243 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5245 QString aName = SMESH::fromUtf8( obj->GetName());
5246 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5247 aName.remove(( aName.length() - 1 ), 1 );
5253 LightApp_Selection* SMESHGUI::createSelection() const
5255 return new SMESHGUI_Selection();
5258 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5260 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5261 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5262 #ifndef DISABLE_PYCONSOLE
5263 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5267 void SMESHGUI::viewManagers( QStringList& list ) const
5269 list.append( SVTK_Viewer::Type() );
5272 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5274 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5275 SMESH::UpdateSelectionProp( this );
5277 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5278 for(int i = 0; i < aViews.count() ; i++){
5279 SUIT_ViewWindow *sf = aViews[i];
5282 EmitSignalActivatedViewManager();
5286 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5288 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5289 myClippingPlaneInfoMap.erase( theViewManager );
5292 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5294 theActor->AddObserver( SMESH::DeleteActorEvent,
5295 myEventCallbackCommand.GetPointer(),
5299 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5300 unsigned long theEvent,
5301 void* theClientData,
5304 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5305 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5306 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5307 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5308 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5309 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5310 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5311 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5312 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5313 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5314 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5315 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5316 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5317 if( anActor == *anIter3 ) {
5318 anActorList.erase( anIter3 );
5329 void SMESHGUI::createPreferences()
5331 // General tab ------------------------------------------------------------------------
5332 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5334 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5335 setPreferenceProperty( autoUpdate, "columns", 2 );
5336 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5337 setPreferenceProperty( lim, "min", 0 );
5338 setPreferenceProperty( lim, "max", 100000000 );
5339 setPreferenceProperty( lim, "step", 1000 );
5340 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5341 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5343 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5344 setPreferenceProperty( dispgroup, "columns", 2 );
5346 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5348 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5350 modes.append( tr("MEN_WIRE") );
5351 modes.append( tr("MEN_SHADE") );
5352 modes.append( tr("MEN_NODES") );
5353 modes.append( tr("MEN_SHRINK") );
5354 QList<QVariant> indices;
5355 indices.append( 0 );
5356 indices.append( 1 );
5357 indices.append( 2 );
5358 indices.append( 3 );
5359 setPreferenceProperty( dispmode, "strings", modes );
5360 setPreferenceProperty( dispmode, "indexes", indices );
5362 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5363 setPreferenceProperty( arcgroup, "columns", 2 );
5364 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5365 QStringList quadraticModes;
5366 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5367 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5369 indices.append( 0 );
5370 indices.append( 1 );
5371 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5372 setPreferenceProperty( quadraticmode, "indexes", indices );
5374 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5375 "SMESH", "max_angle" );
5376 setPreferenceProperty( maxAngle, "min", 1 );
5377 setPreferenceProperty( maxAngle, "max", 90 );
5379 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5380 setPreferenceProperty( qaGroup, "columns", 2 );
5381 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5382 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5383 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5384 setPreferenceProperty( prec, "min", 0 );
5385 setPreferenceProperty( prec, "max", 100 );
5386 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5387 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5388 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5389 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5390 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5393 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5394 setPreferenceProperty( cinc, "min", 0 );
5395 setPreferenceProperty( cinc, "max", 5 );
5398 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5399 setPreferenceProperty( exportgroup, "columns", 2 );
5400 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5401 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5402 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5403 setPreferenceProperty( zTol, "precision", 10 );
5404 setPreferenceProperty( zTol, "min", 0.0000000001 );
5405 setPreferenceProperty( zTol, "max", 1000000.0 );
5406 setPreferenceProperty( zTol, "step", 1. );
5407 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5409 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5410 setPreferenceProperty( computeGroup, "columns", 2 );
5411 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5413 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5414 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5415 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5417 indices.append( 0 );
5418 indices.append( 1 );
5419 indices.append( 2 );
5420 setPreferenceProperty( notifyMode, "strings", modes );
5421 setPreferenceProperty( notifyMode, "indexes", indices );
5423 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5424 setPreferenceProperty( infoGroup, "columns", 2 );
5425 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5427 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5428 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5430 indices.append( 0 );
5431 indices.append( 1 );
5432 setPreferenceProperty( elemInfo, "strings", modes );
5433 setPreferenceProperty( elemInfo, "indexes", indices );
5434 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5435 setPreferenceProperty( nodesLim, "min", 0 );
5436 setPreferenceProperty( nodesLim, "max", 10000000 );
5437 setPreferenceProperty( nodesLim, "step", 10000 );
5438 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5439 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5440 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5441 setPreferenceProperty( ctrlLim, "min", 0 );
5442 setPreferenceProperty( ctrlLim, "max", 10000000 );
5443 setPreferenceProperty( ctrlLim, "step", 1000 );
5444 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5445 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5446 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5447 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5448 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5450 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5451 setPreferenceProperty( segGroup, "columns", 2 );
5452 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5453 "SMESH", "segmentation" );
5454 setPreferenceProperty( segLen, "min", 1 );
5455 setPreferenceProperty( segLen, "max", 10000000 );
5456 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5457 "SMESH", "nb_segments_per_edge" );
5458 setPreferenceProperty( nbSeg, "min", 1 );
5459 setPreferenceProperty( nbSeg, "max", 10000000 );
5460 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5462 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5463 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5464 "SMESH", "forget_mesh_on_hyp_modif" );
5467 // Quantities with individual precision settings
5468 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5469 setPreferenceProperty( precGroup, "columns", 2 );
5471 const int nbQuantities = 6;
5472 int precs[nbQuantities], ii = 0;
5473 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5474 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5475 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5476 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5477 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5478 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5479 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5480 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5481 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5482 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5483 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5484 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5486 // Set property for precision value for spinboxes
5487 for ( ii = 0; ii < nbQuantities; ii++ ){
5488 setPreferenceProperty( precs[ii], "min", -14 );
5489 setPreferenceProperty( precs[ii], "max", 14 );
5490 setPreferenceProperty( precs[ii], "precision", 2 );
5493 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5494 setPreferenceProperty( previewGroup, "columns", 2 );
5495 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5496 setPreferenceProperty( chunkSize, "min", 1 );
5497 setPreferenceProperty( chunkSize, "max", 1000 );
5498 setPreferenceProperty( chunkSize, "step", 50 );
5500 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5501 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5503 // Mesh tab ------------------------------------------------------------------------
5504 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5505 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5506 setPreferenceProperty( nodeGroup, "columns", 3 );
5508 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5510 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5512 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5513 QList<QVariant> aMarkerTypeIndicesList;
5514 QList<QVariant> aMarkerTypeIconsList;
5515 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5516 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5517 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5518 aMarkerTypeIndicesList << i;
5519 aMarkerTypeIconsList << pixmap;
5521 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5522 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5524 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5526 QList<QVariant> aMarkerScaleIndicesList;
5527 QStringList aMarkerScaleValuesList;
5528 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5529 aMarkerScaleIndicesList << i;
5530 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5531 aMarkerScaleValuesList << QString::number( i );
5533 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5534 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5536 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5537 //setPreferenceProperty( elemGroup, "columns", 2 );
5539 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5540 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5541 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5542 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5543 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5544 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5545 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5546 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5547 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5550 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5551 setPreferenceProperty( grpGroup, "columns", 2 );
5553 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5554 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5556 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5557 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5558 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5559 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5560 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5561 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5562 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5563 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5564 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5565 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5566 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5567 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5568 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5569 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5571 setPreferenceProperty( size0d, "min", 1 );
5572 setPreferenceProperty( size0d, "max", 10 );
5574 // setPreferenceProperty( ballSize, "min", 1 );
5575 // setPreferenceProperty( ballSize, "max", 10 );
5577 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5578 setPreferenceProperty( ballDiameter, "max", 1e9 );
5579 setPreferenceProperty( ballDiameter, "step", 0.1 );
5581 setPreferenceProperty( ballScale, "min", 1e-2 );
5582 setPreferenceProperty( ballScale, "max", 1e7 );
5583 setPreferenceProperty( ballScale, "step", 0.5 );
5585 setPreferenceProperty( elemW, "min", 1 );
5586 setPreferenceProperty( elemW, "max", 5 );
5588 setPreferenceProperty( outW, "min", 1 );
5589 setPreferenceProperty( outW, "max", 5 );
5591 setPreferenceProperty( shrink, "min", 0 );
5592 setPreferenceProperty( shrink, "max", 100 );
5594 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5595 setPreferenceProperty( numGroup, "columns", 2 );
5597 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5598 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5600 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5601 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5603 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5604 setPreferenceProperty( orientGroup, "columns", 1 );
5606 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5607 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5609 setPreferenceProperty( orientScale, "min", 0.05 );
5610 setPreferenceProperty( orientScale, "max", 0.5 );
5611 setPreferenceProperty( orientScale, "step", 0.05 );
5613 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5615 // Selection tab ------------------------------------------------------------------------
5616 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5618 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5619 setPreferenceProperty( selGroup, "columns", 2 );
5621 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5622 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5624 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5625 setPreferenceProperty( preGroup, "columns", 2 );
5627 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5629 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5630 setPreferenceProperty( precSelGroup, "columns", 2 );
5632 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5633 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5634 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5636 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5637 setPreferenceProperty( sinc, "min", 0 );
5638 setPreferenceProperty( sinc, "max", 5 );
5640 // Scalar Bar tab ------------------------------------------------------------------------
5641 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5642 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5643 setPreferenceProperty( fontGr, "columns", 2 );
5645 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5646 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5648 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5649 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5651 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5652 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5654 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5655 setPreferenceProperty( numcol, "min", 2 );
5656 setPreferenceProperty( numcol, "max", 256 );
5658 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5659 setPreferenceProperty( numlab, "min", 2 );
5660 setPreferenceProperty( numlab, "max", 65 );
5662 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5663 setPreferenceProperty( orientGr, "columns", 2 );
5664 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5665 QStringList orients;
5666 orients.append( tr( "SMESH_VERTICAL" ) );
5667 orients.append( tr( "SMESH_HORIZONTAL" ) );
5668 indices.clear(); indices.append( 0 ); indices.append( 1 );
5669 setPreferenceProperty( orient, "strings", orients );
5670 setPreferenceProperty( orient, "indexes", indices );
5672 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5673 setPreferenceProperty( posVSizeGr, "columns", 2 );
5674 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5675 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5676 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5677 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5678 setPreferenceProperty( xv, "step", 0.1 );
5679 setPreferenceProperty( xv, "min", 0.0 );
5680 setPreferenceProperty( xv, "max", 1.0 );
5681 setPreferenceProperty( yv, "step", 0.1 );
5682 setPreferenceProperty( yv, "min", 0.0 );
5683 setPreferenceProperty( yv, "max", 1.0 );
5684 setPreferenceProperty( wv, "step", 0.1 );
5685 setPreferenceProperty( wv, "min", 0.0 );
5686 setPreferenceProperty( wv, "max", 1.0 );
5687 setPreferenceProperty( hv, "min", 0.0 );
5688 setPreferenceProperty( hv, "max", 1.0 );
5689 setPreferenceProperty( hv, "step", 0.1 );
5691 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5692 setPreferenceProperty( posHSizeGr, "columns", 2 );
5693 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5694 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5695 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5696 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5697 setPreferenceProperty( xv, "min", 0.0 );
5698 setPreferenceProperty( xv, "max", 1.0 );
5699 setPreferenceProperty( xv, "step", 0.1 );
5700 setPreferenceProperty( xh, "min", 0.0 );
5701 setPreferenceProperty( xh, "max", 1.0 );
5702 setPreferenceProperty( xh, "step", 0.1 );
5703 setPreferenceProperty( yh, "min", 0.0 );
5704 setPreferenceProperty( yh, "max", 1.0 );
5705 setPreferenceProperty( yh, "step", 0.1 );
5706 setPreferenceProperty( wh, "min", 0.0 );
5707 setPreferenceProperty( wh, "max", 1.0 );
5708 setPreferenceProperty( wh, "step", 0.1 );
5709 setPreferenceProperty( hh, "min", 0.0 );
5710 setPreferenceProperty( hh, "max", 1.0 );
5711 setPreferenceProperty( hh, "step", 0.1 );
5713 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5714 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5715 setPreferenceProperty( distributionGr, "columns", 3 );
5717 types.append( tr( "SMESH_MONOCOLOR" ) );
5718 types.append( tr( "SMESH_MULTICOLOR" ) );
5719 indices.clear(); indices.append( 0 ); indices.append( 1 );
5720 setPreferenceProperty( coloringType, "strings", types );
5721 setPreferenceProperty( coloringType, "indexes", indices );
5722 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5724 // Adaptation tab ------------------------------------------------------------------------
5725 int adaptTab = addPreference( tr( "ADAPT_PREF_TAB_GENERAL" ) );
5727 // Refinement with HOMARD
5728 bloc = addPreference( tr( "ADAPT_PREF_PUBLICATION" ), adaptTab );
5729 setPreferenceProperty( bloc, "columns", 1 );
5730 pref = addPreference( tr( "ADAPT_PREF_PUBLICATION_MAILLAGE_IN" ), bloc, LightApp_Preferences::Bool, "HOMARD", "publish_mesh_in" );
5731 pref = addPreference( tr( "ADAPT_PREF_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "publish_mesh_out" );
5733 bloc = addPreference( tr( "ADAPT_PREF_YACS_MAX" ), adaptTab );
5734 setPreferenceProperty( bloc, "columns", 1 );
5735 pref = addPreference( tr( "ADAPT_PREF_YACS_MAX_ITER" ), bloc, LightApp_Preferences::IntSpin, "HOMARD", "yacs_max_iter" );
5736 setPreferenceProperty( pref, "min", 0 );
5737 setPreferenceProperty( pref, "max", 100000000 );
5738 setPreferenceProperty( pref, "step", 1 );
5739 pref = addPreference( tr( "ADAPT_PREF_YACS_MAX_NODE" ), bloc, LightApp_Preferences::IntSpin, "HOMARD", "yacs_max_node" );
5740 setPreferenceProperty( pref, "min", 0 );
5741 setPreferenceProperty( pref, "max", 100000000 );
5742 setPreferenceProperty( pref, "step", 1000 );
5743 pref = addPreference( tr( "ADAPT_PREF_YACS_MAX_ELEM" ), bloc, LightApp_Preferences::IntSpin, "HOMARD", "yacs_max_elem" );
5744 setPreferenceProperty( pref, "min", 0 );
5745 setPreferenceProperty( pref, "max", 100000000 );
5746 setPreferenceProperty( pref, "step", 1000 );
5747 bloc = addPreference( tr( "ADAPT_PREF_YACS_CONVERGENCE" ), adaptTab );
5748 setPreferenceProperty( bloc, "columns", 1 );
5749 pref = addPreference( tr( "ADAPT_PREF_YACS_TYPE_TEST" ), bloc, LightApp_Preferences::Selector, "HOMARD", "yacs_type_test" );
5750 QStringList aListOfTypeTest;
5751 aListOfTypeTest << "None";
5752 aListOfTypeTest << "VTest > VRef";
5753 aListOfTypeTest << "VTest < VRef";
5754 setPreferenceProperty( pref, "strings", aListOfTypeTest );
5758 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5760 if ( sect=="SMESH" ) {
5761 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5762 float aTol = 1.00000009999999;
5763 std::string aWarning;
5764 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5766 if ( name == "selection_object_color" ||
5767 name == "selection_element_color" ||
5768 name == "highlight_color" ||
5769 name == "selection_precision_node" ||
5770 name == "selection_precision_element" ||
5771 name == "selection_precision_object" ||
5772 name == "selection_increment")
5774 SMESH::UpdateSelectionProp( this );
5776 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5778 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5779 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5780 if ( sbX1+sbW > aTol ) {
5781 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5784 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5785 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5788 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5790 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5791 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5792 if ( sbY1 + sbH > aTol ) {
5793 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5794 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5795 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5798 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5800 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5801 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5802 if ( sbX1 + sbW > aTol ) {
5803 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5806 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5807 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5810 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5812 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5813 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5814 if ( sbY1 + sbH > aTol ) {
5815 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5818 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5819 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5822 else if ( name == "segmentation" )
5824 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5825 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5827 else if ( name == "nb_segments_per_edge" )
5829 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5830 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5832 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5834 QString val = aResourceMgr->stringValue( "SMESH", name );
5835 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5837 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5839 SMESH::UpdateFontProp( this );
5841 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5843 SMESH::UpdateFontProp( this );
5846 if ( aWarning.size() != 0 ) {
5847 aWarning += "The default values are applied instead.";
5848 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5849 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5850 QObject::tr(aWarning.c_str()));
5855 //================================================================================
5857 * \brief Update something in accordance with update flags
5858 * \param theFlags - update flags
5860 * Update viewer or/and object browser etc. in accordance with update flags ( see
5861 * LightApp_UpdateFlags enumeration ).
5863 //================================================================================
5864 void SMESHGUI::update( const int flags )
5866 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5867 SMESH::UpdateView();
5869 SalomeApp_Module::update( flags );
5872 //================================================================================
5874 * \brief Set default selection mode
5876 * SLOT called when operation committed. Sets default selection mode
5878 //================================================================================
5879 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5881 SVTK_ViewWindow* vtkWnd =
5882 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5884 vtkWnd->SetSelectionMode( ActorSelection );
5887 //================================================================================
5889 * \brief Set default selection mode
5891 * SLOT called when operation aborted. Sets default selection mode
5893 //================================================================================
5894 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5896 SVTK_ViewWindow* vtkWnd =
5897 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5899 vtkWnd->SetSelectionMode( ActorSelection );
5902 //================================================================================
5904 * \brief Creates operation with given identifier
5905 * \param id - identifier of operation to be started
5906 * \return Pointer on created operation or NULL if operation is not created
5908 * Virtual method redefined from the base class creates operation with given id.
5909 * It is called called automatically from startOperation method of base class.
5911 //================================================================================
5912 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5914 LightApp_Operation* op = 0;
5915 // to do : create operation here
5918 case SMESHOp::OpUniformRefinement:
5919 case SMESHOp::OpHONewCase:
5920 case SMESHOp::OpHOCaseFollow:
5921 case SMESHOp::OpHONewIter:
5922 case SMESHOp::OpHOIterCompute:
5923 case SMESHOp::OpHOIterComputePublish:
5924 case SMESHOp::OpHOEdit:
5925 case SMESHOp::OpHODelete:
5926 case SMESHOp::OpMGAdapt:
5928 case SMESHOp::OpSplitBiQuadratic:
5929 op = new SMESHGUI_SplitBiQuadOp();
5931 case SMESHOp::OpConvertMeshToQuadratic:
5932 op = new SMESHGUI_ConvToQuadOp();
5934 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5935 op = new SMESHGUI_Make2DFrom3DOp();
5937 case SMESHOp::OpReorientFaces:
5938 op = new SMESHGUI_ReorientFacesOp();
5940 case SMESHOp::OpCreateMesh:
5941 op = new SMESHGUI_MeshOp( true, true );
5943 case SMESHOp::OpCreateSubMesh:
5944 op = new SMESHGUI_MeshOp( true, false );
5946 case SMESHOp::OpEditMeshOrSubMesh:
5947 case SMESHOp::OpEditMesh:
5948 case SMESHOp::OpEditSubMesh:
5949 op = new SMESHGUI_MeshOp( false );
5951 case SMESHOp::OpCompute:
5952 case SMESHOp::OpComputeSubMesh:
5953 op = new SMESHGUI_ComputeOp();
5955 case SMESHOp::OpPreCompute:
5956 op = new SMESHGUI_PrecomputeOp();
5958 case SMESHOp::OpEvaluate:
5959 op = new SMESHGUI_EvaluateOp();
5961 case SMESHOp::OpMeshOrder:
5962 op = new SMESHGUI_MeshOrderOp();
5964 case SMESHOp::OpCreateGeometryGroup:
5965 op = new SMESHGUI_GroupOnShapeOp();
5967 case SMESHOp::OpFindElementByPoint:
5968 op = new SMESHGUI_FindElemByPointOp();
5970 case SMESHOp::OpMoveNode: // Make mesh pass through point
5971 op = new SMESHGUI_MakeNodeAtPointOp();
5973 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5974 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5981 op = SalomeApp_Module::createOperation( id );
5985 //================================================================================
5987 * \brief Stops current operations and starts a given one
5988 * \param id - The id of the operation to start
5990 //================================================================================
5992 void SMESHGUI::switchToOperation(int id)
5994 activeStudy()->abortAllOperations();
5995 startOperation( id );
5998 LightApp_Displayer* SMESHGUI::displayer()
6001 myDisplayer = new SMESHGUI_Displayer( getApp() );
6005 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
6008 int aTolerance = 64;
6009 int anIterations = 0;
6015 if( anIterations % aPeriod == 0 )
6018 if( aTolerance < 1 )
6022 aHue = (int)( 360.0 * rand() / RAND_MAX );
6025 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
6026 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
6027 for( ; it != itEnd; ++it )
6029 SALOMEDS::Color anAutoColor = *it;
6030 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6033 aQColor.getHsv( &h, &s, &v );
6034 if( abs( h - aHue ) < aTolerance )
6046 aColor.setHsv( aHue, 255, 255 );
6048 SALOMEDS::Color aSColor;
6049 aSColor.R = aColor.redF();
6050 aSColor.G = aColor.greenF();
6051 aSColor.B = aColor.blueF();
6056 const char* gSeparator = "_"; // character used to separate parameter names
6057 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6058 const char* gPathSep = "|"; // character used to separate paths
6061 * \brief Store visual parameters
6063 * This method is called just before the study document is saved.
6064 * Store visual parameters in AttributeParameter attribute(s)
6066 void SMESHGUI::storeVisualParameters (int savePoint)
6069 Kernel_Utils::Localizer loc;
6071 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6072 if (!appStudy || !appStudy->studyDS())
6074 _PTR(Study) studyDS = appStudy->studyDS();
6076 // componentName is used for encoding of entries when storing them in IParameters
6077 std::string componentName = myComponentSMESH->ComponentDataType();
6078 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6079 //if (!aSComponent) return;
6082 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6083 componentName.c_str(),
6085 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6087 // store custom markers
6088 if( !myMarkerMap.empty() )
6090 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6091 for( ; anIter != myMarkerMap.end(); anIter++ )
6093 int anId = anIter->first;
6094 VTK::MarkerData aMarkerData = anIter->second;
6095 std::string aMarkerFileName = aMarkerData.first;
6096 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6097 if( aMarkerTexture.size() < 3 )
6098 continue; // should contain at least width, height and the first value
6100 QString aPropertyName( "texture" );
6101 aPropertyName += gSeparator;
6102 aPropertyName += QString::number( anId );
6104 QString aPropertyValue = aMarkerFileName.c_str();
6105 aPropertyValue += gPathSep;
6107 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6108 ushort aWidth = *aTextureIter++;
6109 ushort aHeight = *aTextureIter++;
6110 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6111 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6112 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6113 aPropertyValue += QString::number( *aTextureIter );
6115 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6119 // viewers counters are used for storing view_numbers in IParameters
6122 // main cycle to store parameters of displayed objects
6123 QList<SUIT_ViewManager*> lst;
6124 QList<SUIT_ViewManager*>::Iterator it;
6125 getApp()->viewManagers(lst);
6126 for (it = lst.begin(); it != lst.end(); it++)
6128 SUIT_ViewManager* vman = *it;
6129 QString vType = vman->getType();
6131 // saving VTK actors properties
6132 if (vType == SVTK_Viewer::Type())
6134 // store the clipping planes attached to the view manager
6135 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6136 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6137 if( anIter != myClippingPlaneInfoMap.end() )
6138 aClippingPlaneInfoList = anIter->second;
6140 if( !aClippingPlaneInfoList.empty() ) {
6141 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6142 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6144 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6145 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6147 QString aPropertyName( "ClippingPlane" );
6148 aPropertyName += gSeparator;
6149 aPropertyName += QString::number( vtkViewers );
6150 aPropertyName += gSeparator;
6151 aPropertyName += QString::number( anId );
6153 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6154 aPropertyValue += gDigitsSep;
6155 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6156 aPropertyValue += gDigitsSep;
6157 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6158 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6159 aPropertyValue += gDigitsSep;
6160 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6161 aPropertyValue += gDigitsSep;
6162 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6163 aPropertyValue += gDigitsSep;
6164 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6165 aPropertyValue += gDigitsSep;
6166 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6167 aPropertyValue += gDigitsSep;
6168 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6169 aPropertyValue += gDigitsSep;
6170 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6172 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6173 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6174 aPropertyValue += gDigitsSep;
6175 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6176 aPropertyValue += gDigitsSep;
6177 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6178 aPropertyValue += gDigitsSep;
6179 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6182 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6186 QVector<SUIT_ViewWindow*> views = vman->getViews();
6187 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6189 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6191 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6192 vtkActorCollection* allActors = aCopy.GetActors();
6193 allActors->InitTraversal();
6194 while (vtkActor* actor = allActors->GetNextActor())
6196 if (actor->GetVisibility()) // store only visible actors
6198 SMESH_Actor* aSmeshActor = 0;
6199 if (actor->IsA("SMESH_Actor"))
6200 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6201 if (aSmeshActor && aSmeshActor->hasIO())
6203 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6206 // entry is "encoded" = it does NOT contain component address,
6207 // since it is a subject to change on next component loading
6208 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6210 std::string param, vtkParam = vType.toLatin1().data();
6211 vtkParam += gSeparator;
6212 vtkParam += QString::number(vtkViewers).toLatin1().data();
6213 vtkParam += gSeparator;
6216 param = vtkParam + "Visibility";
6217 ip->setParameter(entry, param, "On");
6220 param = vtkParam + "Representation";
6221 ip->setParameter(entry, param, QString::number
6222 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6225 param = vtkParam + "IsShrunk";
6226 ip->setParameter(entry, param, QString::number
6227 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6229 // Displayed entities
6230 unsigned int aMode = aSmeshActor->GetEntityMode();
6231 bool isE = aMode & SMESH_Actor::eEdges;
6232 bool isF = aMode & SMESH_Actor::eFaces;
6233 bool isV = aMode & SMESH_Actor::eVolumes;
6234 bool is0d = aMode & SMESH_Actor::e0DElements;
6235 bool isB = aMode & SMESH_Actor::eBallElem;
6237 QString modeStr ("e");
6238 modeStr += gDigitsSep; modeStr += QString::number(isE);
6239 modeStr += gDigitsSep; modeStr += "f";
6240 modeStr += gDigitsSep; modeStr += QString::number(isF);
6241 modeStr += gDigitsSep; modeStr += "v";
6242 modeStr += gDigitsSep; modeStr += QString::number(isV);
6243 modeStr += gDigitsSep; modeStr += "0d";
6244 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6245 modeStr += gDigitsSep; modeStr += "b";
6246 modeStr += gDigitsSep; modeStr += QString::number(isB);
6248 param = vtkParam + "Entities";
6249 ip->setParameter(entry, param, modeStr.toLatin1().data());
6255 aSmeshActor->GetSufaceColor(r, g, b, delta);
6256 QStringList colorStr;
6257 colorStr << "surface";
6258 colorStr << QString::number(r);
6259 colorStr << QString::number(g);
6260 colorStr << QString::number(b);
6262 colorStr << "backsurface";
6263 colorStr << QString::number(delta);
6265 aSmeshActor->GetVolumeColor(r, g, b, delta);
6266 colorStr << "volume";
6267 colorStr << QString::number(r);
6268 colorStr << QString::number(g);
6269 colorStr << QString::number(b);
6270 colorStr << QString::number(delta);
6272 aSmeshActor->GetEdgeColor(r, g, b);
6274 colorStr << QString::number(r);
6275 colorStr << QString::number(g);
6276 colorStr << QString::number(b);
6278 aSmeshActor->GetNodeColor(r, g, b);
6280 colorStr << QString::number(r);
6281 colorStr << QString::number(g);
6282 colorStr << QString::number(b);
6284 aSmeshActor->GetOutlineColor(r, g, b);
6285 colorStr << "outline";
6286 colorStr << QString::number(r);
6287 colorStr << QString::number(g);
6288 colorStr << QString::number(b);
6290 aSmeshActor->Get0DColor(r, g, b);
6291 colorStr << "elem0d";
6292 colorStr << QString::number(r);
6293 colorStr << QString::number(g);
6294 colorStr << QString::number(b);
6296 aSmeshActor->GetBallColor(r, g, b);
6298 colorStr << QString::number(r);
6299 colorStr << QString::number(g);
6300 colorStr << QString::number(b);
6302 aSmeshActor->GetFacesOrientationColor(r, g, b);
6303 colorStr << "orientation";
6304 colorStr << QString::number(r);
6305 colorStr << QString::number(g);
6306 colorStr << QString::number(b);
6308 param = vtkParam + "Colors";
6309 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6312 QStringList sizeStr;
6314 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6315 sizeStr << "outline";
6316 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6317 sizeStr << "elem0d";
6318 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6320 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6321 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6322 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6323 sizeStr << "shrink";
6324 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6325 sizeStr << "orientation";
6326 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6327 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6329 param = vtkParam + "Sizes";
6330 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6335 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6336 if( aMarkerType == VTK::MT_USER ) {
6337 markerStr += "custom";
6338 markerStr += gDigitsSep;
6339 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6343 markerStr += gDigitsSep;
6344 markerStr += QString::number( (int)aMarkerType );
6345 markerStr += gDigitsSep;
6346 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6349 param = vtkParam + "PointMarker";
6350 ip->setParameter(entry, param, markerStr.toLatin1().data());
6353 param = vtkParam + "Opacity";
6354 ip->setParameter(entry, param,
6355 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6358 param = vtkParam + "ClippingPlane";
6360 if( !aClippingPlaneInfoList.empty() ) {
6361 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6362 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6364 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6365 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6366 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6367 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6368 if( aSmeshActor == *anIter2 ) {
6369 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6370 QString::number( anId ).toLatin1().constData() );
6377 ip->setParameter( entry, param, "Off" );
6378 } // if (io->hasEntry())
6379 } // SMESH_Actor && hasIO
6381 } // while.. actors traversal
6385 } // if (SVTK view model)
6386 } // for (viewManagers)
6389 // data structures for clipping planes processing
6393 bool isOpenGLClipping;
6394 vtkIdType RelativeOrientation;
6397 int AbsoluteOrientation;
6398 double X, Y, Z, Dx, Dy, Dz;
6400 typedef std::list<TPlaneData> TPlaneDataList;
6401 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6403 typedef std::list<vtkActor*> TActorList;
6406 TActorList ActorList;
6407 SUIT_ViewManager* ViewManager;
6409 typedef std::list<TPlaneInfo> TPlaneInfoList;
6410 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6413 * \brief Restore visual parameters
6415 * This method is called after the study document is opened.
6416 * Restore visual parameters from AttributeParameter attribute(s)
6418 void SMESHGUI::restoreVisualParameters (int savePoint)
6421 Kernel_Utils::Localizer loc;
6423 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6424 if (!appStudy || !appStudy->studyDS())
6426 _PTR(Study) studyDS = appStudy->studyDS();
6428 // componentName is used for encoding of entries when storing them in IParameters
6429 std::string componentName = myComponentSMESH->ComponentDataType();
6432 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6433 componentName.c_str(),
6435 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6437 // restore custom markers and map of clipping planes
6438 TPlaneDataMap aPlaneDataMap;
6440 std::vector<std::string> properties = ip->getProperties();
6441 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6443 std::string property = *propIt;
6444 QString aPropertyName( property.c_str() );
6445 QString aPropertyValue( ip->getProperty( property ).c_str() );
6447 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6448 if( aPropertyNameList.isEmpty() )
6451 QString aPropertyType = aPropertyNameList[0];
6452 if( aPropertyType == "texture" )
6454 if( aPropertyNameList.size() != 2 )
6458 int anId = aPropertyNameList[1].toInt( &ok );
6459 if( !ok || anId < 1 )
6462 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6463 if( aPropertyValueList.size() != 2 )
6466 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6467 QString aMarkerTextureString = aPropertyValueList[1];
6468 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6469 if( aMarkerTextureStringList.size() != 3 )
6473 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6478 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6482 VTK::MarkerTexture aMarkerTexture;
6483 aMarkerTexture.push_back( aWidth );
6484 aMarkerTexture.push_back( aHeight );
6486 QString aMarkerTextureData = aMarkerTextureStringList[2];
6487 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6489 QChar aChar = aMarkerTextureData.at( i );
6490 if( aChar.isDigit() )
6491 aMarkerTexture.push_back( aChar.digitValue() );
6494 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6496 else if( aPropertyType == "ClippingPlane" )
6498 if( aPropertyNameList.size() != 3 )
6502 int aViewId = aPropertyNameList[1].toInt( &ok );
6503 if( !ok || aViewId < 0 )
6507 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6508 if( !ok || aClippingPlaneId < 0 )
6511 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6512 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6515 TPlaneData aPlaneData;
6516 aPlaneData.AbsoluteOrientation = false;
6517 aPlaneData.RelativeOrientation = 0;
6518 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6519 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6520 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6522 aPlaneData.Id = aClippingPlaneId;
6525 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6530 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6534 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6537 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6542 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6547 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6552 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6557 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6562 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6567 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6571 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6573 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6578 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6583 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6588 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6593 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6594 aPlaneDataList.push_back( aPlaneData );
6598 TPlaneInfoMap aPlaneInfoMap;
6600 std::vector<std::string> entries = ip->getEntries();
6602 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6604 // entry is a normal entry - it should be "decoded" (setting base address of component)
6605 QString entry (ip->decodeEntry(*entIt).c_str());
6607 // Check that the entry corresponds to a real object in the Study
6608 // as the object may be deleted or modified after the visual state is saved.
6609 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6610 if (!so) continue; //Skip the not existent entry
6612 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6613 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6615 std::vector<std::string>::iterator namesIt = paramNames.begin();
6616 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6618 // actors are stored in a map after displaying of them for
6619 // quicker access in the future: map < viewID to actor >
6620 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6622 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6624 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6625 // '_' is used as separator and should not be used in viewer type or parameter names.
6626 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6627 if (lst.size() != 3)
6630 QString viewerTypStr = lst[0];
6631 QString viewIndexStr = lst[1];
6632 QString paramNameStr = lst[2];
6635 int viewIndex = viewIndexStr.toUInt(&ok);
6636 if (!ok) // bad conversion of view index to integer
6640 if (viewerTypStr == SVTK_Viewer::Type())
6642 SMESH_Actor* aSmeshActor = 0;
6643 if (vtkActors.IsBound(viewIndex))
6644 aSmeshActor = vtkActors.Find(viewIndex);
6646 QList<SUIT_ViewManager*> lst;
6647 getApp()->viewManagers(viewerTypStr, lst);
6649 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6650 SUIT_ViewManager* vman = NULL;
6651 if (viewIndex >= 0 && viewIndex < lst.count())
6652 vman = lst.at(viewIndex);
6654 if (paramNameStr == "Visibility")
6656 if (!aSmeshActor && displayer() && vman)
6658 SUIT_ViewModel* vmodel = vman->getViewModel();
6659 // SVTK view model can be casted to SALOME_View
6660 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6662 // store displayed actor in a temporary map for quicker
6663 // access later when restoring other parameters
6664 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6665 vtkRenderer* Renderer = vtkView->getRenderer();
6666 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6667 vtkActorCollection* theActors = aCopy.GetActors();
6668 theActors->InitTraversal();
6669 bool isFound = false;
6670 vtkActor *ac = theActors->GetNextActor();
6671 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6672 if (ac->IsA("SMESH_Actor")) {
6673 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6674 if (aGeomAc->hasIO()) {
6675 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6676 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6678 vtkActors.Bind(viewIndex, aGeomAc);
6684 } // if (paramNameStr == "Visibility")
6687 // the rest properties "work" with SMESH_Actor
6690 QString val ((*valuesIt).c_str());
6693 if (paramNameStr == "Representation") {
6694 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6697 else if (paramNameStr == "IsShrunk") {
6699 if (!aSmeshActor->IsShrunk())
6700 aSmeshActor->SetShrink();
6703 if (aSmeshActor->IsShrunk())
6704 aSmeshActor->UnShrink();
6707 // Displayed entities
6708 else if (paramNameStr == "Entities") {
6709 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6710 int aEntityMode = SMESH_Actor::eAllEntity;
6711 for ( int i = 0; i < mode.count(); i+=2 ) {
6712 if ( i < mode.count()-1 ) {
6713 QString type = mode[i];
6714 bool val = mode[i+1].toInt();
6715 if ( type == "e" && !val )
6716 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6717 else if ( type == "f" && !val )
6718 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6719 else if ( type == "v" && !val )
6720 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6721 else if ( type == "0d" && !val )
6722 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6723 else if ( type == "b" && !val )
6724 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6727 aSmeshActor->SetEntityMode( aEntityMode );
6730 else if (paramNameStr == "Colors") {
6731 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6738 QColor outlineColor;
6739 QColor orientationColor;
6745 // below lines are required to get default values for delta coefficients
6746 // of backface color for faces and color of reversed volumes
6747 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6748 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6749 for ( int i = 0; i < colors.count(); i++ ) {
6750 QString type = colors[i];
6751 if ( type == "surface" ) {
6752 // face color is set by 3 values r:g:b, where
6753 // - r,g,b - is rgb color components
6754 if ( i+1 >= colors.count() ) break; // format error
6755 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6756 if ( i+2 >= colors.count() ) break; // format error
6757 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6758 if ( i+3 >= colors.count() ) break; // format error
6759 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6760 faceColor.setRgbF( r, g, b );
6763 else if ( type == "backsurface" ) {
6764 // backface color can be defined in several ways
6765 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6766 // - in latest versions, it is set as delta coefficient
6767 bool rgbOk = false, deltaOk;
6768 if ( i+1 >= colors.count() ) break; // format error
6769 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6770 int delta = colors[i+1].toInt( &deltaOk );
6772 if ( i+1 < colors.count() ) // index is shifted to 1
6773 g = colors[i+1].toDouble( &rgbOk );
6774 if ( rgbOk ) i++; // shift index
6775 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6776 b = colors[i+1].toDouble( &rgbOk );
6778 // - as currently there's no way to set directly backsurface color as it was before,
6779 // we ignore old dump where r,g,b triple was set
6780 // - also we check that delta parameter is set properly
6781 if ( !rgbOk && deltaOk )
6784 else if ( type == "volume" ) {
6785 // volume color is set by 4 values r:g:b:delta, where
6786 // - r,g,b - is a normal volume rgb color components
6787 // - delta - is a reversed volume color delta coefficient
6788 if ( i+1 >= colors.count() ) break; // format error
6789 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6790 if ( i+2 >= colors.count() ) break; // format error
6791 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6792 if ( i+3 >= colors.count() ) break; // format error
6793 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6794 if ( i+4 >= colors.count() ) break; // format error
6795 int delta = colors[i+4].toInt( &bOk );
6796 if ( !bOk ) break; // format error
6797 volumeColor.setRgbF( r, g, b );
6801 else if ( type == "edge" ) {
6802 // edge color is set by 3 values r:g:b, where
6803 // - r,g,b - is rgb color components
6804 if ( i+1 >= colors.count() ) break; // format error
6805 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6806 if ( i+2 >= colors.count() ) break; // format error
6807 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6808 if ( i+3 >= colors.count() ) break; // format error
6809 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6810 edgeColor.setRgbF( r, g, b );
6813 else if ( type == "node" ) {
6814 // node color is set by 3 values r:g:b, where
6815 // - r,g,b - is rgb color components
6816 if ( i+1 >= colors.count() ) break; // format error
6817 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6818 if ( i+2 >= colors.count() ) break; // format error
6819 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6820 if ( i+3 >= colors.count() ) break; // format error
6821 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6822 nodeColor.setRgbF( r, g, b );
6825 else if ( type == "elem0d" ) {
6826 // 0d element color is set by 3 values r:g:b, where
6827 // - r,g,b - is rgb color components
6828 if ( i+1 >= colors.count() ) break; // format error
6829 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6830 if ( i+2 >= colors.count() ) break; // format error
6831 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6832 if ( i+3 >= colors.count() ) break; // format error
6833 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6834 elem0dColor.setRgbF( r, g, b );
6837 else if ( type == "ball" ) {
6838 // ball color is set by 3 values r:g:b, where
6839 // - r,g,b - is rgb color components
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 ballColor.setRgbF( r, g, b );
6849 else if ( type == "outline" ) {
6850 // outline color is set by 3 values r:g:b, where
6851 // - r,g,b - is rgb color components
6852 if ( i+1 >= colors.count() ) break; // format error
6853 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6854 if ( i+2 >= colors.count() ) break; // format error
6855 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6856 if ( i+3 >= colors.count() ) break; // format error
6857 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6858 outlineColor.setRgbF( r, g, b );
6861 else if ( type == "orientation" ) {
6862 // orientation color is set by 3 values r:g:b, where
6863 // - r,g,b - is rgb color components
6864 if ( i+1 >= colors.count() ) break; // format error
6865 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6866 if ( i+2 >= colors.count() ) break; // format error
6867 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6868 if ( i+3 >= colors.count() ) break; // format error
6869 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6870 orientationColor.setRgbF( r, g, b );
6875 if ( nodeColor.isValid() )
6876 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6878 if ( edgeColor.isValid() )
6879 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6881 if ( faceColor.isValid() )
6882 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6884 if ( volumeColor.isValid() )
6885 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6886 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6887 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6889 if ( elem0dColor.isValid() )
6890 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6892 if ( ballColor.isValid() )
6893 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6895 if ( outlineColor.isValid() )
6896 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6897 // orientation color
6898 if ( orientationColor.isValid() )
6899 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6902 else if (paramNameStr == "Sizes") {
6903 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6906 int outlineWidth = -1;
6907 int elem0dSize = -1;
6908 //int ballSize = -1;
6909 double ballDiameter = -1.0;
6910 double ballScale = -1.0;
6911 double shrinkSize = -1;
6912 double orientationSize = -1;
6913 bool orientation3d = false;
6914 for ( int i = 0; i < sizes.count(); i++ ) {
6915 QString type = sizes[i];
6916 if ( type == "line" ) {
6917 // line (wireframe) width is given as single integer value
6918 if ( i+1 >= sizes.count() ) break; // format error
6919 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6923 if ( type == "outline" ) {
6924 // outline width is given as single integer value
6925 if ( i+1 >= sizes.count() ) break; // format error
6926 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6930 else if ( type == "elem0d" ) {
6931 // 0d element size is given as single integer value
6932 if ( i+1 >= sizes.count() ) break; // format error
6933 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6937 else if ( type == "ball" ) {
6938 // balls are specified by two values: size:scale, where
6939 // - size - is a integer value specifying size
6940 // - scale - is a double value specifying scale factor
6941 if ( i+1 >= sizes.count() ) break; // format error
6942 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6943 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6944 if ( i+2 >= sizes.count() ) break; // format error
6945 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6951 else if ( type == "shrink" ) {
6952 // shrink factor is given as single floating point value
6953 if ( i+1 >= sizes.count() ) break; // format error
6954 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6958 else if ( type == "orientation" ) {
6959 // orientation vectors are specified by two values size:3d, where
6960 // - size - is a floating point value specifying scale factor
6961 // - 3d - is a boolean
6962 if ( i+1 >= sizes.count() ) break; // format error
6963 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6964 if ( i+2 >= sizes.count() ) break; // format error
6965 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6966 orientationSize = v1;
6967 orientation3d = (bool)v2;
6971 // line (wireframe) width
6972 if ( lineWidth > 0 )
6973 aSmeshActor->SetLineWidth( lineWidth );
6975 if ( outlineWidth > 0 )
6976 aSmeshActor->SetOutlineWidth( outlineWidth );
6977 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6978 aSmeshActor->SetOutlineWidth( lineWidth );
6980 if ( elem0dSize > 0 )
6981 aSmeshActor->Set0DSize( elem0dSize );
6983 /*if ( ballSize > 0 )
6984 aSmeshActor->SetBallSize( ballSize );*/
6986 if ( ballDiameter > 0 )
6987 aSmeshActor->SetBallSize( ballDiameter );
6989 if ( ballScale > 0.0 )
6990 aSmeshActor->SetBallScale( ballScale );
6992 if ( shrinkSize > 0 )
6993 aSmeshActor->SetShrinkFactor( shrinkSize );
6994 // orientation vectors
6995 if ( orientationSize > 0 ) {
6996 aSmeshActor->SetFacesOrientationScale( orientationSize );
6997 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
7001 else if (paramNameStr == "PointMarker") {
7002 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
7003 if( data.count() >= 2 ) {
7005 int aParam1 = data[1].toInt( &ok );
7007 if( data[0] == "std" && data.count() == 3 ) {
7008 int aParam2 = data[2].toInt( &ok );
7009 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
7011 else if( data[0] == "custom" ) {
7012 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
7013 if( markerIt != myMarkerMap.end() ) {
7014 VTK::MarkerData aMarkerData = markerIt->second;
7015 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
7022 else if (paramNameStr == "Opacity") {
7023 aSmeshActor->SetOpacity(val.toFloat());
7026 else if (paramNameStr.startsWith("ClippingPlane")) {
7027 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
7028 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
7029 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
7030 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
7031 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7032 // new format - val looks like "Off" or "0" (plane id)
7033 // (note: in new format "Off" value is used only for consistency,
7034 // so it is processed together with values in old format)
7035 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7036 if( anIsOldFormat ) {
7037 if (paramNameStr == "ClippingPlane1" || val == "Off")
7038 aSmeshActor->RemoveAllClippingPlanes();
7040 QList<SUIT_ViewManager*> lst;
7041 getApp()->viewManagers(viewerTypStr, lst);
7042 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7043 if (viewIndex >= 0 && viewIndex < lst.count()) {
7044 SUIT_ViewManager* vman = lst.at(viewIndex);
7045 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7047 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7049 SMESH::TActorList anActorList;
7050 anActorList.push_back( aSmeshActor );
7051 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7052 aPlane->myViewWindow = vtkView;
7053 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7054 aPlane->PlaneMode = aMode;
7055 bool isOpenGLClipping = ( bool )vals[1].toInt();
7056 aPlane->IsOpenGLClipping = isOpenGLClipping;
7057 if ( aMode == SMESH::Absolute ) {
7058 aPlane->myAbsoluteOrientation = vals[2].toInt();
7059 aPlane->X = vals[3].toFloat();
7060 aPlane->Y = vals[4].toFloat();
7061 aPlane->Z = vals[5].toFloat();
7062 aPlane->Dx = vals[6].toFloat();
7063 aPlane->Dy = vals[7].toFloat();
7064 aPlane->Dz = vals[8].toFloat();
7066 else if ( aMode == SMESH::Relative ) {
7067 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7068 aPlane->myDistance = vals[3].toFloat();
7069 aPlane->myAngle[0] = vals[4].toFloat();
7070 aPlane->myAngle[1] = vals[5].toFloat();
7074 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7075 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7076 aClippingPlaneInfo.Plane = aPlane;
7077 aClippingPlaneInfo.ActorList = anActorList;
7078 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7086 int aPlaneId = val.toInt( &ok );
7087 if( ok && aPlaneId >= 0 ) {
7088 bool anIsDefinedPlane = false;
7089 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7090 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7091 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7092 TPlaneInfo& aPlaneInfo = *anIter;
7093 if( aPlaneInfo.PlaneId == aPlaneId ) {
7094 aPlaneInfo.ActorList.push_back( aSmeshActor );
7095 anIsDefinedPlane = true;
7099 if( !anIsDefinedPlane ) {
7100 TPlaneInfo aPlaneInfo;
7101 aPlaneInfo.PlaneId = aPlaneId;
7102 aPlaneInfo.ActorList.push_back( aSmeshActor );
7103 aPlaneInfo.ViewManager = vman;
7105 // to make the list sorted by plane id
7106 anIter = aPlaneInfoList.begin();
7107 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7108 const TPlaneInfo& aPlaneInfoRef = *anIter;
7109 if( aPlaneInfoRef.PlaneId > aPlaneId )
7112 aPlaneInfoList.insert( anIter, aPlaneInfo );
7117 } // if (aSmeshActor)
7118 } // other parameters than Visibility
7120 } // for names/parameters iterator
7121 } // for entries iterator
7123 // take into account planes with empty list of actors referred to them
7124 QList<SUIT_ViewManager*> aVMList;
7125 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7127 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7128 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7129 int aViewId = aPlaneDataIter->first;
7130 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7131 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7133 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7135 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7136 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7137 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7138 const TPlaneData& aPlaneData = *anIter2;
7139 int aPlaneId = aPlaneData.Id;
7141 bool anIsFound = false;
7142 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7143 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7144 const TPlaneInfo& aPlaneInfo = *anIter3;
7145 if( aPlaneInfo.PlaneId == aPlaneId ) {
7152 TPlaneInfo aPlaneInfo; // ActorList field is empty
7153 aPlaneInfo.PlaneId = aPlaneId;
7154 aPlaneInfo.ViewManager = aViewManager;
7156 // to make the list sorted by plane id
7157 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7158 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7159 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7160 if( aPlaneInfoRef.PlaneId > aPlaneId )
7163 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7169 // add clipping planes to actors according to the restored parameters
7170 // and update the clipping plane map
7171 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7172 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7173 int aViewId = anIter1->first;
7174 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7176 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7177 if( anIter2 == aPlaneDataMap.end() )
7179 const TPlaneDataList& aPlaneDataList = anIter2->second;
7181 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7182 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7183 const TPlaneInfo& aPlaneInfo = *anIter3;
7184 int aPlaneId = aPlaneInfo.PlaneId;
7185 const TActorList& anActorList = aPlaneInfo.ActorList;
7186 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7190 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7194 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7196 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7197 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7198 const TPlaneData& aPlaneData = *anIter4;
7199 if( aPlaneData.Id == aPlaneId ) {
7200 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7201 aPlane->myViewWindow = aViewWindow;
7202 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7203 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7204 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7205 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7206 aPlane->X = aPlaneData.X;
7207 aPlane->Y = aPlaneData.Y;
7208 aPlane->Z = aPlaneData.Z;
7209 aPlane->Dx = aPlaneData.Dx;
7210 aPlane->Dy = aPlaneData.Dy;
7211 aPlane->Dz = aPlaneData.Dz;
7213 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7214 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7215 aPlane->myDistance = aPlaneData.Distance;
7216 aPlane->myAngle[0] = aPlaneData.Angle[0];
7217 aPlane->myAngle[1] = aPlaneData.Angle[1];
7220 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7221 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7222 aClippingPlaneInfo.Plane = aPlane;
7223 aClippingPlaneInfo.ActorList = anActorList;
7224 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7235 // update all VTK views
7236 QList<SUIT_ViewManager*> lst;
7237 getApp()->viewManagers(lst);
7238 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7239 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7240 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7241 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7242 // set OpenGL clipping planes
7243 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7244 vtkActorCollection* anAllActors = aCopy.GetActors();
7245 anAllActors->InitTraversal();
7246 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7247 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7248 anActor->SetOpenGLClippingPlane();
7250 vtkView->getRenderer()->ResetCameraClippingRange();
7257 \brief Adds preferences for dfont of VTK viewer
7259 \param pIf group identifier
7260 \param param parameter
7261 \return identifier of preferences
7263 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7265 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7267 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7270 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7271 fam.append( tr( "SMESH_FONT_COURIER" ) );
7272 fam.append( tr( "SMESH_FONT_TIMES" ) );
7274 setPreferenceProperty( tfont, "fonts", fam );
7276 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7277 if ( needSize ) f = f | QtxFontEdit::Size;
7278 setPreferenceProperty( tfont, "features", f );
7284 \brief Actions after hypothesis edition
7285 Updates object browser after hypothesis edition
7287 void SMESHGUI::onHypothesisEdit( int result )
7290 SMESHGUI::Modified();
7291 updateObjBrowser( true );
7295 \brief Actions after choosing menu of control modes
7296 Updates control mode actions according to current selection
7298 void SMESHGUI::onUpdateControlActions()
7300 SALOME_ListIO selected;
7301 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7302 aSel->selectedObjects( selected );
7304 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7305 if ( selected.Extent() ) {
7306 if ( selected.First()->hasEntry() ) {
7307 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7308 aControl = anActor->GetControlMode();
7309 SALOME_ListIteratorOfListIO it(selected);
7310 for ( it.Next(); it.More(); it.Next() ) {
7311 Handle(SALOME_InteractiveObject) anIO = it.Value();
7312 if ( anIO->hasEntry() ) {
7313 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7314 if ( aControl != anActor->GetControlMode() ) {
7315 aControl = SMESH_Actor::eNone;
7325 int anAction = ActionToControl( aControl, true );
7327 action( anAction )->setChecked( true );
7329 QMenu* send = (QMenu*)sender();
7330 QList<QAction*> actions = send->actions();
7331 for ( int i = 0; i < actions.size(); i++ )
7332 actions[i]->setChecked( false );
7338 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7339 \param pview view being closed
7341 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7342 #ifndef DISABLE_PLOT2DVIEWER
7343 //Crear all Plot2d Viewers if need.
7344 SMESH::ClearPlot2Viewers(pview);
7346 EmitSignalCloseView();
7349 void SMESHGUI::message( const QString& msg )
7352 QStringList data = msg.split("/");
7353 if ( data.count() > 0 ) {
7354 if ( data.first() == "mesh_loading" ) {
7356 QString entry = data.count() > 1 ? data[1] : QString();
7357 if ( entry.isEmpty() )
7360 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7362 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7365 name = SMESH::fromUtf8(obj->GetName());
7366 if ( name.isEmpty() )
7369 if ( data.last() == "stop" )
7370 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7372 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7373 QApplication::processEvents();
7379 \brief Connects or disconnects signals about activating and cloning view on the module slots
7380 \param pview view which is connected/disconnected
7382 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7386 SUIT_ViewManager* viewMgr = pview->getViewManager();
7388 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7389 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7391 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7392 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7397 \brief Return \c true if object can be renamed
7399 bool SMESHGUI::renameAllowed( const QString& entry) const {
7400 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7404 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7408 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7413 if(appStudy->isComponent(entry) || obj->isReference())
7416 // check type to prevent renaming of inappropriate objects
7417 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7418 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7419 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7420 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7421 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7422 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7429 Rename object by entry.
7430 \param entry entry of the object
7431 \param name new name of the object
7432 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7434 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7436 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7440 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7445 _PTR(Study) aStudy = appStudy->studyDS();
7450 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7452 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7457 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7458 _PTR(GenericAttribute) anAttr;
7459 _PTR(AttributeName) aName;
7461 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7463 // check type to prevent renaming of inappropriate objects
7464 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7465 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7466 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7467 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7468 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7469 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7470 if ( !name.isEmpty() ) {
7471 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7473 // update name of group object and its actor
7474 Handle(SALOME_InteractiveObject) IObject =
7475 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7477 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7478 if( !aGroupObject->_is_nil() ) {
7479 aGroupObject->SetName( qUtf8Printable(name) );
7480 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7481 anActor->setName( qUtf8Printable(name) );
7491 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7493 static QList<QColor> colors;
7495 if ( colors.isEmpty() ) {
7497 for (int s = 0; s < 2 ; s++)
7499 for (int v = 100; v >= 40; v = v - 20)
7501 for (int h = 0; h < 359 ; h = h + 60)
7503 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7508 static int currentColor = randomize( colors.size() );
7510 SALOMEDS::Color color;
7511 color.R = (double)colors[currentColor].red() / 255.0;
7512 color.G = (double)colors[currentColor].green() / 255.0;
7513 color.B = (double)colors[currentColor].blue() / 255.0;
7515 currentColor = (currentColor+1) % colors.count();