1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FieldSelectorWdg.h"
48 #include "SMESHGUI_FileInfoDlg.h"
49 #include "SMESHGUI_FileValidator.h"
50 #include "SMESHGUI_FilterDlg.h"
51 #include "SMESHGUI_FilterLibraryDlg.h"
52 #include "SMESHGUI_FindElemByPointDlg.h"
53 #include "SMESHGUI_GroupDlg.h"
54 #include "SMESHGUI_GroupOnShapeDlg.h"
55 #include "SMESHGUI_GroupOpDlg.h"
56 #include "SMESHGUI_Hypotheses.h"
57 #include "SMESHGUI_Make2DFrom3DOp.h"
58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
59 #include "SMESHGUI_Measurements.h"
60 #include "SMESHGUI_MergeDlg.h"
61 #include "SMESHGUI_MeshInfo.h"
62 #include "SMESHGUI_MeshOp.h"
63 #include "SMESHGUI_MeshOrderOp.h"
64 #include "SMESHGUI_MeshPatternDlg.h"
65 #include "SMESHGUI_MultiEditDlg.h"
66 #include "SMESHGUI_NodesDlg.h"
67 #include "SMESHGUI_Operations.h"
68 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
69 #include "SMESHGUI_PropertiesDlg.h"
70 #include "SMESHGUI_RemoveElementsDlg.h"
71 #include "SMESHGUI_RemoveNodesDlg.h"
72 #include "SMESHGUI_RenumberingDlg.h"
73 #include "SMESHGUI_ReorientFacesDlg.h"
74 #include "SMESHGUI_RevolutionDlg.h"
75 #include "SMESHGUI_RotationDlg.h"
76 #include "SMESHGUI_ScaleDlg.h"
77 #include "SMESHGUI_OffsetDlg.h"
78 #include "SMESHGUI_Selection.h"
79 #include "SMESHGUI_SewingDlg.h"
80 #include "SMESHGUI_SingleEditDlg.h"
81 #include "SMESHGUI_SmoothingDlg.h"
82 #include "SMESHGUI_SymmetryDlg.h"
83 #include "SMESHGUI_TranslationDlg.h"
84 #include "SMESHGUI_TransparencyDlg.h"
85 #include "SMESHGUI_DisplayEntitiesDlg.h"
86 #include "SMESHGUI_SplitBiQuad.h"
88 #include "SMESHGUI_FilterUtils.h"
89 #include "SMESHGUI_GEOMGenUtils.h"
90 #include "SMESHGUI_GroupUtils.h"
91 #include "SMESHGUI_HypothesesUtils.h"
92 #include "SMESHGUI_MeshUtils.h"
93 #include "SMESHGUI_PatternUtils.h"
94 #include "SMESHGUI_Utils.h"
95 #include "SMESHGUI_VTKUtils.h"
97 #include "SMESH_version.h"
99 #include "SMESH_ControlsDef.hxx"
100 #include "SMESH_Actor.h"
101 #include "SMESH_ActorUtils.h"
102 #include "SMESH_Client.hxx"
103 #include "SMESH_ScalarBarActor.h"
104 #include "SMESH_TypeFilter.hxx"
106 // SALOME GUI includes
107 #include <SalomeApp_Application.h>
108 #include <SalomeApp_CheckFileDlg.h>
109 #include <SalomeApp_DataObject.h>
110 #include <SalomeApp_Study.h>
111 #include <SalomeApp_Tools.h>
113 #include <LightApp_DataOwner.h>
114 #include <LightApp_NameDlg.h>
115 #include <LightApp_Preferences.h>
116 #include <LightApp_SelectionMgr.h>
117 #include <LightApp_UpdateFlags.h>
119 #include <SVTK_ViewManager.h>
120 #include <SVTK_ViewModel.h>
121 #include <SVTK_ViewWindow.h>
123 #include <VTKViewer_Algorithm.h>
125 #include <SUIT_Desktop.h>
126 #include <SUIT_FileDlg.h>
127 #include <SUIT_MessageBox.h>
128 #include <SUIT_OverrideCursor.h>
129 #include <SUIT_ResourceMgr.h>
130 #include <SUIT_Session.h>
132 #include <QtxPopupMgr.h>
133 #include <QtxFontEdit.h>
135 #include <SALOME_ListIO.hxx>
137 #ifndef DISABLE_PLOT2DVIEWER
138 #include <SPlot2d_ViewModel.h>
139 #include <SPlot2d_Histogram.h>
143 #include <SALOMEconfig.h>
144 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
145 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
146 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
147 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
150 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
151 #include <QApplication>
153 #include <QTextStream>
158 #include <QDialogButtonBox>
161 #include <boost/shared_ptr.hpp>
164 #include <vtkCallbackCommand.h>
165 #include <vtkCamera.h>
166 #include <vtkLookupTable.h>
167 #include <vtkPlane.h>
168 #include <vtkRenderer.h>
170 // SALOME KERNEL includes
171 #include <SALOMEDSClient_ClientFactory.hxx>
172 #include <SALOMEDSClient_IParameters.hxx>
173 #include <SALOMEDSClient_SComponent.hxx>
174 #include <SALOMEDSClient_StudyBuilder.hxx>
175 #include <SALOMEDS_Study.hxx>
176 #include <SALOMEDS_SObject.hxx>
177 #include "utilities.h"
180 #include <Standard_ErrorHandler.hxx>
181 #include <NCollection_DataMap.hxx>
182 #include <NCollection_DoubleMap.hxx>
184 #include <Basics_Utils.hxx>
186 // Below macro, when uncommented, switches on simplified (more performant) algorithm
187 // of auto-color picking up
188 #define SIMPLE_AUTOCOLOR
193 //=============================================================
194 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
197 void ExportMeshToFile(int theCommandID);
199 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap);
201 void SetDisplayEntity(int theCommandID);
203 int ActionToControl( int theID, bool theReversed = false );
205 void Control( int theCommandID );
208 //================================================================================
210 * \brief Reads meshes from file
212 //================================================================================
214 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
218 std::string myExtension;
220 if ( theCommandID == SMESHOp::OpImportMED ||
221 theCommandID == SMESHOp::OpPopupImportMED ) {
222 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
223 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
225 else if ( theCommandID == SMESHOp::OpImportUNV ||
226 theCommandID == SMESHOp::OpPopupImportUNV ) {
227 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
229 else if ( theCommandID == SMESHOp::OpImportDAT ||
230 theCommandID == SMESHOp::OpPopupImportDAT ) {
231 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
233 else if ( theCommandID == SMESHOp::OpImportSTL ||
234 theCommandID == SMESHOp::OpPopupImportSTL ) {
235 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
237 else if ( theCommandID == SMESHOp::OpImportCGNS ||
238 theCommandID == SMESHOp::OpPopupImportCGNS ) {
239 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
241 else if ( theCommandID == SMESHOp::OpImportSAUV ||
242 theCommandID == SMESHOp::OpPopupImportSAUV ) {
243 filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
244 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
246 else if ( theCommandID == SMESHOp::OpImportGMF ||
247 theCommandID == SMESHOp::OpPopupImportGMF ) {
248 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
249 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
252 QString anInitialPath = "";
253 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
254 anInitialPath = QDir::currentPath();
256 QStringList filenames;
257 bool toCreateGroups = true;
259 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
260 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
261 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
262 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
263 // fd->setNameFilters( filter );
264 // fd->SetChecked( true );
266 // filenames << fd->selectedFile();
267 // toCreateGroups = fd->IsChecked();
273 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
276 QObject::tr( "SMESH_IMPORT_MESH" ) );
278 if ( filenames.count() > 0 )
280 SUIT_OverrideCursor wc;
281 _PTR(Study) aStudy = SMESH::getStudy();
284 QStringList anEntryList;
285 bool isEmpty = false;
286 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
288 QString filename = *it;
289 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
291 switch ( theCommandID ) {
292 case SMESHOp::OpImportDAT:
293 case SMESHOp::OpPopupImportDAT:
295 // DAT format (currently unsupported)
296 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
297 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
300 case SMESHOp::OpImportUNV:
301 case SMESHOp::OpPopupImportUNV:
304 aMeshes->length( 1 );
305 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
306 if ( aMeshes[0]->_is_nil() )
307 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
308 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
311 case SMESHOp::OpImportMED:
312 case SMESHOp::OpPopupImportMED:
315 SMESH::DriverMED_ReadStatus res;
316 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
317 if ( res != SMESH::DRS_OK ) {
318 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
319 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
323 case SMESHOp::OpImportSTL:
324 case SMESHOp::OpPopupImportSTL:
327 aMeshes->length( 1 );
328 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
329 if ( aMeshes[0]->_is_nil() ) {
330 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
331 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
335 case SMESHOp::OpImportCGNS:
336 case SMESHOp::OpPopupImportCGNS:
339 SMESH::DriverMED_ReadStatus res;
340 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
341 if ( res != SMESH::DRS_OK ) {
342 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
343 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
347 case SMESHOp::OpImportSAUV:
348 case SMESHOp::OpPopupImportSAUV:
351 SMESH::DriverMED_ReadStatus res;
352 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
353 if ( res != SMESH::DRS_OK ) {
354 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
355 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
359 case SMESHOp::OpImportGMF:
360 case SMESHOp::OpPopupImportGMF:
363 SMESH::ComputeError_var res;
364 aMeshes->length( 1 );
365 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
368 if ( res->code != SMESH::DRS_OK ) {
369 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
370 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
371 if ( strlen( res->comment.in() ) > 0 ) {
372 errors.back() += ": ";
373 errors.back() += res->comment.in();
380 catch ( const SALOME::SALOME_Exception& S_ex ) {
381 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
382 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
385 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
387 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
389 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
390 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
391 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
392 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
393 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
395 anEntryList.append( aMeshSO->GetID().c_str() );
403 // update Object browser
404 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
406 // browse to the published meshes
407 if( LightApp_Application* anApp =
408 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
409 anApp->browseObjects( anEntryList );
411 // show Error message box if there were errors
412 if ( errors.count() > 0 ) {
413 SUIT_MessageBox::critical( SMESHGUI::desktop(),
414 QObject::tr( "SMESH_ERROR" ),
415 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
418 // show warning message box, if some imported mesh is empty
420 SUIT_MessageBox::warning( SMESHGUI::desktop(),
421 QObject::tr( "SMESH_WRN_WARNING" ),
422 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
427 //================================================================================
429 * \brief Export selected meshes or groups into a file
431 //================================================================================
433 void ExportMeshToFile( int theCommandID )
435 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
436 SALOME_ListIO selected;
438 aSel->selectedObjects( selected );
440 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
441 theCommandID == SMESHOp::OpPopupExportDAT );
442 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
443 theCommandID == SMESHOp::OpPopupExportMED );
444 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
445 theCommandID == SMESHOp::OpPopupExportUNV );
446 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
447 theCommandID == SMESHOp::OpPopupExportSTL );
448 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
449 theCommandID == SMESHOp::OpPopupExportCGNS );
450 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
451 theCommandID == SMESHOp::OpPopupExportSAUV );
452 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
453 theCommandID == SMESHOp::OpPopupExportGMF );
455 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
456 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
458 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
459 bool aCheckWarn = true;
461 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
462 // get mesh object from selection and check duplication of their names
463 bool hasDuplicatedMeshNames = false;
464 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
465 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
466 SALOME_ListIteratorOfListIO It( selected );
467 for( ; It.More(); It.Next() )
469 Handle(SALOME_InteractiveObject) anIObject = It.Value();
470 SMESH::SMESH_IDSource_var aMeshItem =
471 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
472 if ( aMeshItem->_is_nil() ) {
473 SUIT_MessageBox::warning( SMESHGUI::desktop(),
474 QObject::tr( "SMESH_WRN_WARNING" ),
475 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
478 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
479 if ( aCheckWarn && !aGroup->_is_nil() )
481 QMessageBox msgBox(SUIT_MessageBox::Warning,
482 QObject::tr("SMESH_WRN_WARNING"),
483 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
484 QMessageBox::StandardButton::NoButton,
485 SMESHGUI::desktop());
486 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
487 msgBox.addButton(QMessageBox::Ok);
488 msgBox.addButton(QMessageBox::Cancel);
489 msgBox.setDefaultButton(QMessageBox::Cancel);
490 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
491 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
492 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
493 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
494 if(msgBox.exec() == QMessageBox::Ok)
496 if(dontShowCheckBox.checkState() == Qt::Checked)
499 resMgr->setValue( "SMESH", "show_warning", false);
507 QString aMeshName = anIObject->getName();
509 // check for name duplications
510 if ( !hasDuplicatedMeshNames )
511 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
512 if( aMeshName == (*aMeshIter).second ) {
513 hasDuplicatedMeshNames = true;
518 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
521 if( hasDuplicatedMeshNames && isMED ) {
522 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
523 QObject::tr("SMESH_WRN_WARNING"),
524 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
525 QObject::tr("SMESH_BUT_YES"),
526 QObject::tr("SMESH_BUT_NO"), 0, 1);
531 aMeshIter = aMeshList.begin();
532 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
533 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
534 QString aMeshName = (*aMeshIter).second;
536 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
538 // check for equal group names within each mesh
539 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
540 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
541 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
542 int aRet = SUIT_MessageBox::warning
543 (SMESHGUI::desktop(),
544 QObject::tr("SMESH_WRN_WARNING"),
545 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
546 QObject::tr("SMESH_BUT_YES"),
547 QObject::tr("SMESH_BUT_NO"), 0, 1);
554 // Warn the user about presence of not supported elements
556 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
560 notSupportedElemTypes.push_back( SMESH::Entity_0D );
561 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
566 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
567 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
568 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
569 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
570 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
571 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
572 notSupportedElemTypes.push_back( SMESH::Entity_0D );
573 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
578 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
579 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
580 notSupportedElemTypes.push_back( SMESH::Entity_0D );
581 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
586 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
591 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
592 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
593 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
594 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
595 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
596 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
597 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
598 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
603 notSupportedElemTypes.push_back( SMESH::Entity_0D );
604 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
605 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
606 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
607 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
608 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
609 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
610 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
611 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
612 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
614 if ( ! notSupportedElemTypes.empty() )
616 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
617 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
618 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
619 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
621 if ( !presentNotSupported.empty() )
624 const char* typeMsg[] = {
625 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
626 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
627 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
628 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
629 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
630 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
631 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
632 "SMESH_BIQUADRATIC_PENTAHEDRONS",
633 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
635 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
636 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
637 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
639 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
640 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
641 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
642 if ( iType != presentNotSupported.size() - 1 )
643 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
645 int aRet = SUIT_MessageBox::warning
646 (SMESHGUI::desktop(),
647 QObject::tr("SMESH_WRN_WARNING"),
648 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
649 QObject::tr("SMESH_BUT_YES"),
650 QObject::tr("SMESH_BUT_NO"), 0, 1);
655 // Get parameters of export operation
658 int aFormat =-1; // for MED minor versions
659 bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
661 // Init the parameters with the default values
662 bool aIsASCII_STL = true;
663 bool toCreateGroups = false;
665 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
666 bool toOverwrite = true;
667 bool toFindOutDim = true;
669 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
670 QString anInitialPath = "";
671 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
672 anInitialPath = QDir::currentPath();
674 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
676 // Get a file name to write in and additional otions
677 if ( isUNV || isDAT || isGMF ) // Export w/o options
680 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
682 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
684 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
685 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
686 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
687 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
688 anInitialPath + QString("/") + aMeshName,
689 aFilter, aTitle, false);
691 else if ( isCGNS )// Export to CGNS
693 const char* theByTypeResource = "cgns_group_elems_by_type";
694 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
696 QStringList checkBoxes;
697 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
699 SalomeApp_CheckFileDlg* fd =
700 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
701 fd->setWindowTitle( aTitle );
702 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
703 if ( !anInitialPath.isEmpty() )
704 fd->setDirectory( anInitialPath );
705 fd->selectFile(aMeshName);
706 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
707 fd->setValidator( fv );
708 fd->SetChecked( toCreateGroups, 0 );
711 aFilename = fd->selectedFile();
712 toOverwrite = fv->isOverwrite(aFilename);
713 toCreateGroups = fd->IsChecked(0);
714 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
718 else if ( isSTL ) // Export to STL
720 QMap<QString, int> aFilterMap;
721 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
722 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
725 QMap<QString, int>::const_iterator it = aFilterMap.begin();
726 for ( ; it != aFilterMap.end(); ++it )
727 filters.push_back( it.key() );
729 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
730 fd->setWindowTitle( aTitle );
731 fd->setNameFilters( filters );
732 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
733 if ( !anInitialPath.isEmpty() )
734 fd->setDirectory( anInitialPath );
735 fd->selectFile(aMeshName);
739 aFilename = fd->selectedFile();
740 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
745 else if ( isMED || isSAUV ) // Export to MED or SAUV
747 QMap<QString, int> aFilterMap;
749 //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
750 QString vmed (aMesh->GetVersionString(-1, 2));
751 //MESSAGE("MED version: " << vmed.toStdString());
752 int minor = vmed.split(".").last().toInt();
753 //MESSAGE("MED version minor: "<< minor);
754 //minor +=3; // TODO remove: test multiple minor
755 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vmed ) + " (*.med)", minor );
756 for (int ii=0; ii<minor; ii++)
758 QString vs = aMesh->GetVersionString(ii, 2);
759 //std::ostringstream vss; // TODO remove: test multiple minor
760 //vss << "4."; // TODO remove: test multiple minor
761 //vss << ii; // TODO remove: test multiple minor
762 //vs = vss.str().c_str(); // TODO remove: test multiple minor
763 //MESSAGE("MED version: " << vs.toStdString());
764 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", ii);
768 aFilterMap.insert("All files (*)", -1 );
769 aFilterMap.insert("SAUV files (*.sauv)", -1 );
770 aFilterMap.insert("SAUV files (*.sauve)", -1 );
774 QString aDefaultFilter;
775 QMap<QString, int>::const_iterator it = aFilterMap.begin();
776 for ( ; it != aFilterMap.end(); ++it ) {
777 filters.push_back( it.key() );
779 aDefaultFilter = it.key();
781 QStringList checkBoxes;
782 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
784 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
785 QList< QWidget* > wdgList;
786 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
787 wdgList.append( fieldSelWdg );
789 SalomeApp_CheckFileDlg* fd =
790 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
791 fd->setWindowTitle( aTitle );
792 fd->setNameFilters( filters );
793 fd->SetChecked( toCreateGroups, 0 );
794 fd->SetChecked( toFindOutDim, 1 );
795 if ( !anInitialPath.isEmpty() )
796 fd->setDirectory( anInitialPath );
797 fd->selectFile(aMeshName);
800 QListView *lview = fd->findChild<QListView*>("listView");
802 lview->setMinimumHeight(200);
804 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
806 tview->setMinimumHeight(200);
809 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
810 fd->setValidator( fv );
814 //MESSAGE("******* Loop on file dialog ***********");
817 aFilename = fd->selectedFile();
819 aFilename = QString::null;
822 aFormat = aFilterMap[fd->selectedNameFilter()];
823 //MESSAGE("selected minor: " << aFormat << " file: " << aFilename.toUtf8().constData());
824 toOverwrite = fv->isOverwrite(aFilename);
826 if ( !aFilename.isEmpty() ) {
828 // can't append to an existing using other format
829 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
830 if ( !isVersionOk ) {
831 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
832 QObject::tr("SMESH_WRN_WARNING"),
833 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
834 QObject::tr("SMESH_BUT_YES"),
835 QObject::tr("SMESH_BUT_NO"), 0, 1);
839 MESSAGE("incompatible MED file version for add, overwrite accepted");
845 MESSAGE("incompatible MED file version for add, overwrite refused");
848 QStringList aMeshNamesCollisionList;
849 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
850 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
851 QString anExistingMeshName( aMeshNames[ i ] );
852 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
853 QString anExportMeshName = (*aMeshIter).second;
854 if( anExportMeshName == anExistingMeshName ) {
855 aMeshNamesCollisionList.append( anExportMeshName );
860 if( !aMeshNamesCollisionList.isEmpty() ) {
862 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
863 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
864 QObject::tr("SMESH_WRN_WARNING"),
865 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
866 QObject::tr("SMESH_BUT_YES"),
867 QObject::tr("SMESH_BUT_NO"),
868 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
869 //MESSAGE("answer collision name " << aRet);
880 //MESSAGE(" ****** end of file dialog loop")
881 toCreateGroups = fd->IsChecked(0);
882 toFindOutDim = fd->IsChecked(1);
883 fieldSelWdg->GetSelectedFields();
884 if ( !fieldSelWdg->parent() )
895 if ( !aFilename.isEmpty() ) {
896 // Check whether the file already exists and delete it if yes
897 QFile aFile( aFilename );
898 if ( aFile.exists() && toOverwrite )
900 SUIT_OverrideCursor wc;
903 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
904 // bool Renumber = false;
905 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
907 // Renumber= resMgr->booleanValue("renumbering");
909 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
910 // aMeshEditor->RenumberNodes();
911 // aMeshEditor->RenumberElements();
912 // if ( SMESHGUI::automaticUpdate() )
913 // SMESH::UpdateView();
915 if ( isMED && isOkToWrite)
917 //MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
918 aMeshIter = aMeshList.begin();
919 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
921 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
922 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
923 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
924 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
925 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
926 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
927 aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
928 toOverwrite && aMeshIndex == 0, toFindOutDim );
930 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups, aFormat,
931 toOverwrite && aMeshIndex == 0, toFindOutDim,
932 fields, geoAssFields.toLatin1().data() );
937 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
939 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
940 if( !aMeshItem->_is_nil() )
941 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
946 if ( aMeshOrGroup->_is_equivalent( aMesh ))
947 aMesh->ExportDAT( aFilename.toUtf8().data() );
949 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
953 if ( aMeshOrGroup->_is_equivalent( aMesh ))
954 aMesh->ExportUNV( aFilename.toUtf8().data() );
956 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
960 if ( aMeshOrGroup->_is_equivalent( aMesh ))
961 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
963 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
967 aMeshIter = aMeshList.begin();
968 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
970 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
971 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
972 aMeshItem->ExportCGNS( aMeshOrGroup,
973 aFilename.toUtf8().data(),
974 toOverwrite && aMeshIndex == 0,
980 toCreateGroups = true;
981 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
984 catch (const SALOME::SALOME_Exception& S_ex){
986 SUIT_MessageBox::warning(SMESHGUI::desktop(),
987 QObject::tr("SMESH_WRN_WARNING"),
988 QObject::tr("SMESH_EXPORT_FAILED"));
994 inline void InverseEntityMode(unsigned int& theOutputMode,
995 unsigned int theMode)
997 bool anIsNotPresent = ~theOutputMode & theMode;
999 theOutputMode |= theMode;
1001 theOutputMode &= ~theMode;
1004 void SetDisplayEntity(int theCommandID)
1006 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1007 SALOME_ListIO selected;
1009 aSel->selectedObjects( selected );
1011 if ( selected.Extent() >= 1 ) {
1012 SUIT_OverrideCursor wc;
1013 SALOME_ListIteratorOfListIO It( selected );
1014 for( ; It.More(); It.Next()){
1015 Handle(SALOME_InteractiveObject) IObject = It.Value();
1016 if(IObject->hasEntry()){
1017 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1018 unsigned int aMode = anActor->GetEntityMode();
1019 switch(theCommandID){
1020 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1021 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1022 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1023 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1024 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1025 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1028 anActor->SetEntityMode(aMode);
1037 SalomeApp_Application* app =
1038 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1042 LightApp_SelectionMgr* aSel = app->selectionMgr();
1043 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1044 if ( !aSel || !appStudy )
1047 SALOME_ListIO selected;
1048 aSel->selectedObjects( selected );
1049 if ( selected.IsEmpty() )
1052 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1054 _PTR(Study) aStudy = appStudy->studyDS();
1055 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1056 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1057 if ( aMainObject->_is_nil() )
1060 SUIT_OverrideCursor wc;
1062 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1064 QList<SALOMEDS::Color> aReservedColors;
1066 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1067 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1069 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1071 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1072 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1073 #else // old algorithm for auto-colors
1074 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1075 aReservedColors.append( aColor );
1076 #endif // SIMPLE_AUTOCOLOR
1077 aGroupObject->SetColor( aColor );
1079 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1080 if ( aGroupSObject ) {
1083 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1084 switch ( aGroupObject->GetType ()) {
1086 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1088 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1090 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1092 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1094 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1095 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1098 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1099 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1105 SMESH::RepaintCurrentView();
1108 void OverallMeshQuality()
1110 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1111 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1112 SALOME_ListIO selected;
1114 aSel->selectedObjects( selected );
1116 if ( selected.IsEmpty() ) return;
1117 SALOME_ListIteratorOfListIO It( selected );
1118 for ( ; It.More(); It.Next() ) {
1119 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1120 ctrlDlg->showInfo( It.Value() );
1125 QString functorToString( SMESH::Controls::FunctorPtr f )
1127 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1128 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1129 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1130 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1131 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1132 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1133 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1134 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1135 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1136 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1137 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1138 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1139 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1140 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1141 type = QObject::tr( "WARP_ELEMENTS" );
1142 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1143 type = QObject::tr( "TAPER_ELEMENTS" );
1144 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1145 type = QObject::tr( "SKEW_ELEMENTS" );
1146 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1147 type = QObject::tr( "AREA_ELEMENTS" );
1148 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1149 type = QObject::tr( "LENGTH_EDGES" );
1150 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1151 type = QObject::tr( "LENGTH2D_EDGES" );
1152 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1153 type = QObject::tr( "DEFLECTION2D_FACES" );
1154 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1155 type = QObject::tr( "MULTI_BORDERS" );
1156 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1157 type = QObject::tr( "MULTI2D_BORDERS" );
1158 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1159 type = QObject::tr( "FREE_NODES" );
1160 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1161 type = QObject::tr( "FREE_EDGES" );
1162 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1163 type = QObject::tr( "FREE_BORDERS" );
1164 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1165 type = QObject::tr( "FREE_FACES" );
1166 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1167 type = QObject::tr( "BARE_BORDER_VOLUME" );
1168 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1169 type = QObject::tr( "BARE_BORDER_FACE" );
1170 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1171 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1172 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1173 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1174 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1175 type = QObject::tr( "EQUAL_NODE" );
1176 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1177 type = QObject::tr( "EQUAL_EDGE" );
1178 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1179 type = QObject::tr( "EQUAL_FACE" );
1180 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1181 type = QObject::tr( "EQUAL_VOLUME" );
1182 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1183 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1187 void SaveDistribution()
1189 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1190 SALOME_ListIO selected;
1192 aSel->selectedObjects( selected );
1194 if ( selected.Extent() == 1 ) {
1195 Handle(SALOME_InteractiveObject) anIO = selected.First();
1196 if ( anIO->hasEntry() ) {
1197 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1199 anActor->GetScalarBarActor() &&
1200 anActor->GetControlMode() != SMESH_Actor::eNone )
1202 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1203 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1204 if ( aScalarBarActor && aFunctor ) {
1205 SMESH::Controls::NumericalFunctor* aNumFun =
1206 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1208 std::vector<int> elements;
1209 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1210 if ( mesh->_is_nil() ) {
1211 SMESH::SMESH_IDSource_var idSource =
1212 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1213 if ( !idSource->_is_nil() )
1215 SMESH::long_array_var ids = idSource->GetIDs();
1216 elements.resize( ids->length() );
1217 for ( unsigned i = 0; i < elements.size(); ++i )
1218 elements[i] = ids[i];
1221 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1222 vtkLookupTable* lookupTable =
1223 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1224 double * minmax = lookupTable->GetRange();
1225 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1226 std::vector<int> nbEvents;
1227 std::vector<double> funValues;
1228 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1229 elements, minmax, isLogarithmic );
1230 QString anInitialPath = "";
1231 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1232 anInitialPath = QDir::currentPath();
1233 QString aMeshName = anIO->getName();
1235 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1236 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1237 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1238 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1239 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1242 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1244 if ( !aFilename.isEmpty() ) {
1245 QFile f( aFilename );
1246 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1247 QTextStream out( &f );
1248 out << "# Mesh: " << aMeshName << endl;
1249 out << "# Control: " << functorToString( aFunctor ) << endl;
1251 out.setFieldWidth( 10 );
1252 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1253 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1264 void ShowElement( int theCommandID )
1266 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1267 SALOME_ListIO selected;
1269 aSel->selectedObjects( selected );
1271 if ( selected.Extent() == 1 ) {
1272 Handle(SALOME_InteractiveObject) anIO = selected.First();
1273 if ( anIO->hasEntry() ) {
1274 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1276 anActor->GetScalarBarActor() &&
1277 anActor->GetControlMode() != SMESH_Actor::eNone )
1279 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1280 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1281 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1283 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1284 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1291 #ifndef DISABLE_PLOT2DVIEWER
1292 void PlotDistribution()
1294 SalomeApp_Application* app =
1295 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1299 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1300 SALOME_ListIO selected;
1302 aSel->selectedObjects( selected );
1304 if ( selected.Extent() == 1 ) {
1305 Handle(SALOME_InteractiveObject) anIO = selected.First();
1306 if ( anIO->hasEntry() ) {
1307 //Find Actor by entry before getting Plot2d viewer,
1308 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1309 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1311 SUIT_ViewManager* aViewManager =
1312 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1316 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1320 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1324 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1326 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1327 QString functorName = functorToString( anActor->GetFunctor());
1328 QString aHistogramName("%1 : %2");
1329 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1330 aHistogram->setName(aHistogramName);
1331 aHistogram->setHorTitle(functorName);
1332 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1333 aPlot->displayObject(aHistogram, true);
1338 #endif //DISABLE_PLOT2DVIEWER
1340 void DisableAutoColor()
1342 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1343 SALOME_ListIO selected;
1345 aSel->selectedObjects( selected );
1347 if ( selected.Extent() ) {
1348 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1349 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1350 if ( !aMesh->_is_nil() ) {
1351 aMesh->SetAutoColor( false );
1358 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1359 SALOME_ListIO selected;
1361 aSel->selectedObjects( selected );
1362 if ( selected.Extent() )
1364 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1365 _PTR(Study) aStudy = SMESH::getStudy();
1366 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1368 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1369 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1376 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1378 SALOME_ListIO selected;
1379 SalomeApp_Application* app =
1380 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1384 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1385 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1386 if ( !aSel || !appStudy )
1389 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1390 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1391 aModule->EmitSignalDeactivateDialog();
1392 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1393 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1398 aSel->selectedObjects( selected );
1400 if ( selected.Extent() >= 1 )
1402 switch ( theCommandID ) {
1403 case SMESHOp::OpTransparency:
1405 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1406 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1409 case SMESHOp::OpProperties:
1412 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1413 QColor orientationColor, outlineColor, volumeColor;
1414 int deltaF = 0, deltaV = 0;
1417 double ballScale = 1.0;
1419 int outlineWidth = 1;
1420 double shrinkCoef = 0.0;
1421 double orientationScale = 0.0;
1422 bool orientation3d = false;
1423 VTK::MarkerType markerType = VTK::MT_NONE;
1424 VTK::MarkerScale markerScale = VTK::MS_NONE;
1426 bool hasNodes = false;
1427 int presentEntities = 0;
1428 bool firstTime = true;
1430 SALOME_ListIteratorOfListIO It( selected );
1431 for ( ; It.More(); It.Next() ) {
1432 Handle(SALOME_InteractiveObject) IObject = It.Value();
1433 if ( !IObject->hasEntry() ) continue;
1434 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1435 if ( !anActor || !anActor->GetObject() ) continue;
1438 // nodes: color, marker
1439 anActor->GetNodeColor( color[0], color[1], color[2] );
1440 nodeColor.setRgbF( color[0], color[1], color[2] );
1441 markerType = anActor->GetMarkerType();
1442 markerScale = anActor->GetMarkerScale();
1443 markerId = anActor->GetMarkerTexture();
1444 // edges: color, width
1445 anActor->GetEdgeColor( color[0], color[1], color[2] );
1446 edgeColor.setRgbF( color[0], color[1], color[2] );
1447 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1448 // faces: front color, back color (delta)
1449 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1450 faceColor.setRgbF( color[0], color[1], color[2] );
1451 // faces: front color, back color (delta)
1452 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1453 volumeColor.setRgbF( color[0], color[1], color[2] );
1454 // 0d elements: color, size
1455 anActor->Get0DColor( color[0], color[1], color[2] );
1456 elem0dColor.setRgbF( color[0], color[1], color[2] );
1457 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1458 // balls: color, size
1459 anActor->GetBallColor( color[0], color[1], color[2] );
1460 ballColor.setRgbF( color[0], color[1], color[2] );
1461 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1462 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1464 anActor->GetOutlineColor( color[0], color[1], color[2] );
1465 outlineColor.setRgbF( color[0], color[1], color[2] );
1466 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1467 // orientation vectors: color, scale, 3d flag
1468 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1469 orientationColor.setRgbF( color[0], color[1], color[2] );
1470 orientationScale = anActor->GetFacesOrientationScale();
1471 orientation3d = anActor->GetFacesOrientation3DVectors();
1473 shrinkCoef = anActor->GetShrinkFactor();
1476 firstTime = false; // we only take properties from first object (for performance reasons)
1479 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1480 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1481 presentEntities = presentEntities | SMESH_Actor::eEdges;
1482 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1483 presentEntities = presentEntities | SMESH_Actor::eFaces;
1484 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1485 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1486 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1487 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1488 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1489 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1491 // as we know that all types of elements are present, we can exit the loop
1492 if ( presentEntities == SMESH_Actor::eAllEntity )
1496 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1497 // nodes: color, marker
1498 dlg.setNodeColor( nodeColor );
1499 if( markerType != VTK::MT_USER )
1500 dlg.setNodeMarker( markerType, markerScale );
1502 dlg.setNodeCustomMarker( markerId );
1503 // edges: color, line width
1504 dlg.setEdgeColor( edgeColor );
1505 dlg.setEdgeWidth( edgeWidth );
1506 // faces: front color, back color
1507 dlg.setFaceColor( faceColor, deltaF );
1508 // volumes: normal color, reversed color
1509 dlg.setVolumeColor( volumeColor, deltaV );
1510 // outlines: color, line width
1511 dlg.setOutlineColor( outlineColor );
1512 dlg.setOutlineWidth( outlineWidth );
1513 // 0d elements: color, size
1514 dlg.setElem0dColor( elem0dColor );
1515 dlg.setElem0dSize( elem0dSize );
1516 // balls: color, size
1517 dlg.setBallColor( ballColor );
1518 //dlg.setBallSize( ballSize );
1519 dlg.setBallScale( ballScale );
1520 // orientation: color, scale, 3d flag
1521 dlg.setOrientationColor( orientationColor );
1522 dlg.setOrientationSize( int( orientationScale * 100. ) );
1523 dlg.setOrientation3d( orientation3d );
1524 // shrink: scale factor
1525 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1526 // hide unused controls
1527 dlg.showControls( presentEntities, hasNodes );
1530 nodeColor = dlg.nodeColor();
1531 markerType = dlg.nodeMarkerType();
1532 markerScale = dlg.nodeMarkerScale();
1533 markerId = dlg.nodeMarkerId();
1534 edgeColor = dlg.edgeColor();
1535 edgeWidth = dlg.edgeWidth();
1536 faceColor = dlg.faceColor();
1537 deltaF = dlg.faceColorDelta();
1538 volumeColor = dlg.volumeColor();
1539 deltaV = dlg.volumeColorDelta();
1540 outlineColor = dlg.outlineColor();
1541 outlineWidth = dlg.outlineWidth();
1542 elem0dColor = dlg.elem0dColor();
1543 elem0dSize = dlg.elem0dSize();
1544 ballColor = dlg.ballColor();
1545 // ballSize = dlg.ballSize();
1546 ballScale = dlg.ballScale();
1547 orientationColor = dlg.orientationColor();
1548 orientationScale = dlg.orientationSize() / 100.;
1549 orientation3d = dlg.orientation3d();
1550 shrinkCoef = dlg.shrinkCoef() / 100.;
1552 // store point markers that might be changed by the user
1553 theMarkerMap = dlg.customMarkers();
1555 // set properties from dialog box to the presentations
1556 SALOME_ListIteratorOfListIO It( selected );
1557 for ( ; It.More(); It.Next() ) {
1558 Handle(SALOME_InteractiveObject) IObject = It.Value();
1559 if ( !IObject->hasEntry() ) continue;
1560 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1561 if ( !anActor ) continue;
1563 // nodes: color, marker
1564 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1565 if ( markerType != VTK::MT_USER ) {
1566 anActor->SetMarkerStd( markerType, markerScale );
1569 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1570 if ( iter != theMarkerMap.end() )
1571 anActor->SetMarkerTexture( markerId, iter->second.second );
1573 // volumes: normal color, reversed color (delta)
1574 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1575 // faces: front color, back color (delta)
1576 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1577 // edges: color, width
1578 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1579 anActor->SetLineWidth( edgeWidth );
1581 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1582 anActor->SetOutlineWidth( outlineWidth );
1583 // 0D elements: color, size
1584 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1585 anActor->Set0DSize( elem0dSize );
1586 // balls: color, size
1587 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1588 // anActor->SetBallSize( ballSize );
1589 anActor->SetBallScale( ballScale );
1590 // orientation: color, scale, 3d flag
1591 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1592 anActor->SetFacesOrientationScale( orientationScale );
1593 anActor->SetFacesOrientation3DVectors( orientation3d );
1595 anActor->SetShrinkFactor( shrinkCoef );
1597 // for groups, set also proper color
1598 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1599 if ( !aGroupObject->_is_nil() ) {
1600 SMESH::ElementType anElementType = aGroupObject->GetType();
1602 switch( anElementType ) {
1604 aColor = nodeColor; break;
1606 aColor = edgeColor; break;
1608 aColor = faceColor; break;
1610 aColor = volumeColor; break;
1612 aColor = elem0dColor; break;
1614 aColor = ballColor; break;
1618 if ( aColor.isValid() ) {
1619 SALOMEDS::Color aGroupColor;
1620 aGroupColor.R = aColor.redF();
1621 aGroupColor.G = aColor.greenF();
1622 aGroupColor.B = aColor.blueF();
1623 aGroupObject->SetColor( aGroupColor );
1625 } // if ( !aGroupObject->_is_nil() )
1626 } // for ( ; It.More(); It.Next() )
1627 SMESH::RepaintCurrentView();
1628 } // if ( dlg.exec() )
1630 } // case SMESHOp::OpProperties:
1631 } // switch(theCommandID)
1632 SUIT_OverrideCursor wc;
1633 SALOME_ListIteratorOfListIO It( selected );
1634 for( ; It.More(); It.Next()){
1635 Handle(SALOME_InteractiveObject) IObject = It.Value();
1636 if(IObject->hasEntry()){
1637 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1638 switch(theCommandID){
1639 case SMESHOp::OpDMWireframe:
1640 anActor->SetRepresentation(SMESH_Actor::eEdge);
1642 case SMESHOp::OpDMShading:
1643 anActor->SetRepresentation(SMESH_Actor::eSurface);
1645 case SMESHOp::OpDMShrink:
1646 if(anActor->IsShrunk())
1647 anActor->UnShrink();
1649 anActor->SetShrink();
1651 case SMESHOp::OpDMNodes:
1652 anActor->SetRepresentation(SMESH_Actor::ePoint);
1654 case SMESHOp::OpRepresentationLines:
1655 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1656 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1658 case SMESHOp::OpRepresentationArcs:
1659 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1660 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1666 SMESH::RepaintCurrentView();
1670 int ActionToControl( int theID, bool theReversed )
1672 NCollection_DoubleMap<int,int> ActionControl;
1673 ActionControl.Bind( 0, SMESH_Actor::eNone );
1674 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1675 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1676 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1677 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1678 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1679 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1680 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1681 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1682 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1683 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1684 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1685 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1686 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1687 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1688 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1689 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1690 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1691 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1692 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1693 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1694 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1695 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1696 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1697 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1698 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1699 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1700 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1701 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1704 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1705 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1708 void Control( int theCommandID )
1710 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1711 _PTR(Study) aStudy = SMESH::getStudy();
1713 SALOME_ListIO selected;
1714 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1715 aSel->selectedObjects( selected );
1717 if ( !selected.IsEmpty() ) {
1718 SALOME_ListIteratorOfListIO It(selected);
1719 for ( ; It.More(); It.Next())
1721 Handle(SALOME_InteractiveObject) anIO = It.Value();
1722 if ( !anIO.IsNull() ) {
1723 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1725 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1726 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1727 if ( !anIDSrc->_is_nil() ) {
1728 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1729 if (( !anActor && selected.Extent() == 1 ) &&
1730 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1732 anActor->SetControlMode( aControl );
1733 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1734 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1738 if ( anActor->GetControlMode() != aControl )
1739 anActor->SetControlMode( aControl );
1740 QString functorName = functorToString( anActor->GetFunctor() );
1741 int anEntitiesCount = anActor->GetNumberControlEntities();
1742 if (anEntitiesCount >= 0)
1743 functorName = functorName + ": " + QString::number(anEntitiesCount);
1744 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1745 SMESH::RepaintCurrentView();
1746 #ifndef DISABLE_PLOT2DVIEWER
1747 if ( anActor->GetPlot2Histogram() ) {
1748 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1749 QString aHistogramName("%1 : %2");
1750 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1751 aHistogram->setName( aHistogramName );
1752 aHistogram->setHorTitle( functorName );
1753 SMESH::ProcessIn2DViewers( anActor );
1765 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1766 SMESH::MeshObjectType theType,
1767 const QString theInTypeName,
1768 QString & theOutTypeName)
1770 SMESH_TypeFilter aTypeFilter( theType );
1772 if ( !theIO.IsNull() )
1774 entry = theIO->getEntry();
1775 LightApp_DataOwner owner( entry );
1776 if ( aTypeFilter.isOk( &owner )) {
1777 theOutTypeName = theInTypeName;
1785 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1787 _PTR(Study) aStudy = SMESH::getStudy();
1788 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1790 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1791 CORBA::String_var anID = aSComp->GetID().c_str();
1792 if ( !strcmp(anID.in(),theIO->getEntry()) )
1798 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1799 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1800 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1801 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1802 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1810 // QString CheckHomogeneousSelection()
1812 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1813 // SALOME_ListIO selected;
1815 // aSel->selectedObjects( selected );
1817 // QString RefType = CheckTypeObject(selected.First());
1818 // SALOME_ListIteratorOfListIO It(selected);
1819 // for ( ; It.More(); It.Next())
1821 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1822 // QString Type = CheckTypeObject(IObject);
1823 // if ( Type.compare(RefType) != 0 )
1824 // return "Heterogeneous Selection";
1830 uint randomize( uint size )
1832 static bool initialized = false;
1833 if ( !initialized ) {
1834 qsrand( QDateTime::currentDateTime().toTime_t() );
1838 v = uint( (double)( v ) / RAND_MAX * size );
1839 v = qMax( uint(0), qMin ( v, size-1 ) );
1845 void SMESHGUI::OnEditDelete()
1847 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1848 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1849 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1851 _PTR(Study) aStudy = SMESH::getStudy();
1852 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1853 _PTR(GenericAttribute) anAttr;
1854 _PTR(AttributeIOR) anIOR;
1856 int objectCount = 0;
1858 QString aParentComponent = QString::null;
1860 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1862 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1863 if ( anIO.IsNull() ) continue;
1865 QString father = "unknown";
1867 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1869 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1870 // check if object is reference
1871 _PTR(SObject) aRefSObj;
1872 aNameList.append("\n - ");
1873 if ( aSO->ReferencedObject( aRefSObj ) ) {
1874 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1875 aNameList.append( aRefName );
1876 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1879 aNameList.append(anIO->getName());
1883 if( aParentComponent.isNull() )
1884 aParentComponent = father;
1885 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1886 aParentComponent = "";
1889 if ( objectCount == 0 )
1890 return; // No Valid Objects Selected
1892 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1893 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1894 QObject::tr("ERR_ERROR"),
1895 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1898 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1899 if (SUIT_MessageBox::warning
1900 (SMESHGUI::desktop(),
1901 QObject::tr("SMESH_WRN_WARNING"),
1902 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1903 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1904 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1907 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1909 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1910 // then treat them all starting from the deepest objects (at list back)
1911 std::list< _PTR(SObject) > listSO;
1912 SALOME_ListIteratorOfListIO It(selected);
1913 for( ; It.More(); It.Next()) // loop on selected IO's
1915 Handle(SALOME_InteractiveObject) IObject = It.Value();
1916 if(IObject->hasEntry()) {
1917 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1919 // disable removal of "SMESH" component object
1920 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1922 if ( engineIOR() == anIOR->Value().c_str() )
1925 //Check the referenced object
1926 _PTR(SObject) aRefSObject;
1927 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1928 aSO = aRefSObject; // Delete main Object instead of reference
1930 listSO.push_back( aSO );
1931 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1932 for ( ; itSO != listSO.end(); ++itSO ) {
1933 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1934 for (it->InitEx(false); it->More(); it->Next())
1935 listSO.push_back( it->Value() );
1939 // Check if none of objects to delete is referred from outside
1940 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1941 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1943 _PTR(SObject) SO = *ritSO;
1944 if ( !SO ) continue;
1945 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1946 for (size_t i = 0; i < aReferences.size(); i++) {
1947 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1948 std::string type = aComponent->ComponentDataType();
1949 if ( type != "SMESH" )
1951 SUIT_MessageBox::warning( anApp->desktop(),
1952 QObject::tr("WRN_WARNING"),
1953 QObject::tr("DEP_OBJECT") );
1954 return; // outside SMESH, there is an object depending on a SMESH object
1959 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1960 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1962 Handle(SALOME_InteractiveObject) IObject = It.Value();
1963 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1964 if ( !mesh->_is_nil() )
1968 // Treat SO's in the list starting from the back
1969 aStudyBuilder->NewCommand(); // There is a transaction
1970 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1972 _PTR(SObject) SO = *ritSO;
1973 if ( !SO ) continue;
1974 std::string anEntry = SO->GetID();
1976 /** Erase graphical object and remove all its data **/
1977 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1978 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1980 /** Remove an object from data structures **/
1981 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1982 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1983 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1984 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1985 aMesh->RemoveGroup( aGroup );
1987 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1988 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1989 aMesh->RemoveSubMesh( aSubMesh );
1992 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1993 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1994 QString objType = CheckTypeObject(IObject);
1995 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1996 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1997 aStudyBuilder->RemoveObjectWithChildren( SO );
1999 else {// default action: remove SObject from the study
2000 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2001 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2003 aStudyBuilder->RemoveObjectWithChildren( SO );
2007 } /* listSO back loop */
2009 aStudyBuilder->CommitCommand();
2011 /* Clear any previous selection */
2013 aSel->setSelectedObjects( l1 );
2015 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2019 SMESHGUI_EXPORT CAM_Module* createModule()
2021 return new SMESHGUI();
2024 SMESHGUI_EXPORT char* getModuleVersion() {
2025 return (char*)SMESH_VERSION_STR;
2029 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2031 //=============================================================================
2035 //=============================================================================
2036 SMESHGUI::SMESHGUI() :
2037 SalomeApp_Module( "SMESH" )
2039 if ( CORBA::is_nil( myComponentSMESH ) )
2041 CORBA::Boolean anIsEmbeddedMode;
2042 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2043 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2045 // 0019923: EDF 765 SMESH : default values of hypothesis
2046 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2047 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2048 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2049 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2050 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2052 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2053 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2054 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2056 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2057 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2061 myActiveDialogBox = 0;
2062 myFilterLibraryDlg = 0;
2066 myEventCallbackCommand = vtkCallbackCommand::New();
2067 myEventCallbackCommand->Delete();
2068 myEventCallbackCommand->SetClientData( this );
2069 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2072 /* load resources for all available meshers */
2073 SMESH::InitAvailableHypotheses();
2076 //=============================================================================
2080 //=============================================================================
2081 SMESHGUI::~SMESHGUI()
2085 //=============================================================================
2089 //=============================================================================
2090 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2092 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2094 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2099 //=============================================================================
2103 //=============================================================================
2104 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2106 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2110 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2111 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2112 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2113 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2114 return autoUpdate && !exceeded;
2117 //=============================================================================
2121 //=============================================================================
2122 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2123 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2125 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2129 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2130 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2131 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2133 SMESH::long_array_var info = theMesh->GetMeshInfo();
2134 long nbOdElems = info[SMDSEntity_0D];
2135 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2136 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2137 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2138 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2139 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2140 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2141 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2142 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2143 info[SMDSEntity_Polyhedra] +
2144 info[SMDSEntity_Hexagonal_Prism];
2145 long nbBalls = info[SMDSEntity_Ball];
2147 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2148 *nbElements = requestedSize;
2150 *entities = SMESH_Actor::eAllEntity;
2153 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2155 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2157 if ( incrementalLimit ) {
2160 if ( nbOdElems > 0 ) {
2161 if ( total + nbOdElems > updateLimit ) {
2162 *entities = *entities & ~SMESH_Actor::e0DElements;
2163 *hidden = *hidden | SMESH_Actor::e0DElements;
2170 if ( nbEdges > 0 ) {
2171 if ( total + nbEdges > updateLimit ) {
2172 *entities = *entities & ~SMESH_Actor::eEdges;
2173 *hidden = *hidden | SMESH_Actor::eEdges;
2180 if ( nbFaces > 0 ) {
2181 if ( total + nbFaces > updateLimit ) {
2182 *entities = *entities & ~SMESH_Actor::eFaces;
2183 *hidden = *hidden | SMESH_Actor::eFaces;
2190 if ( nbVolumes > 0 ) {
2191 if ( total + nbVolumes > updateLimit ) {
2192 *entities = *entities & ~SMESH_Actor::eVolumes;
2193 *hidden = *hidden | SMESH_Actor::eVolumes;
2200 if ( nbBalls > 0 ) {
2201 if ( total + nbBalls > updateLimit ) {
2202 *entities = *entities & ~SMESH_Actor::eBallElem;
2203 *hidden = *hidden | SMESH_Actor::eBallElem;
2211 return autoUpdate && !exceeded;
2214 //=============================================================================
2218 //=============================================================================
2219 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2221 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2224 //=============================================================================
2228 //=============================================================================
2229 SMESHGUI* SMESHGUI::GetSMESHGUI()
2231 SMESHGUI* smeshMod = 0;
2232 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2235 CAM_Module* module = app->module( "Mesh" );
2236 smeshMod = dynamic_cast<SMESHGUI*>( module );
2244 Standard_EXPORT SMESHGUI* GetComponentGUI()
2246 return SMESHGUI::GetSMESHGUI();
2250 //=============================================================================
2254 //=============================================================================
2255 void SMESHGUI::SetState(int aState)
2260 //=============================================================================
2264 //=============================================================================
2265 void SMESHGUI::ResetState()
2270 //=============================================================================
2274 //=============================================================================
2275 void SMESHGUI::EmitSignalDeactivateDialog()
2277 emit SignalDeactivateActiveDialog();
2280 //=============================================================================
2284 //=============================================================================
2285 void SMESHGUI::EmitSignalStudyFrameChanged()
2287 emit SignalStudyFrameChanged();
2290 //=============================================================================
2294 //=============================================================================
2295 void SMESHGUI::EmitSignalCloseAllDialogs()
2297 emit SignalCloseAllDialogs();
2300 //=============================================================================
2304 //=============================================================================
2305 void SMESHGUI::EmitSignalVisibilityChanged()
2307 emit SignalVisibilityChanged();
2310 //=============================================================================
2314 //=============================================================================
2315 void SMESHGUI::EmitSignalCloseView()
2317 emit SignalCloseView();
2320 //=============================================================================
2324 //=============================================================================
2325 void SMESHGUI::EmitSignalActivatedViewManager()
2327 emit SignalActivatedViewManager();
2330 //=============================================================================
2334 //=============================================================================
2335 QDialog *SMESHGUI::GetActiveDialogBox()
2337 return myActiveDialogBox;
2340 //=============================================================================
2344 //=============================================================================
2345 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2347 myActiveDialogBox = (QDialog *) aDlg;
2351 //=============================================================================
2355 //=============================================================================
2356 SUIT_Desktop* SMESHGUI::desktop()
2358 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2360 return app->desktop();
2365 //=============================================================================
2369 //=============================================================================
2370 SalomeApp_Study* SMESHGUI::activeStudy()
2372 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2374 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2379 //=============================================================================
2383 //=============================================================================
2384 void SMESHGUI::Modified( bool theIsUpdateActions )
2386 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2387 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2388 appStudy->Modified();
2389 if( theIsUpdateActions )
2390 app->updateActions();
2395 //=============================================================================
2399 //=============================================================================
2400 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2402 /* Here the position is on the bottom right corner - 10 */
2403 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2405 SUIT_Desktop *PP = desktop();
2406 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2407 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2412 * \brief Verifies whether study of operation is locked
2413 * \param theMess - specifies whether message box must be shown if study is locked
2414 * \return State of study.
2416 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2417 * is locked when corresponding message box appears
2419 bool SMESHGUI::isStudyLocked( bool theMessage )
2421 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2424 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2425 QObject::tr( "WRN_WARNING" ),
2426 QObject::tr( "WRN_STUDY_LOCKED" ) );
2432 //=============================================================================
2436 //=============================================================================
2437 bool SMESHGUI::OnGUIEvent( int theCommandID )
2439 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2443 SUIT_ResourceMgr* mgr = resourceMgr();
2447 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2448 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2450 //QAction* act = action( theCommandID );
2452 switch (theCommandID) {
2453 case SMESHOp::OpDelete:
2454 if(isStudyLocked()) break;
2457 case SMESHOp::OpImportDAT:
2458 case SMESHOp::OpImportUNV:
2459 case SMESHOp::OpImportMED:
2460 case SMESHOp::OpImportSTL:
2461 case SMESHOp::OpImportCGNS:
2462 case SMESHOp::OpImportSAUV:
2463 case SMESHOp::OpImportGMF:
2464 case SMESHOp::OpPopupImportDAT:
2465 case SMESHOp::OpPopupImportUNV:
2466 case SMESHOp::OpPopupImportMED:
2467 case SMESHOp::OpPopupImportSTL:
2468 case SMESHOp::OpPopupImportCGNS:
2469 case SMESHOp::OpPopupImportSAUV:
2470 case SMESHOp::OpPopupImportGMF:
2472 if(isStudyLocked()) break;
2473 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2477 case SMESHOp::OpFileInformation:
2479 SALOME_ListIO selected;
2480 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2482 aSel->selectedObjects( selected );
2483 if( selected.Extent() )
2485 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2486 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2487 if ( !aMesh->_is_nil() )
2489 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2495 case SMESHOp::OpExportDAT:
2496 case SMESHOp::OpExportMED:
2497 case SMESHOp::OpExportUNV:
2498 case SMESHOp::OpExportSTL:
2499 case SMESHOp::OpExportCGNS:
2500 case SMESHOp::OpExportSAUV:
2501 case SMESHOp::OpExportGMF:
2502 case SMESHOp::OpPopupExportDAT:
2503 case SMESHOp::OpPopupExportMED:
2504 case SMESHOp::OpPopupExportUNV:
2505 case SMESHOp::OpPopupExportSTL:
2506 case SMESHOp::OpPopupExportCGNS:
2507 case SMESHOp::OpPopupExportSAUV:
2508 case SMESHOp::OpPopupExportGMF:
2510 ::ExportMeshToFile(theCommandID);
2514 case SMESHOp::OpReset: // SCALAR BAR
2516 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2517 SALOME_ListIO selected;
2519 aSel->selectedObjects( selected );
2521 SALOME_ListIteratorOfListIO it(selected);
2522 for( ; it.More(); it.Next()) {
2523 Handle(SALOME_InteractiveObject) anIO = it.Value();
2524 if( anIO->hasEntry() ) {
2525 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2526 anActor->SetControlMode( SMESH_Actor::eNone );
2527 #ifndef DISABLE_PLOT2DVIEWER
2528 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2533 SMESH::UpdateView();
2536 case SMESHOp::OpScalarBarProperties:
2538 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2541 case SMESHOp::OpShowScalarBar:
2543 // show/hide scalar bar
2544 ::ShowElement(theCommandID);
2547 case SMESHOp::OpSaveDistribution:
2549 // dump control distribution data to the text file
2550 ::SaveDistribution();
2554 case SMESHOp::OpShowDistribution:
2556 // show/hide distribution
2557 ::ShowElement(theCommandID);
2561 #ifndef DISABLE_PLOT2DVIEWER
2562 case SMESHOp::OpPlotDistribution:
2564 // plot distribution
2565 ::PlotDistribution();
2571 case SMESHOp::OpAutoColor:
2575 case SMESHOp::OpDisableAutoColor:
2576 ::DisableAutoColor();
2579 case SMESHOp::OpClipping:
2580 case SMESHOp::OpTransparency:
2581 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2584 case SMESHOp::OpDMWireframe:
2585 case SMESHOp::OpDMShading:
2586 case SMESHOp::OpDMNodes:
2587 case SMESHOp::OpDMShrink:
2588 ::SetDisplayMode(theCommandID, myMarkerMap);
2591 //2D quadratic representation
2592 case SMESHOp::OpRepresentationLines:
2593 case SMESHOp::OpRepresentationArcs:
2594 ::SetDisplayMode(theCommandID, myMarkerMap);
2598 case SMESHOp::OpDE0DElements:
2599 case SMESHOp::OpDEEdges:
2600 case SMESHOp::OpDEFaces:
2601 case SMESHOp::OpDEVolumes:
2602 case SMESHOp::OpDEBalls:
2603 case SMESHOp::OpDEAllEntity:
2604 ::SetDisplayEntity(theCommandID);
2607 // Choose entities to be displayed
2608 case SMESHOp::OpDEChoose:
2610 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2614 case SMESHOp::OpOrientationOnFaces:
2616 SUIT_OverrideCursor wc;
2617 LightApp_SelectionMgr* mgr = selectionMgr();
2618 SALOME_ListIO selected; mgr->selectedObjects( selected );
2620 SALOME_ListIteratorOfListIO it(selected);
2621 for( ; it.More(); it.Next()) {
2622 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2623 if(anIObject->hasEntry()) {
2624 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2625 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2632 case SMESHOp::OpUpdate:
2634 if(isStudyLocked()) break;
2635 SUIT_OverrideCursor wc;
2638 SMESH::UpdateView();
2640 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2641 SMESH::OnVisuException();
2643 catch (...) { // PAL16774 (Crash after display of many groups)
2644 SMESH::OnVisuException();
2648 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2649 aSel->selectedObjects( l );
2650 aSel->setSelectedObjects( l );
2654 case SMESHOp::OpHide:
2655 case SMESHOp::OpShow:
2656 case SMESHOp::OpShowOnly:
2658 SUIT_OverrideCursor wc;
2659 SMESH::EDisplaing anAction;
2660 switch (theCommandID) {
2661 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2662 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2663 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2666 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2667 SALOME_ListIO sel_objects, to_process;
2669 aSel->selectedObjects( sel_objects );
2671 if ( theCommandID==SMESHOp::OpShowOnly )
2673 //MESSAGE("anAction = SMESH::eDisplayOnly");
2674 startOperation( myEraseAll );
2677 extractContainers( sel_objects, to_process );
2682 SALOME_ListIteratorOfListIO It( to_process );
2683 for ( ; It.More(); It.Next())
2685 Handle(SALOME_InteractiveObject) IOS = It.Value();
2686 if ( IOS->hasEntry() )
2688 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2689 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2690 break; // PAL16774 (Crash after display of many groups)
2692 if (anAction == SMESH::eDisplayOnly)
2693 anAction = SMESH::eDisplay;
2698 // PAL13338 + PAL15161 -->
2699 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2700 SMESH::UpdateView();
2701 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2703 // PAL13338 + PAL15161 <--
2705 catch (...) { // PAL16774 (Crash after display of many groups)
2706 SMESH::OnVisuException();
2709 if (anAction == SMESH::eErase) {
2711 aSel->setSelectedObjects( l1 );
2714 aSel->setSelectedObjects( to_process );
2719 case SMESHOp::OpNode:
2721 if(isStudyLocked()) break;
2724 EmitSignalDeactivateDialog();
2726 ( new SMESHGUI_NodesDlg( this ) )->show();
2729 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2734 case SMESHOp::OpCreateMesh:
2735 case SMESHOp::OpCreateSubMesh:
2736 case SMESHOp::OpEditMeshOrSubMesh:
2737 case SMESHOp::OpEditMesh:
2738 case SMESHOp::OpEditSubMesh:
2739 case SMESHOp::OpCompute:
2740 case SMESHOp::OpComputeSubMesh:
2741 case SMESHOp::OpPreCompute:
2742 case SMESHOp::OpEvaluate:
2743 case SMESHOp::OpMeshOrder:
2744 startOperation( theCommandID );
2746 case SMESHOp::OpCopyMesh:
2748 if (isStudyLocked()) break;
2749 EmitSignalDeactivateDialog();
2750 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2753 case SMESHOp::OpBuildCompoundMesh:
2755 if (isStudyLocked()) break;
2756 EmitSignalDeactivateDialog();
2757 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2761 case SMESHOp::OpDiagonalInversion:
2762 case SMESHOp::OpUnionOfTwoTriangle:
2766 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2770 if ( isStudyLocked() )
2773 /*Standard_Boolean aRes;
2774 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2775 if ( aMesh->_is_nil() )
2777 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2778 tr( "SMESH_BAD_SELECTION" ) );
2782 EmitSignalDeactivateDialog();
2783 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2784 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2786 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2789 case SMESHOp::OpOrientation:
2790 case SMESHOp::OpUnionOfTriangles:
2791 case SMESHOp::OpCuttingOfQuadrangles:
2792 case SMESHOp::OpSplitVolumes:
2796 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2800 if ( isStudyLocked() )
2803 EmitSignalDeactivateDialog();
2804 SMESHGUI_MultiEditDlg* aDlg = NULL;
2805 if ( theCommandID == SMESHOp::OpOrientation )
2806 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2807 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2808 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2809 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2810 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2812 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2817 case SMESHOp::OpSmoothing:
2819 if(isStudyLocked()) break;
2821 EmitSignalDeactivateDialog();
2822 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2825 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2829 case SMESHOp::OpExtrusion:
2831 if (isStudyLocked()) break;
2833 EmitSignalDeactivateDialog();
2834 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2836 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2840 case SMESHOp::OpExtrusionAlongAPath:
2842 if (isStudyLocked()) break;
2844 EmitSignalDeactivateDialog();
2845 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2847 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2851 case SMESHOp::OpRevolution:
2853 if(isStudyLocked()) break;
2855 EmitSignalDeactivateDialog();
2856 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2859 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2863 case SMESHOp::OpPatternMapping:
2865 if ( isStudyLocked() )
2869 EmitSignalDeactivateDialog();
2870 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2873 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2877 case SMESHOp::OpSplitBiQuadratic:
2878 case SMESHOp::OpConvertMeshToQuadratic:
2879 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2880 case SMESHOp::OpReorientFaces:
2881 case SMESHOp::OpCreateGeometryGroup:
2883 startOperation( theCommandID );
2886 case SMESHOp::OpCreateGroup:
2890 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2894 if(isStudyLocked()) break;
2895 EmitSignalDeactivateDialog();
2896 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2898 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2899 SALOME_ListIO selected;
2901 aSel->selectedObjects( selected );
2903 int nbSel = selected.Extent();
2905 // check if mesh is selected
2906 aMesh = SMESH::GetMeshByIO( selected.First() );
2908 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2913 case SMESHOp::OpConstructGroup:
2917 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2921 if(isStudyLocked()) break;
2922 EmitSignalDeactivateDialog();
2924 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2925 SALOME_ListIO selected;
2927 aSel->selectedObjects( selected );
2929 int nbSel = selected.Extent();
2931 // check if submesh is selected
2932 Handle(SALOME_InteractiveObject) IObject = selected.First();
2933 if (IObject->hasEntry()) {
2934 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
2936 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2937 if (!aSubMesh->_is_nil()) {
2939 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2940 // get submesh elements list by types
2941 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2942 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2943 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2944 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2945 // create group for each type o elements
2946 QString aName = IObject->getName();
2947 QStringList anEntryList;
2948 if (aNodes->length() > 0) {
2949 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2950 aGroup->Add(aNodes.inout());
2951 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2952 anEntryList.append( aSObject->GetID().c_str() );
2954 if (aEdges->length() > 0) {
2955 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2956 aGroup->Add(aEdges.inout());
2957 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2958 anEntryList.append( aSObject->GetID().c_str() );
2960 if (aFaces->length() > 0) {
2961 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2962 aGroup->Add(aFaces.inout());
2963 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2964 anEntryList.append( aSObject->GetID().c_str() );
2966 if (aVolumes->length() > 0) {
2967 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2968 aGroup->Add(aVolumes.inout());
2969 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2970 anEntryList.append( aSObject->GetID().c_str() );
2973 anApp->browseObjects( anEntryList );
2975 catch(const SALOME::SALOME_Exception & S_ex){
2976 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2983 SUIT_MessageBox::warning(desktop(),
2984 tr("SMESH_WRN_WARNING"),
2985 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2990 case SMESHOp::OpEditGroup:
2994 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2998 if(isStudyLocked()) break;
2999 EmitSignalDeactivateDialog();
3001 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3002 SALOME_ListIO selected;
3004 aSel->selectedObjects( selected );
3006 SALOME_ListIteratorOfListIO It (selected);
3007 int nbSelectedGroups = 0;
3008 for ( ; It.More(); It.Next() )
3010 SMESH::SMESH_GroupBase_var aGroup =
3011 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3012 if (!aGroup->_is_nil()) {
3014 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3018 if (nbSelectedGroups == 0)
3020 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3026 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3028 if(isStudyLocked()) break;
3029 if (myState == 800) {
3030 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3031 if (aDlg) aDlg->onAdd();
3036 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3038 if(isStudyLocked()) break;
3039 if (myState == 800) {
3040 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3041 if (aDlg) aDlg->onRemove();
3046 case SMESHOp::OpEditGeomGroupAsGroup:
3050 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3054 if(isStudyLocked()) break;
3055 EmitSignalDeactivateDialog();
3057 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3058 SALOME_ListIO selected;
3060 aSel->selectedObjects( selected );
3062 SALOME_ListIteratorOfListIO It (selected);
3063 for ( ; It.More(); It.Next() )
3065 SMESH::SMESH_GroupOnGeom_var aGroup =
3066 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3067 if (!aGroup->_is_nil()) {
3068 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3073 SMESH::SMESH_GroupOnFilter_var aGroup =
3074 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3075 if (!aGroup->_is_nil()) {
3076 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3084 case SMESHOp::OpUnionGroups:
3085 case SMESHOp::OpIntersectGroups:
3086 case SMESHOp::OpCutGroups:
3090 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3094 if ( isStudyLocked() )
3097 EmitSignalDeactivateDialog();
3099 SMESHGUI_GroupOpDlg* aDlg = 0;
3100 if ( theCommandID == SMESHOp::OpUnionGroups )
3101 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3102 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3103 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3105 aDlg = new SMESHGUI_CutGroupsDlg( this );
3112 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3114 if ( isStudyLocked() )
3117 EmitSignalDeactivateDialog();
3118 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3124 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3128 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3132 if ( isStudyLocked() )
3135 EmitSignalDeactivateDialog();
3137 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3141 case SMESHOp::OpMeshInformation:
3142 case SMESHOp::OpWhatIs:
3144 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3145 EmitSignalDeactivateDialog();
3146 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3147 SALOME_ListIO selected;
3149 aSel->selectedObjects( selected );
3151 if ( selected.Extent() > 1 ) { // a dlg for each IO
3152 SALOME_ListIteratorOfListIO It( selected );
3153 for ( ; It.More(); It.Next() ) {
3154 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3155 dlg->showInfo( It.Value() );
3160 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3166 case SMESHOp::OpFindElementByPoint:
3168 startOperation( theCommandID );
3172 case SMESHOp::OpEditHypothesis:
3174 if(isStudyLocked()) break;
3176 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3177 SALOME_ListIO selected;
3179 aSel->selectedObjects( selected );
3181 int nbSel = selected.Extent();
3184 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3185 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3187 if ( !aHypothesis->_is_nil() )
3189 SMESHGUI_GenericHypothesisCreator* aCreator =
3190 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3193 // set geometry of mesh and sub-mesh to aCreator
3194 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3195 if ( selected.Extent() == 1 )
3197 QString subGeomID, meshGeomID;
3198 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3199 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3201 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3202 aCreator->setShapeEntry( subGeomID );
3203 aCreator->setMainShapeEntry( meshGeomID );
3207 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3217 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3219 if(isStudyLocked()) break;
3220 SUIT_OverrideCursor wc;
3222 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3223 SALOME_ListIO selected;
3225 aSel->selectedObjects( selected, QString::null, false );
3227 SALOME_ListIteratorOfListIO It(selected);
3228 for (int i = 0; It.More(); It.Next(), i++) {
3229 Handle(SALOME_InteractiveObject) IObject = It.Value();
3230 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3233 aSel->setSelectedObjects( l1 );
3238 case SMESHOp::OpElem0D:
3239 case SMESHOp::OpBall:
3240 case SMESHOp::OpEdge:
3241 case SMESHOp::OpTriangle:
3242 case SMESHOp::OpQuadrangle:
3243 case SMESHOp::OpPolygon:
3244 case SMESHOp::OpTetrahedron:
3245 case SMESHOp::OpHexahedron:
3246 case SMESHOp::OpPentahedron:
3247 case SMESHOp::OpPyramid:
3248 case SMESHOp::OpHexagonalPrism:
3250 if(isStudyLocked()) break;
3252 EmitSignalDeactivateDialog();
3253 SMDSAbs_EntityType type = SMDSEntity_Edge;
3254 switch (theCommandID) {
3255 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3256 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3257 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3258 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3259 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3260 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3261 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3262 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3263 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3264 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3267 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3270 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3274 case SMESHOp::OpPolyhedron:
3276 if(isStudyLocked()) break;
3278 EmitSignalDeactivateDialog();
3279 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3282 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3286 case SMESHOp::OpQuadraticEdge:
3287 case SMESHOp::OpQuadraticTriangle:
3288 case SMESHOp::OpBiQuadraticTriangle:
3289 case SMESHOp::OpQuadraticQuadrangle:
3290 case SMESHOp::OpBiQuadraticQuadrangle:
3291 case SMESHOp::OpQuadraticPolygon:
3292 case SMESHOp::OpQuadraticTetrahedron:
3293 case SMESHOp::OpQuadraticPyramid:
3294 case SMESHOp::OpQuadraticPentahedron:
3295 case SMESHOp::OpBiQuadraticPentahedron:
3296 case SMESHOp::OpQuadraticHexahedron:
3297 case SMESHOp::OpTriQuadraticHexahedron:
3299 if(isStudyLocked()) break;
3301 EmitSignalDeactivateDialog();
3302 SMDSAbs_EntityType type = SMDSEntity_Last;
3304 switch (theCommandID) {
3305 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3306 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3307 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3308 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3309 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3310 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3311 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3312 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3313 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3314 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3315 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3316 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3319 if ( type != SMDSEntity_Last )
3320 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3323 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3324 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3328 case SMESHOp::OpRemoveNodes:
3330 if(isStudyLocked()) break;
3332 EmitSignalDeactivateDialog();
3333 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3336 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3337 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3341 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3343 if(isStudyLocked()) break;
3345 EmitSignalDeactivateDialog();
3346 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3350 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3351 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3355 case SMESHOp::OpClearMesh: {
3357 if(isStudyLocked()) break;
3359 SALOME_ListIO selected;
3360 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3361 aSel->selectedObjects( selected );
3363 SUIT_OverrideCursor wc;
3364 SALOME_ListIteratorOfListIO It (selected);
3365 for ( ; It.More(); It.Next() )
3367 Handle(SALOME_InteractiveObject) IOS = It.Value();
3368 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3369 if ( aMesh->_is_nil()) continue;
3372 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3373 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3374 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3375 // hide groups and submeshes
3376 _PTR(ChildIterator) anIter =
3377 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3378 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3380 _PTR(SObject) so = anIter->Value();
3381 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3384 catch (const SALOME::SALOME_Exception& S_ex){
3386 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3390 SMESH::UpdateView();
3394 case SMESHOp::OpRemoveOrphanNodes:
3396 if(isStudyLocked()) break;
3397 SALOME_ListIO selected;
3398 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3399 aSel->selectedObjects( selected );
3400 if ( selected.Extent() == 1 ) {
3401 Handle(SALOME_InteractiveObject) anIO = selected.First();
3402 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3403 if ( !aMesh->_is_nil() ) {
3404 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3405 tr( "SMESH_WARNING" ),
3406 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3407 SUIT_MessageBox::Yes |
3408 SUIT_MessageBox::No,
3409 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3412 SUIT_OverrideCursor wc;
3413 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3414 int removed = aMeshEditor->RemoveOrphanNodes();
3415 SUIT_MessageBox::information(SMESHGUI::desktop(),
3416 tr("SMESH_INFORMATION"),
3417 tr("NB_NODES_REMOVED").arg(removed));
3418 if ( removed > 0 ) {
3419 SMESH::UpdateView();
3420 SMESHGUI::Modified();
3423 catch (const SALOME::SALOME_Exception& S_ex) {
3424 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3433 case SMESHOp::OpRenumberingNodes:
3435 if(isStudyLocked()) break;
3437 EmitSignalDeactivateDialog();
3438 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3442 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3443 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3447 case SMESHOp::OpRenumberingElements:
3449 if(isStudyLocked()) break;
3451 EmitSignalDeactivateDialog();
3452 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3456 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3457 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3461 case SMESHOp::OpTranslation:
3463 if(isStudyLocked()) break;
3465 EmitSignalDeactivateDialog();
3466 ( new SMESHGUI_TranslationDlg( this ) )->show();
3469 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3470 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3474 case SMESHOp::OpRotation:
3476 if(isStudyLocked()) break;
3478 EmitSignalDeactivateDialog();
3479 ( new SMESHGUI_RotationDlg( this ) )->show();
3482 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3483 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3487 case SMESHOp::OpSymmetry:
3489 if(isStudyLocked()) break;
3491 EmitSignalDeactivateDialog();
3492 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3495 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3496 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3500 case SMESHOp::OpScale:
3502 if(isStudyLocked()) break;
3504 EmitSignalDeactivateDialog();
3505 ( new SMESHGUI_ScaleDlg( this ) )->show();
3508 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3509 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3514 case SMESHOp::OpOffset:
3516 if(isStudyLocked()) break;
3518 EmitSignalDeactivateDialog();
3519 ( new SMESHGUI_OffsetDlg( this ) )->show();
3522 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3523 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3528 case SMESHOp::OpSewing:
3530 if(isStudyLocked()) break;
3532 EmitSignalDeactivateDialog();
3533 ( new SMESHGUI_SewingDlg( this ) )->show();
3536 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3537 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3541 case SMESHOp::OpMergeNodes:
3543 if(isStudyLocked()) break;
3545 EmitSignalDeactivateDialog();
3546 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3549 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3550 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3554 case SMESHOp::OpMergeElements:
3556 if (isStudyLocked()) break;
3558 EmitSignalDeactivateDialog();
3559 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3561 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3562 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3567 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3568 startOperation( SMESHOp::OpMoveNode );
3571 case SMESHOp::OpDuplicateNodes:
3573 if(isStudyLocked()) break;
3575 EmitSignalDeactivateDialog();
3576 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3579 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3580 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3585 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3586 startOperation( SMESHOp::OpElem0DOnElemNodes );
3589 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3591 static QList<int> aTypes;
3592 if ( aTypes.isEmpty() )
3594 aTypes.append( SMESH::NODE );
3595 aTypes.append( SMESH::EDGE );
3596 aTypes.append( SMESH::FACE );
3597 aTypes.append( SMESH::VOLUME );
3599 if (!myFilterLibraryDlg)
3600 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3601 else if (myFilterLibraryDlg->isHidden())
3602 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3603 myFilterLibraryDlg->raise();
3607 case SMESHOp::OpFreeNode:
3608 case SMESHOp::OpEqualNode:
3609 case SMESHOp::OpNodeConnectivityNb:
3610 case SMESHOp::OpFreeEdge:
3611 case SMESHOp::OpFreeBorder:
3612 case SMESHOp::OpLength:
3613 case SMESHOp::OpConnection:
3614 case SMESHOp::OpEqualEdge:
3615 case SMESHOp::OpFreeFace:
3616 case SMESHOp::OpBareBorderFace:
3617 case SMESHOp::OpOverConstrainedFace:
3618 case SMESHOp::OpLength2D:
3619 case SMESHOp::OpDeflection2D:
3620 case SMESHOp::OpConnection2D:
3621 case SMESHOp::OpArea:
3622 case SMESHOp::OpTaper:
3623 case SMESHOp::OpAspectRatio:
3624 case SMESHOp::OpMinimumAngle:
3625 case SMESHOp::OpWarpingAngle:
3626 case SMESHOp::OpSkew:
3627 case SMESHOp::OpMaxElementLength2D:
3628 case SMESHOp::OpEqualFace:
3629 case SMESHOp::OpAspectRatio3D:
3630 case SMESHOp::OpVolume:
3631 case SMESHOp::OpMaxElementLength3D:
3632 case SMESHOp::OpBareBorderVolume:
3633 case SMESHOp::OpOverConstrainedVolume:
3634 case SMESHOp::OpEqualVolume:
3637 LightApp_SelectionMgr* mgr = selectionMgr();
3638 SALOME_ListIO selected; mgr->selectedObjects( selected );
3640 if( !selected.IsEmpty() ) {
3641 SUIT_OverrideCursor wc;
3642 ::Control( theCommandID );
3645 SUIT_MessageBox::warning(desktop(),
3646 tr( "SMESH_WRN_WARNING" ),
3647 tr( "SMESH_BAD_SELECTION" ) );
3651 SUIT_MessageBox::warning(desktop(),
3652 tr( "SMESH_WRN_WARNING" ),
3653 tr( "NOT_A_VTK_VIEWER" ) );
3656 case SMESHOp::OpOverallMeshQuality:
3657 OverallMeshQuality();
3659 case SMESHOp::OpNumberingNodes:
3661 SUIT_OverrideCursor wc;
3662 LightApp_SelectionMgr* mgr = selectionMgr();
3663 SALOME_ListIO selected; mgr->selectedObjects( selected );
3665 SALOME_ListIteratorOfListIO it(selected);
3666 for( ; it.More(); it.Next()) {
3667 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3668 if(anIObject->hasEntry()) {
3669 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3670 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3676 case SMESHOp::OpNumberingElements:
3678 SUIT_OverrideCursor wc;
3679 LightApp_SelectionMgr* mgr = selectionMgr();
3680 SALOME_ListIO selected; mgr->selectedObjects( selected );
3682 SALOME_ListIteratorOfListIO it(selected);
3683 for( ; it.More(); it.Next()) {
3684 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3685 if(anIObject->hasEntry())
3686 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3687 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3692 case SMESHOp::OpPropertiesLength:
3693 case SMESHOp::OpPropertiesArea:
3694 case SMESHOp::OpPropertiesVolume:
3695 case SMESHOp::OpMinimumDistance:
3696 case SMESHOp::OpBoundingBox:
3698 int page = SMESHGUI_MeasureDlg::MinDistance;
3699 if ( theCommandID == SMESHOp::OpBoundingBox )
3700 page = SMESHGUI_MeasureDlg::BoundingBox;
3701 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3702 page = SMESHGUI_MeasureDlg::Length;
3703 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3704 page = SMESHGUI_MeasureDlg::Area;
3705 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3706 page = SMESHGUI_MeasureDlg::Volume;
3708 EmitSignalDeactivateDialog();
3709 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3713 case SMESHOp::OpSortChild:
3719 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3720 //updateObjBrowser();
3724 //=============================================================================
3728 //=============================================================================
3729 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3734 //=============================================================================
3738 //=============================================================================
3739 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3744 //=============================================================================
3748 //=============================================================================
3749 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3754 //=============================================================================
3755 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3756 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3758 //=============================================================================
3759 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3760 SUIT_ViewWindow* wnd )
3762 if(theIO->hasEntry()){
3763 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3764 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3768 //=======================================================================
3769 // function : createSMESHAction
3771 //=======================================================================
3772 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3773 const int key, const bool toggle, const QString& shortcutAction )
3776 QWidget* parent = application()->desktop();
3777 SUIT_ResourceMgr* resMgr = resourceMgr();
3779 if ( !icon_id.isEmpty() )
3780 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3782 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3783 if ( !pix.isNull() )
3784 icon = QIcon( pix );
3786 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3787 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3788 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3790 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3791 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3794 //=======================================================================
3795 // function : createPopupItem
3797 //=======================================================================
3798 void SMESHGUI::createPopupItem( const int id,
3799 const QString& clients,
3800 const QString& types,
3801 const QString& theRule,
3804 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3805 popupMgr()->insert( action( id ), pId, 0 );
3807 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3808 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3809 QString rule = "(%1) and (%2) and (%3)";
3810 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3811 if( clients.isEmpty() )
3812 rule = rule.arg( QString( "true" ) );
3814 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3815 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3818 bool cont = myRules.contains( id );
3820 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3822 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3823 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3826 //=======================================================================
3827 // function : initialize
3829 //=======================================================================
3830 void SMESHGUI::initialize( CAM_Application* app )
3832 SalomeApp_Module::initialize( app );
3834 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3836 /* Automatic Update flag */
3837 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3839 // ----- create actions --------------
3841 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3842 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3843 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3844 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3846 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3848 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3849 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3850 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3851 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3852 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3854 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3856 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3857 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3859 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3860 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3861 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3862 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3864 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3866 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3867 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3868 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3869 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3870 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3871 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3873 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3875 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3876 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3877 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3878 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3879 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3880 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3881 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3882 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3883 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3884 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3885 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3886 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3887 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3888 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3889 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3890 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3891 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3892 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3893 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3894 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3895 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3896 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3897 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3898 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3899 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3900 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3901 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3902 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3903 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3904 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3905 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3906 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3907 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3909 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3910 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3911 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3912 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3913 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3914 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3915 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3916 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3917 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3918 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3919 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3920 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3921 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
3922 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3923 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3924 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3925 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3926 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3927 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3928 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3929 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3930 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3931 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3932 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3933 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3934 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3935 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3936 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3937 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3939 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3940 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3941 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3942 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3943 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3944 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3945 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3946 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3947 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3948 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3949 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3950 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3951 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3952 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3953 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3954 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3955 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3956 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3957 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3958 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3959 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3960 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3961 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3962 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
3963 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3964 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3966 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3967 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3968 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3969 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3971 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3972 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3974 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3975 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3976 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3977 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3978 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
3979 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3980 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3981 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3982 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3983 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3984 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3985 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3986 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3987 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3988 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3989 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3990 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3991 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3992 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3993 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3994 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3995 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3996 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3997 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3998 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4000 createSMESHAction( SMESHOp::OpReset, "RESET" );
4001 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4002 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4003 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4004 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4005 #ifndef DISABLE_PLOT2DVIEWER
4006 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4008 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4009 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4010 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4011 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4012 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4013 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4014 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4015 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4016 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4017 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4018 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4019 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4020 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4022 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4023 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4025 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4026 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4027 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4028 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4029 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4030 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4031 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4032 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4033 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4035 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4036 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4037 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4038 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4039 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4041 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4042 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4043 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4045 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4047 QList<int> aCtrlActions;
4048 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4049 << SMESHOp::OpNodeConnectivityNb // node controls
4050 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4051 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4052 << SMESHOp::OpDeflection2D
4053 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4054 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4055 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4056 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4057 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4058 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4059 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4060 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4061 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4062 aCtrlGroup->setExclusive( true );
4063 for( int i = 0; i < aCtrlActions.size(); i++ )
4064 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4066 // ----- create menu --------------
4067 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4068 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4069 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4070 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4071 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4072 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4073 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4074 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4076 createMenu( separator(), fileId );
4078 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4079 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4080 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4081 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4082 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4083 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4084 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4085 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4086 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4087 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4088 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4089 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4090 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4092 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4093 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4094 createMenu( SMESHOp::OpImportMED, importId, -1 );
4095 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4097 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4099 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4100 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4101 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4102 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4103 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4104 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4106 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4108 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4109 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4110 createMenu( separator(), fileId, 10 );
4112 createMenu( SMESHOp::OpDelete, editId, -1 );
4114 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4116 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4117 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4118 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4119 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4120 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4121 createMenu( separator(), meshId, -1 );
4122 createMenu( SMESHOp::OpCompute, meshId, -1 );
4123 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4124 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4125 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4126 createMenu( separator(), meshId, -1 );
4127 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4128 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4129 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4130 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4131 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4132 createMenu( separator(), meshId, -1 );
4133 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4134 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4135 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4136 createMenu( separator(), meshId, -1 );
4137 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4138 createMenu( separator(), meshId, -1 );
4139 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4140 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4141 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4142 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4143 createMenu( separator(), meshId, -1 );
4145 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4146 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4147 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4148 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4149 createMenu( SMESHOp::OpLength, edgeId, -1 );
4150 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4151 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4152 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4153 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4154 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4155 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4156 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4157 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4158 createMenu( SMESHOp::OpArea, faceId, -1 );
4159 createMenu( SMESHOp::OpTaper, faceId, -1 );
4160 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4161 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4162 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4163 createMenu( SMESHOp::OpSkew, faceId, -1 );
4164 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4165 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4166 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4167 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4168 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4169 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4170 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4171 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4172 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4173 createMenu( separator(), ctrlId, -1 );
4174 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4175 createMenu( separator(), ctrlId, -1 );
4176 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4178 createMenu( SMESHOp::OpNode, addId, -1 );
4179 createMenu( SMESHOp::OpElem0D, addId, -1 );
4180 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4181 createMenu( SMESHOp::OpBall, addId, -1 );
4182 createMenu( SMESHOp::OpEdge, addId, -1 );
4183 createMenu( SMESHOp::OpTriangle, addId, -1 );
4184 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4185 createMenu( SMESHOp::OpPolygon, addId, -1 );
4186 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4187 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4188 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4189 createMenu( SMESHOp::OpPyramid, addId, -1 );
4190 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4191 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4192 createMenu( separator(), addId, -1 );
4193 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4194 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4195 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4196 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4197 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4198 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4199 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4200 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4201 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4202 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4203 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4204 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4206 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4207 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4208 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4209 createMenu( separator(), removeId, -1 );
4210 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4211 createMenu( separator(), removeId, -1 );
4212 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4214 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4215 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4217 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4218 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4219 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4220 createMenu( SMESHOp::OpRotation, transfId, -1 );
4221 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4222 createMenu( SMESHOp::OpScale, transfId, -1 );
4223 createMenu( SMESHOp::OpOffset, transfId, -1 );
4224 createMenu( SMESHOp::OpSewing, transfId, -1 );
4225 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4227 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4228 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4229 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4230 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4231 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4232 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4233 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4234 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4235 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4236 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4237 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4238 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4239 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4240 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4241 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4242 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4244 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4245 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4246 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4247 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4248 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4249 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4251 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4252 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4253 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4254 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4256 // ----- create toolbars --------------
4257 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4258 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4259 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4260 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4261 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4262 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4263 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4264 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4265 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4266 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4267 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4268 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4269 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4270 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4271 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4273 createTool( SMESHOp::OpCreateMesh, meshTb );
4274 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4275 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4276 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4277 createTool( SMESHOp::OpCopyMesh, meshTb );
4278 createTool( separator(), meshTb );
4279 createTool( SMESHOp::OpCompute, meshTb );
4280 createTool( SMESHOp::OpPreCompute, meshTb );
4281 createTool( SMESHOp::OpEvaluate, meshTb );
4282 createTool( SMESHOp::OpMeshOrder, meshTb );
4284 createTool( SMESHOp::OpCreateGroup, groupTb );
4285 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4286 createTool( SMESHOp::OpConstructGroup, groupTb );
4287 createTool( SMESHOp::OpEditGroup, groupTb );
4289 createTool( SMESHOp::OpMeshInformation, info );
4290 //createTool( SMESHOp::OpStdInfo, meshTb );
4291 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4292 createTool( SMESHOp::OpFindElementByPoint, info );
4294 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4295 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4296 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4298 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4299 createTool( SMESHOp::OpLength, ctrl1dTb );
4300 createTool( SMESHOp::OpConnection, ctrl1dTb );
4301 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4303 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4304 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4305 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4306 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4307 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4308 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4309 createTool( SMESHOp::OpArea, ctrl2dTb );
4310 createTool( SMESHOp::OpTaper, ctrl2dTb );
4311 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4312 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4313 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4314 createTool( SMESHOp::OpSkew, ctrl2dTb );
4315 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4316 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4317 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4319 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4320 createTool( SMESHOp::OpVolume, ctrl3dTb );
4321 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4322 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4323 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4324 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4326 createTool( SMESHOp::OpNode, addElemTb );
4327 createTool( SMESHOp::OpElem0D, addElemTb );
4328 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4329 createTool( SMESHOp::OpBall, addElemTb );
4330 createTool( SMESHOp::OpEdge, addElemTb );
4331 createTool( SMESHOp::OpTriangle, addElemTb );
4332 createTool( SMESHOp::OpQuadrangle, addElemTb );
4333 createTool( SMESHOp::OpPolygon, addElemTb );
4334 createTool( SMESHOp::OpTetrahedron, addElemTb );
4335 createTool( SMESHOp::OpHexahedron, addElemTb );
4336 createTool( SMESHOp::OpPentahedron, addElemTb );
4337 createTool( SMESHOp::OpPyramid, addElemTb );
4338 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4339 createTool( SMESHOp::OpPolyhedron, addElemTb );
4341 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4342 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4343 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4344 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4345 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4346 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4347 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4348 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4349 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4350 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4351 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4352 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4354 createTool( SMESHOp::OpRemoveNodes, remTb );
4355 createTool( SMESHOp::OpRemoveElements, remTb );
4356 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4357 createTool( SMESHOp::OpClearMesh, remTb );
4359 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4360 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4362 createTool( SMESHOp::OpMergeNodes, transformTb );
4363 createTool( SMESHOp::OpMergeElements, transformTb );
4364 createTool( SMESHOp::OpTranslation, transformTb );
4365 createTool( SMESHOp::OpRotation, transformTb );
4366 createTool( SMESHOp::OpSymmetry, transformTb );
4367 createTool( SMESHOp::OpScale, transformTb );
4368 createTool( SMESHOp::OpOffset, transformTb );
4369 createTool( SMESHOp::OpSewing, transformTb );
4370 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4372 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4373 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4374 createTool( SMESHOp::OpExtrusion, modifyTb );
4375 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4376 createTool( SMESHOp::OpRevolution, modifyTb );
4377 createTool( SMESHOp::OpOrientation, modifyTb );
4378 createTool( SMESHOp::OpReorientFaces, modifyTb );
4379 createTool( SMESHOp::OpMoveNode, modifyTb );
4380 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4381 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4382 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4383 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4384 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4385 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4386 createTool( SMESHOp::OpSmoothing, modifyTb );
4387 createTool( SMESHOp::OpPatternMapping, modifyTb );
4389 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4391 createTool( SMESHOp::OpUpdate, dispModeTb );
4393 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4394 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4398 OB = "'ObjectBrowser'",
4399 View = "'" + SVTK_Viewer::Type() + "'",
4401 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4402 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4403 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4404 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4405 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4406 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4407 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4408 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4409 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4410 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4411 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4412 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4414 mesh_part = mesh + " " + subMesh + " " + group,
4415 mesh_group = mesh + " " + group,
4416 mesh_submesh = mesh + " " + subMesh,
4417 hyp_alg = hypo + " " + algo;
4419 // popup for object browser
4421 isInvisible("not( isVisible )"),
4422 isEmpty("numberOfNodes = 0"),
4423 isNotEmpty("numberOfNodes <> 0"),
4425 // has nodes, edges, etc in VISIBLE! actor
4426 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4427 hasElems("(count( elemTypes ) > 0)"),
4428 hasDifferentElems("(count( elemTypes ) > 1)"),
4429 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4430 hasBalls("({'BallElem'} in elemTypes)"),
4431 hasElems0d("({'Elem0d'} in elemTypes)"),
4432 hasEdges("({'Edge'} in elemTypes)"),
4433 hasFaces("({'Face'} in elemTypes)"),
4434 hasVolumes("({'Volume'} in elemTypes)"),
4435 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4437 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4438 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4439 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4440 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4441 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4442 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4444 popupMgr()->insert( separator(), -1, 0 );
4445 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4446 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4447 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4448 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4449 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4450 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4451 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4452 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4453 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4454 popupMgr()->insert( separator(), -1, 0 );
4455 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4456 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4457 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4458 popupMgr()->insert( separator(), -1, 0 );
4459 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4460 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4461 popupMgr()->insert( separator(), -1, 0 );
4462 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4463 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4464 popupMgr()->insert( separator(), -1, 0 );
4465 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4466 //popupMgr()->insert( separator(), -1, 0 );
4468 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4469 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4470 QString only_one_2D = only_one_non_empty + " && dim>1";
4472 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4473 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4474 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4475 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4477 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4479 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4480 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4481 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4482 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4483 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4485 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4486 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4487 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4488 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4490 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4492 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4493 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4494 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4495 popupMgr()->insert( separator(), -1, 0 );
4498 createPopupItem( SMESHOp::OpEditGroup, View, group );
4499 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4500 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4502 popupMgr()->insert( separator(), -1, 0 );
4503 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4504 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4505 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4506 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4507 popupMgr()->insert( separator(), -1, 0 );
4509 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4510 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4511 popupMgr()->insert( separator(), -1, 0 );
4513 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4514 QString aType = QString( "%1type in {%2}" ).arg( lc );
4515 aType = aType.arg( mesh_part );
4516 QString aMeshInVTK = aClient + "&&" + aType;
4518 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4519 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4520 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4522 //-------------------------------------------------
4524 //-------------------------------------------------
4525 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4527 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4528 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4529 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4531 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4532 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4533 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4535 popupMgr()->insert( separator(), -1, -1 );
4537 //-------------------------------------------------
4539 //-------------------------------------------------
4540 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4542 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4543 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4544 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4546 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4547 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4548 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4550 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4551 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4552 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4554 popupMgr()->insert( separator(), anId, -1 );
4556 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4557 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4558 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4560 //-------------------------------------------------
4562 //-------------------------------------------------
4563 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4565 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4567 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4568 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4569 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4571 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4572 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4573 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4575 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4576 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4577 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4579 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4580 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4581 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4583 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4584 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4585 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4587 popupMgr()->insert( separator(), anId, -1 );
4589 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4590 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4592 popupMgr()->insert( separator(), anId, -1 );
4594 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4595 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4598 //-------------------------------------------------
4599 // Representation of the 2D Quadratic elements
4600 //-------------------------------------------------
4601 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4602 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4603 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4604 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4606 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4607 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4608 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4610 //-------------------------------------------------
4611 // Orientation of faces
4612 //-------------------------------------------------
4613 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4614 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4615 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4617 //-------------------------------------------------
4619 //-------------------------------------------------
4620 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4621 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4623 //-------------------------------------------------
4625 //-------------------------------------------------
4626 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4627 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4629 //-------------------------------------------------
4631 //-------------------------------------------------
4633 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4634 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4635 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4636 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4638 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4640 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4641 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4643 popupMgr()->insert( separator(), anId, -1 );
4645 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4647 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4648 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4649 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4651 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4652 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4653 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4655 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4656 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4657 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4659 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4661 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4662 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4663 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4665 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4666 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4667 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4669 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4670 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4671 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4672 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4673 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4674 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4676 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4678 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4679 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4680 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4682 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4683 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4684 QtxPopupMgr::VisibleRule );
4685 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4687 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4688 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4689 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4691 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4692 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4693 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4695 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4696 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4697 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4699 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4700 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4701 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4703 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4704 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4705 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4707 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4708 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4709 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4711 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4712 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4713 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4715 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4716 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4717 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4719 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4720 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4721 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4723 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4724 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4725 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4727 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4728 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4729 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4731 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4732 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4733 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4735 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4736 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4737 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4739 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4741 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4742 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4743 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4745 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4746 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4747 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4749 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4750 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4751 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4753 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4754 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4755 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4757 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4758 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4759 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4761 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4762 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4763 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4765 popupMgr()->insert( separator(), anId, -1 );
4767 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4768 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4769 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4770 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4771 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4773 popupMgr()->insert( separator(), anId, -1 );
4775 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4777 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4778 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4780 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4781 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4782 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4784 #ifndef DISABLE_PLOT2DVIEWER
4785 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4786 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4789 //-------------------------------------------------
4791 //-------------------------------------------------
4792 popupMgr()->insert( separator(), -1, -1 );
4793 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4794 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4795 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4796 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4798 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4799 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4801 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4802 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4804 popupMgr()->insert( separator(), -1, -1 );
4806 //-------------------------------------------------
4808 //-------------------------------------------------
4809 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4810 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4812 popupMgr()->insert( separator(), -1, -1 );
4814 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4815 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4816 popupMgr()->insert( separator(), -1, -1 );
4818 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4819 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4821 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4822 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4825 //================================================================================
4827 * \brief Return true if SMESH or GEOM objects are selected.
4828 * Is called form LightApp_Module::activateModule() which clear selection if
4829 * not isSelectionCompatible()
4831 //================================================================================
4833 bool SMESHGUI::isSelectionCompatible()
4835 bool isCompatible = true;
4836 SALOME_ListIO selected;
4837 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4838 Sel->selectedObjects( selected );
4840 SALOME_ListIteratorOfListIO It( selected );
4841 for ( ; isCompatible && It.More(); It.Next())
4843 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4844 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4846 return isCompatible;
4850 bool SMESHGUI::reusableOperation( const int id )
4852 // compute, evaluate and precompute are not reusable operations
4853 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4856 bool SMESHGUI::activateModule( SUIT_Study* study )
4858 bool res = SalomeApp_Module::activateModule( study );
4860 setMenuShown( true );
4861 setToolShown( true );
4863 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4864 PyGILState_STATE gstate = PyGILState_Ensure();
4865 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4866 if ( !pluginsmanager ) {
4870 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4875 PyGILState_Release(gstate);
4876 // end of SMESH plugins loading
4878 // Reset actions accelerator keys
4879 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4881 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4882 GetSMESHGen()->UpdateStudy();
4884 // get all view currently opened in the study and connect their signals to
4885 // the corresponding slots of the class.
4886 SUIT_Desktop* aDesk = study->application()->desktop();
4888 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4889 SUIT_ViewWindow* wnd;
4890 foreach ( wnd, wndList )
4894 Py_XDECREF(pluginsmanager);
4898 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4900 setMenuShown( false );
4901 setToolShown( false );
4903 EmitSignalCloseAllDialogs();
4905 // Unset actions accelerator keys
4906 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4908 return SalomeApp_Module::deactivateModule( study );
4911 void SMESHGUI::studyClosed( SUIT_Study* s )
4915 SMESH::RemoveVisuData();
4916 SalomeApp_Module::studyClosed( s );
4919 void SMESHGUI::OnGUIEvent()
4921 const QObject* obj = sender();
4922 if ( !obj || !obj->inherits( "QAction" ) )
4924 int id = actionId((QAction*)obj);
4929 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4931 if ( CORBA::is_nil( myComponentSMESH ) )
4933 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4934 return aGUI.myComponentSMESH;
4936 return myComponentSMESH;
4939 QString SMESHGUI::engineIOR() const
4941 CORBA::ORB_var anORB = getApp()->orb();
4942 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4943 return QString( anIOR.in() );
4946 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4948 SalomeApp_Module::contextMenuPopup( client, menu, title );
4950 selectionMgr()->selectedObjects( lst );
4951 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4952 Handle(SALOME_InteractiveObject) io = lst.First();
4953 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4954 _PTR(Study) study = appStudy->studyDS();
4955 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4957 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4958 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4959 aName.remove( (aName.length() - 1), 1 );
4965 LightApp_Selection* SMESHGUI::createSelection() const
4967 return new SMESHGUI_Selection();
4970 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4972 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4973 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4974 #ifndef DISABLE_PYCONSOLE
4975 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4979 void SMESHGUI::viewManagers( QStringList& list ) const
4981 list.append( SVTK_Viewer::Type() );
4984 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4986 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4987 SMESH::UpdateSelectionProp( this );
4989 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4990 for(int i = 0; i < aViews.count() ; i++){
4991 SUIT_ViewWindow *sf = aViews[i];
4994 EmitSignalActivatedViewManager();
4998 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5000 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5001 myClippingPlaneInfoMap.erase( theViewManager );
5004 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5006 theActor->AddObserver( SMESH::DeleteActorEvent,
5007 myEventCallbackCommand.GetPointer(),
5011 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5012 unsigned long theEvent,
5013 void* theClientData,
5016 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5017 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5018 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5019 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5020 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5021 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5022 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5023 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5024 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5025 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5026 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5027 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5028 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5029 if( anActor == *anIter3 ) {
5030 anActorList.erase( anIter3 );
5041 void SMESHGUI::createPreferences()
5043 // General tab ------------------------------------------------------------------------
5044 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5046 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5047 setPreferenceProperty( autoUpdate, "columns", 2 );
5048 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5049 setPreferenceProperty( lim, "min", 0 );
5050 setPreferenceProperty( lim, "max", 100000000 );
5051 setPreferenceProperty( lim, "step", 1000 );
5052 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5053 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5055 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5056 setPreferenceProperty( dispgroup, "columns", 2 );
5057 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5059 modes.append( tr("MEN_WIRE") );
5060 modes.append( tr("MEN_SHADE") );
5061 modes.append( tr("MEN_NODES") );
5062 modes.append( tr("MEN_SHRINK") );
5063 QList<QVariant> indices;
5064 indices.append( 0 );
5065 indices.append( 1 );
5066 indices.append( 2 );
5067 indices.append( 3 );
5068 setPreferenceProperty( dispmode, "strings", modes );
5069 setPreferenceProperty( dispmode, "indexes", indices );
5071 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5072 setPreferenceProperty( arcgroup, "columns", 2 );
5073 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5074 QStringList quadraticModes;
5075 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5076 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5078 indices.append( 0 );
5079 indices.append( 1 );
5080 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5081 setPreferenceProperty( quadraticmode, "indexes", indices );
5083 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5084 "SMESH", "max_angle" );
5085 setPreferenceProperty( maxAngle, "min", 1 );
5086 setPreferenceProperty( maxAngle, "max", 90 );
5088 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5089 setPreferenceProperty( qaGroup, "columns", 2 );
5090 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5091 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5092 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5093 setPreferenceProperty( prec, "min", 0 );
5094 setPreferenceProperty( prec, "max", 100 );
5095 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5096 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5097 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5098 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5099 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5102 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5103 setPreferenceProperty( exportgroup, "columns", 2 );
5104 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5105 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5106 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5108 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5109 setPreferenceProperty( computeGroup, "columns", 2 );
5110 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5112 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5113 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5114 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5116 indices.append( 0 );
5117 indices.append( 1 );
5118 indices.append( 2 );
5119 setPreferenceProperty( notifyMode, "strings", modes );
5120 setPreferenceProperty( notifyMode, "indexes", indices );
5122 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5123 setPreferenceProperty( infoGroup, "columns", 2 );
5124 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5126 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5127 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5129 indices.append( 0 );
5130 indices.append( 1 );
5131 setPreferenceProperty( elemInfo, "strings", modes );
5132 setPreferenceProperty( elemInfo, "indexes", indices );
5133 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5134 setPreferenceProperty( nodesLim, "min", 0 );
5135 setPreferenceProperty( nodesLim, "max", 10000000 );
5136 setPreferenceProperty( nodesLim, "step", 10000 );
5137 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5138 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5139 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5140 setPreferenceProperty( ctrlLim, "min", 0 );
5141 setPreferenceProperty( ctrlLim, "max", 10000000 );
5142 setPreferenceProperty( ctrlLim, "step", 1000 );
5143 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5144 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5145 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5146 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5147 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5149 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5150 setPreferenceProperty( segGroup, "columns", 2 );
5151 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5152 "SMESH", "segmentation" );
5153 setPreferenceProperty( segLen, "min", 1 );
5154 setPreferenceProperty( segLen, "max", 10000000 );
5155 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5156 "SMESH", "nb_segments_per_edge" );
5157 setPreferenceProperty( nbSeg, "min", 1 );
5158 setPreferenceProperty( nbSeg, "max", 10000000 );
5160 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5161 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5162 "SMESH", "forget_mesh_on_hyp_modif" );
5165 // Quantities with individual precision settings
5166 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5167 setPreferenceProperty( precGroup, "columns", 2 );
5169 const int nbQuantities = 6;
5170 int precs[nbQuantities], ii = 0;
5171 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5172 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5173 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5174 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5175 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5176 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5177 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5178 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5179 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5180 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5181 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5182 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5184 // Set property for precision value for spinboxes
5185 for ( ii = 0; ii < nbQuantities; ii++ ){
5186 setPreferenceProperty( precs[ii], "min", -14 );
5187 setPreferenceProperty( precs[ii], "max", 14 );
5188 setPreferenceProperty( precs[ii], "precision", 2 );
5191 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5192 setPreferenceProperty( previewGroup, "columns", 2 );
5193 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5194 setPreferenceProperty( chunkSize, "min", 1 );
5195 setPreferenceProperty( chunkSize, "max", 1000 );
5196 setPreferenceProperty( chunkSize, "step", 50 );
5198 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5199 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5201 // Mesh tab ------------------------------------------------------------------------
5202 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5203 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5204 setPreferenceProperty( nodeGroup, "columns", 3 );
5206 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5208 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5210 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5211 QList<QVariant> aMarkerTypeIndicesList;
5212 QList<QVariant> aMarkerTypeIconsList;
5213 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5214 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5215 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5216 aMarkerTypeIndicesList << i;
5217 aMarkerTypeIconsList << pixmap;
5219 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5220 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5222 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5224 QList<QVariant> aMarkerScaleIndicesList;
5225 QStringList aMarkerScaleValuesList;
5226 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5227 aMarkerScaleIndicesList << i;
5228 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5229 aMarkerScaleValuesList << QString::number( i );
5231 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5232 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5234 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5235 //setPreferenceProperty( elemGroup, "columns", 2 );
5237 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5238 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5239 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5240 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5241 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5242 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5243 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5244 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5245 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5248 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5249 setPreferenceProperty( grpGroup, "columns", 2 );
5251 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5252 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5254 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5255 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5256 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5257 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5258 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5259 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5260 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5261 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5262 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5263 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5264 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5265 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5266 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5267 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5269 setPreferenceProperty( size0d, "min", 1 );
5270 setPreferenceProperty( size0d, "max", 10 );
5272 // setPreferenceProperty( ballSize, "min", 1 );
5273 // setPreferenceProperty( ballSize, "max", 10 );
5275 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5276 setPreferenceProperty( ballDiameter, "max", 1e9 );
5277 setPreferenceProperty( ballDiameter, "step", 0.1 );
5279 setPreferenceProperty( ballScale, "min", 1e-2 );
5280 setPreferenceProperty( ballScale, "max", 1e7 );
5281 setPreferenceProperty( ballScale, "step", 0.5 );
5283 setPreferenceProperty( elemW, "min", 1 );
5284 setPreferenceProperty( elemW, "max", 5 );
5286 setPreferenceProperty( outW, "min", 1 );
5287 setPreferenceProperty( outW, "max", 5 );
5289 setPreferenceProperty( shrink, "min", 0 );
5290 setPreferenceProperty( shrink, "max", 100 );
5292 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5293 setPreferenceProperty( numGroup, "columns", 2 );
5295 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5296 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5298 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5299 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5301 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5302 setPreferenceProperty( orientGroup, "columns", 1 );
5304 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5305 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5307 setPreferenceProperty( orientScale, "min", 0.05 );
5308 setPreferenceProperty( orientScale, "max", 0.5 );
5309 setPreferenceProperty( orientScale, "step", 0.05 );
5311 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5313 // Selection tab ------------------------------------------------------------------------
5314 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5316 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5317 setPreferenceProperty( selGroup, "columns", 2 );
5319 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5320 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5322 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5323 setPreferenceProperty( preGroup, "columns", 2 );
5325 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5327 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5328 setPreferenceProperty( precSelGroup, "columns", 2 );
5330 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5331 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5332 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5334 // Scalar Bar tab ------------------------------------------------------------------------
5335 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5336 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5337 setPreferenceProperty( fontGr, "columns", 2 );
5339 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5340 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5342 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5343 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5345 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5346 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5348 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5349 setPreferenceProperty( numcol, "min", 2 );
5350 setPreferenceProperty( numcol, "max", 256 );
5352 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5353 setPreferenceProperty( numlab, "min", 2 );
5354 setPreferenceProperty( numlab, "max", 65 );
5356 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5357 setPreferenceProperty( orientGr, "columns", 2 );
5358 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5359 QStringList orients;
5360 orients.append( tr( "SMESH_VERTICAL" ) );
5361 orients.append( tr( "SMESH_HORIZONTAL" ) );
5362 indices.clear(); indices.append( 0 ); indices.append( 1 );
5363 setPreferenceProperty( orient, "strings", orients );
5364 setPreferenceProperty( orient, "indexes", indices );
5366 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5367 setPreferenceProperty( posVSizeGr, "columns", 2 );
5368 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5369 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5370 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5371 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5372 setPreferenceProperty( xv, "step", 0.1 );
5373 setPreferenceProperty( xv, "min", 0.0 );
5374 setPreferenceProperty( xv, "max", 1.0 );
5375 setPreferenceProperty( yv, "step", 0.1 );
5376 setPreferenceProperty( yv, "min", 0.0 );
5377 setPreferenceProperty( yv, "max", 1.0 );
5378 setPreferenceProperty( wv, "step", 0.1 );
5379 setPreferenceProperty( wv, "min", 0.0 );
5380 setPreferenceProperty( wv, "max", 1.0 );
5381 setPreferenceProperty( hv, "min", 0.0 );
5382 setPreferenceProperty( hv, "max", 1.0 );
5383 setPreferenceProperty( hv, "step", 0.1 );
5385 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5386 setPreferenceProperty( posHSizeGr, "columns", 2 );
5387 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5388 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5389 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5390 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5391 setPreferenceProperty( xv, "min", 0.0 );
5392 setPreferenceProperty( xv, "max", 1.0 );
5393 setPreferenceProperty( xv, "step", 0.1 );
5394 setPreferenceProperty( xh, "min", 0.0 );
5395 setPreferenceProperty( xh, "max", 1.0 );
5396 setPreferenceProperty( xh, "step", 0.1 );
5397 setPreferenceProperty( yh, "min", 0.0 );
5398 setPreferenceProperty( yh, "max", 1.0 );
5399 setPreferenceProperty( yh, "step", 0.1 );
5400 setPreferenceProperty( wh, "min", 0.0 );
5401 setPreferenceProperty( wh, "max", 1.0 );
5402 setPreferenceProperty( wh, "step", 0.1 );
5403 setPreferenceProperty( hh, "min", 0.0 );
5404 setPreferenceProperty( hh, "max", 1.0 );
5405 setPreferenceProperty( hh, "step", 0.1 );
5407 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5408 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5409 setPreferenceProperty( distributionGr, "columns", 3 );
5411 types.append( tr( "SMESH_MONOCOLOR" ) );
5412 types.append( tr( "SMESH_MULTICOLOR" ) );
5413 indices.clear(); indices.append( 0 ); indices.append( 1 );
5414 setPreferenceProperty( coloringType, "strings", types );
5415 setPreferenceProperty( coloringType, "indexes", indices );
5416 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5420 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5422 if ( sect=="SMESH" ) {
5423 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5424 float aTol = 1.00000009999999;
5425 std::string aWarning;
5426 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5428 if ( name== "selection_object_color" ||
5429 name=="selection_element_color" ||
5430 name== "highlight_color" ||
5431 name=="selection_precision_node" ||
5432 name=="selection_precision_element" ||
5433 name=="selection_precision_object" )
5435 SMESH::UpdateSelectionProp( this );
5437 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5439 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5440 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5441 if ( sbX1+sbW > aTol ) {
5442 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5445 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5446 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5449 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5451 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5452 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5453 if ( sbY1 + sbH > aTol ) {
5454 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5455 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5456 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5459 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5461 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5462 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5463 if ( sbX1 + sbW > aTol ) {
5464 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5467 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5468 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5471 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5473 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5474 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5475 if ( sbY1 + sbH > aTol ) {
5476 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5479 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5480 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5483 else if ( name == "segmentation" )
5485 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5486 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5488 else if ( name == "nb_segments_per_edge" )
5490 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5491 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5493 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5495 QString val = aResourceMgr->stringValue( "SMESH", name );
5496 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5498 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5500 SMESH::UpdateFontProp( this );
5502 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5504 SMESH::UpdateFontProp( this );
5507 if ( aWarning.size() != 0 ) {
5508 aWarning += "The default values are applied instead.";
5509 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5510 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5511 QObject::tr(aWarning.c_str()));
5516 //================================================================================
5518 * \brief Update something in accordance with update flags
5519 * \param theFlags - update flags
5521 * Update viewer or/and object browser etc. in accordance with update flags ( see
5522 * LightApp_UpdateFlags enumeration ).
5524 //================================================================================
5525 void SMESHGUI::update( const int flags )
5527 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5528 SMESH::UpdateView();
5530 SalomeApp_Module::update( flags );
5533 //================================================================================
5535 * \brief Set default selection mode
5537 * SLOT called when operation committed. Sets default selection mode
5539 //================================================================================
5540 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5542 SVTK_ViewWindow* vtkWnd =
5543 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5545 vtkWnd->SetSelectionMode( ActorSelection );
5548 //================================================================================
5550 * \brief Set default selection mode
5552 * SLOT called when operation aborted. Sets default selection mode
5554 //================================================================================
5555 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5557 SVTK_ViewWindow* vtkWnd =
5558 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5560 vtkWnd->SetSelectionMode( ActorSelection );
5563 //================================================================================
5565 * \brief Creates operation with given identifier
5566 * \param id - identifier of operation to be started
5567 * \return Pointer on created operation or NULL if operation is not created
5569 * Virtual method redefined from the base class creates operation with given id.
5570 * It is called called automatically from startOperation method of base class.
5572 //================================================================================
5573 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5575 LightApp_Operation* op = 0;
5576 // to do : create operation here
5579 case SMESHOp::OpSplitBiQuadratic:
5580 op = new SMESHGUI_SplitBiQuadOp();
5582 case SMESHOp::OpConvertMeshToQuadratic:
5583 op = new SMESHGUI_ConvToQuadOp();
5585 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5586 op = new SMESHGUI_Make2DFrom3DOp();
5588 case SMESHOp::OpReorientFaces:
5589 op = new SMESHGUI_ReorientFacesOp();
5591 case SMESHOp::OpCreateMesh:
5592 op = new SMESHGUI_MeshOp( true, true );
5594 case SMESHOp::OpCreateSubMesh:
5595 op = new SMESHGUI_MeshOp( true, false );
5597 case SMESHOp::OpEditMeshOrSubMesh:
5598 case SMESHOp::OpEditMesh:
5599 case SMESHOp::OpEditSubMesh:
5600 op = new SMESHGUI_MeshOp( false );
5602 case SMESHOp::OpCompute:
5603 case SMESHOp::OpComputeSubMesh:
5604 op = new SMESHGUI_ComputeOp();
5606 case SMESHOp::OpPreCompute:
5607 op = new SMESHGUI_PrecomputeOp();
5609 case SMESHOp::OpEvaluate:
5610 op = new SMESHGUI_EvaluateOp();
5612 case SMESHOp::OpMeshOrder:
5613 op = new SMESHGUI_MeshOrderOp();
5615 case SMESHOp::OpCreateGeometryGroup:
5616 op = new SMESHGUI_GroupOnShapeOp();
5618 case SMESHOp::OpFindElementByPoint:
5619 op = new SMESHGUI_FindElemByPointOp();
5621 case SMESHOp::OpMoveNode: // Make mesh pass through point
5622 op = new SMESHGUI_MakeNodeAtPointOp();
5624 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5625 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5632 op = SalomeApp_Module::createOperation( id );
5636 //================================================================================
5638 * \brief Stops current operations and starts a given one
5639 * \param id - The id of the operation to start
5641 //================================================================================
5643 void SMESHGUI::switchToOperation(int id)
5645 activeStudy()->abortAllOperations();
5646 startOperation( id );
5649 LightApp_Displayer* SMESHGUI::displayer()
5652 myDisplayer = new SMESHGUI_Displayer( getApp() );
5656 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5659 int aTolerance = 64;
5660 int anIterations = 0;
5666 if( anIterations % aPeriod == 0 )
5669 if( aTolerance < 1 )
5673 aHue = (int)( 360.0 * rand() / RAND_MAX );
5676 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5677 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5678 for( ; it != itEnd; ++it )
5680 SALOMEDS::Color anAutoColor = *it;
5681 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5684 aQColor.getHsv( &h, &s, &v );
5685 if( abs( h - aHue ) < aTolerance )
5697 aColor.setHsv( aHue, 255, 255 );
5699 SALOMEDS::Color aSColor;
5700 aSColor.R = aColor.redF();
5701 aSColor.G = aColor.greenF();
5702 aSColor.B = aColor.blueF();
5707 const char* gSeparator = "_"; // character used to separate parameter names
5708 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5709 const char* gPathSep = "|"; // character used to separate paths
5712 * \brief Store visual parameters
5714 * This method is called just before the study document is saved.
5715 * Store visual parameters in AttributeParameter attribue(s)
5717 void SMESHGUI::storeVisualParameters (int savePoint)
5720 Kernel_Utils::Localizer loc;
5722 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5723 if (!appStudy || !appStudy->studyDS())
5725 _PTR(Study) studyDS = appStudy->studyDS();
5727 // componentName is used for encoding of entries when storing them in IParameters
5728 std::string componentName = myComponentSMESH->ComponentDataType();
5729 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5730 //if (!aSComponent) return;
5733 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5734 componentName.c_str(),
5736 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5738 // store custom markers
5739 if( !myMarkerMap.empty() )
5741 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5742 for( ; anIter != myMarkerMap.end(); anIter++ )
5744 int anId = anIter->first;
5745 VTK::MarkerData aMarkerData = anIter->second;
5746 std::string aMarkerFileName = aMarkerData.first;
5747 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5748 if( aMarkerTexture.size() < 3 )
5749 continue; // should contain at least width, height and the first value
5751 QString aPropertyName( "texture" );
5752 aPropertyName += gSeparator;
5753 aPropertyName += QString::number( anId );
5755 QString aPropertyValue = aMarkerFileName.c_str();
5756 aPropertyValue += gPathSep;
5758 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5759 ushort aWidth = *aTextureIter++;
5760 ushort aHeight = *aTextureIter++;
5761 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5762 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5763 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5764 aPropertyValue += QString::number( *aTextureIter );
5766 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5770 // viewers counters are used for storing view_numbers in IParameters
5773 // main cycle to store parameters of displayed objects
5774 QList<SUIT_ViewManager*> lst;
5775 QList<SUIT_ViewManager*>::Iterator it;
5776 getApp()->viewManagers(lst);
5777 for (it = lst.begin(); it != lst.end(); it++)
5779 SUIT_ViewManager* vman = *it;
5780 QString vType = vman->getType();
5782 // saving VTK actors properties
5783 if (vType == SVTK_Viewer::Type())
5785 // store the clipping planes attached to the view manager
5786 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5787 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5788 if( anIter != myClippingPlaneInfoMap.end() )
5789 aClippingPlaneInfoList = anIter->second;
5791 if( !aClippingPlaneInfoList.empty() ) {
5792 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5793 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5795 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5796 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5798 QString aPropertyName( "ClippingPlane" );
5799 aPropertyName += gSeparator;
5800 aPropertyName += QString::number( vtkViewers );
5801 aPropertyName += gSeparator;
5802 aPropertyName += QString::number( anId );
5804 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5805 aPropertyValue += gDigitsSep;
5806 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5807 aPropertyValue += gDigitsSep;
5808 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5809 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5810 aPropertyValue += gDigitsSep;
5811 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5812 aPropertyValue += gDigitsSep;
5813 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5814 aPropertyValue += gDigitsSep;
5815 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5816 aPropertyValue += gDigitsSep;
5817 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5818 aPropertyValue += gDigitsSep;
5819 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5820 aPropertyValue += gDigitsSep;
5821 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5823 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5824 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5825 aPropertyValue += gDigitsSep;
5826 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5827 aPropertyValue += gDigitsSep;
5828 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5829 aPropertyValue += gDigitsSep;
5830 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5833 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5837 QVector<SUIT_ViewWindow*> views = vman->getViews();
5838 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5840 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5842 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5843 vtkActorCollection* allActors = aCopy.GetActors();
5844 allActors->InitTraversal();
5845 while (vtkActor* actor = allActors->GetNextActor())
5847 if (actor->GetVisibility()) // store only visible actors
5849 SMESH_Actor* aSmeshActor = 0;
5850 if (actor->IsA("SMESH_Actor"))
5851 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5852 if (aSmeshActor && aSmeshActor->hasIO())
5854 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5857 // entry is "encoded" = it does NOT contain component address,
5858 // since it is a subject to change on next component loading
5859 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5861 std::string param, vtkParam = vType.toLatin1().data();
5862 vtkParam += gSeparator;
5863 vtkParam += QString::number(vtkViewers).toLatin1().data();
5864 vtkParam += gSeparator;
5867 param = vtkParam + "Visibility";
5868 ip->setParameter(entry, param, "On");
5871 param = vtkParam + "Representation";
5872 ip->setParameter(entry, param, QString::number
5873 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5876 param = vtkParam + "IsShrunk";
5877 ip->setParameter(entry, param, QString::number
5878 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5880 // Displayed entities
5881 unsigned int aMode = aSmeshActor->GetEntityMode();
5882 bool isE = aMode & SMESH_Actor::eEdges;
5883 bool isF = aMode & SMESH_Actor::eFaces;
5884 bool isV = aMode & SMESH_Actor::eVolumes;
5885 bool is0d = aMode & SMESH_Actor::e0DElements;
5886 bool isB = aMode & SMESH_Actor::eBallElem;
5888 QString modeStr ("e");
5889 modeStr += gDigitsSep; modeStr += QString::number(isE);
5890 modeStr += gDigitsSep; modeStr += "f";
5891 modeStr += gDigitsSep; modeStr += QString::number(isF);
5892 modeStr += gDigitsSep; modeStr += "v";
5893 modeStr += gDigitsSep; modeStr += QString::number(isV);
5894 modeStr += gDigitsSep; modeStr += "0d";
5895 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5896 modeStr += gDigitsSep; modeStr += "b";
5897 modeStr += gDigitsSep; modeStr += QString::number(isB);
5899 param = vtkParam + "Entities";
5900 ip->setParameter(entry, param, modeStr.toLatin1().data());
5906 aSmeshActor->GetSufaceColor(r, g, b, delta);
5907 QStringList colorStr;
5908 colorStr << "surface";
5909 colorStr << QString::number(r);
5910 colorStr << QString::number(g);
5911 colorStr << QString::number(b);
5913 colorStr << "backsurface";
5914 colorStr << QString::number(delta);
5916 aSmeshActor->GetVolumeColor(r, g, b, delta);
5917 colorStr << "volume";
5918 colorStr << QString::number(r);
5919 colorStr << QString::number(g);
5920 colorStr << QString::number(b);
5921 colorStr << QString::number(delta);
5923 aSmeshActor->GetEdgeColor(r, g, b);
5925 colorStr << QString::number(r);
5926 colorStr << QString::number(g);
5927 colorStr << QString::number(b);
5929 aSmeshActor->GetNodeColor(r, g, b);
5931 colorStr << QString::number(r);
5932 colorStr << QString::number(g);
5933 colorStr << QString::number(b);
5935 aSmeshActor->GetOutlineColor(r, g, b);
5936 colorStr << "outline";
5937 colorStr << QString::number(r);
5938 colorStr << QString::number(g);
5939 colorStr << QString::number(b);
5941 aSmeshActor->Get0DColor(r, g, b);
5942 colorStr << "elem0d";
5943 colorStr << QString::number(r);
5944 colorStr << QString::number(g);
5945 colorStr << QString::number(b);
5947 aSmeshActor->GetBallColor(r, g, b);
5949 colorStr << QString::number(r);
5950 colorStr << QString::number(g);
5951 colorStr << QString::number(b);
5953 aSmeshActor->GetFacesOrientationColor(r, g, b);
5954 colorStr << "orientation";
5955 colorStr << QString::number(r);
5956 colorStr << QString::number(g);
5957 colorStr << QString::number(b);
5959 param = vtkParam + "Colors";
5960 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5963 QStringList sizeStr;
5965 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5966 sizeStr << "outline";
5967 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5968 sizeStr << "elem0d";
5969 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5971 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5972 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5973 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5974 sizeStr << "shrink";
5975 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5976 sizeStr << "orientation";
5977 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5978 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5980 param = vtkParam + "Sizes";
5981 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5986 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5987 if( aMarkerType == VTK::MT_USER ) {
5988 markerStr += "custom";
5989 markerStr += gDigitsSep;
5990 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5994 markerStr += gDigitsSep;
5995 markerStr += QString::number( (int)aMarkerType );
5996 markerStr += gDigitsSep;
5997 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6000 param = vtkParam + "PointMarker";
6001 ip->setParameter(entry, param, markerStr.toLatin1().data());
6004 param = vtkParam + "Opacity";
6005 ip->setParameter(entry, param,
6006 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6009 param = vtkParam + "ClippingPlane";
6011 if( !aClippingPlaneInfoList.empty() ) {
6012 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6013 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6015 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6016 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6017 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6018 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6019 if( aSmeshActor == *anIter2 ) {
6020 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6021 QString::number( anId ).toLatin1().constData() );
6028 ip->setParameter( entry, param, "Off" );
6029 } // if (io->hasEntry())
6030 } // SMESH_Actor && hasIO
6032 } // while.. actors traversal
6036 } // if (SVTK view model)
6037 } // for (viewManagers)
6040 // data structures for clipping planes processing
6044 bool isOpenGLClipping;
6045 vtkIdType RelativeOrientation;
6048 int AbsoluteOrientation;
6049 double X, Y, Z, Dx, Dy, Dz;
6051 typedef std::list<TPlaneData> TPlaneDataList;
6052 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6054 typedef std::list<vtkActor*> TActorList;
6057 TActorList ActorList;
6058 SUIT_ViewManager* ViewManager;
6060 typedef std::list<TPlaneInfo> TPlaneInfoList;
6061 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6064 * \brief Restore visual parameters
6066 * This method is called after the study document is opened.
6067 * Restore visual parameters from AttributeParameter attribue(s)
6069 void SMESHGUI::restoreVisualParameters (int savePoint)
6072 Kernel_Utils::Localizer loc;
6074 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6075 if (!appStudy || !appStudy->studyDS())
6077 _PTR(Study) studyDS = appStudy->studyDS();
6079 // componentName is used for encoding of entries when storing them in IParameters
6080 std::string componentName = myComponentSMESH->ComponentDataType();
6081 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6082 //if (!aSComponent) return;
6085 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6086 componentName.c_str(),
6088 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6090 // restore custom markers and map of clipping planes
6091 TPlaneDataMap aPlaneDataMap;
6093 std::vector<std::string> properties = ip->getProperties();
6094 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6096 std::string property = *propIt;
6097 QString aPropertyName( property.c_str() );
6098 QString aPropertyValue( ip->getProperty( property ).c_str() );
6100 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6101 if( aPropertyNameList.isEmpty() )
6104 QString aPropertyType = aPropertyNameList[0];
6105 if( aPropertyType == "texture" )
6107 if( aPropertyNameList.size() != 2 )
6111 int anId = aPropertyNameList[1].toInt( &ok );
6112 if( !ok || anId < 1 )
6115 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6116 if( aPropertyValueList.size() != 2 )
6119 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6120 QString aMarkerTextureString = aPropertyValueList[1];
6121 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6122 if( aMarkerTextureStringList.size() != 3 )
6126 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6131 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6135 VTK::MarkerTexture aMarkerTexture;
6136 aMarkerTexture.push_back( aWidth );
6137 aMarkerTexture.push_back( aHeight );
6139 QString aMarkerTextureData = aMarkerTextureStringList[2];
6140 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6142 QChar aChar = aMarkerTextureData.at( i );
6143 if( aChar.isDigit() )
6144 aMarkerTexture.push_back( aChar.digitValue() );
6147 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6149 else if( aPropertyType == "ClippingPlane" )
6151 if( aPropertyNameList.size() != 3 )
6155 int aViewId = aPropertyNameList[1].toInt( &ok );
6156 if( !ok || aViewId < 0 )
6160 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6161 if( !ok || aClippingPlaneId < 0 )
6164 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6165 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6168 TPlaneData aPlaneData;
6169 aPlaneData.AbsoluteOrientation = false;
6170 aPlaneData.RelativeOrientation = 0;
6171 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6172 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6173 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6175 aPlaneData.Id = aClippingPlaneId;
6178 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6183 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6187 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6190 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6195 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6200 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6205 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6210 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6215 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6220 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6224 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6226 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6231 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6236 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6241 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6246 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6247 aPlaneDataList.push_back( aPlaneData );
6251 TPlaneInfoMap aPlaneInfoMap;
6253 std::vector<std::string> entries = ip->getEntries();
6255 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6257 // entry is a normal entry - it should be "decoded" (setting base address of component)
6258 QString entry (ip->decodeEntry(*entIt).c_str());
6260 // Check that the entry corresponds to a real object in the Study
6261 // as the object may be deleted or modified after the visual state is saved.
6262 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6263 if (!so) continue; //Skip the not existent entry
6265 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6266 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6268 std::vector<std::string>::iterator namesIt = paramNames.begin();
6269 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6271 // actors are stored in a map after displaying of them for
6272 // quicker access in the future: map < viewID to actor >
6273 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6275 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6277 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6278 // '_' is used as separator and should not be used in viewer type or parameter names.
6279 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6280 if (lst.size() != 3)
6283 QString viewerTypStr = lst[0];
6284 QString viewIndexStr = lst[1];
6285 QString paramNameStr = lst[2];
6288 int viewIndex = viewIndexStr.toUInt(&ok);
6289 if (!ok) // bad conversion of view index to integer
6293 if (viewerTypStr == SVTK_Viewer::Type())
6295 SMESH_Actor* aSmeshActor = 0;
6296 if (vtkActors.IsBound(viewIndex))
6297 aSmeshActor = vtkActors.Find(viewIndex);
6299 QList<SUIT_ViewManager*> lst;
6300 getApp()->viewManagers(viewerTypStr, lst);
6302 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6303 SUIT_ViewManager* vman = NULL;
6304 if (viewIndex >= 0 && viewIndex < lst.count())
6305 vman = lst.at(viewIndex);
6307 if (paramNameStr == "Visibility")
6309 if (!aSmeshActor && displayer() && vman)
6311 SUIT_ViewModel* vmodel = vman->getViewModel();
6312 // SVTK view model can be casted to SALOME_View
6313 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6315 // store displayed actor in a temporary map for quicker
6316 // access later when restoring other parameters
6317 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6318 vtkRenderer* Renderer = vtkView->getRenderer();
6319 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6320 vtkActorCollection* theActors = aCopy.GetActors();
6321 theActors->InitTraversal();
6322 bool isFound = false;
6323 vtkActor *ac = theActors->GetNextActor();
6324 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6325 if (ac->IsA("SMESH_Actor")) {
6326 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6327 if (aGeomAc->hasIO()) {
6328 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6329 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6331 vtkActors.Bind(viewIndex, aGeomAc);
6337 } // if (paramNameStr == "Visibility")
6340 // the rest properties "work" with SMESH_Actor
6343 QString val ((*valuesIt).c_str());
6346 if (paramNameStr == "Representation") {
6347 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6350 else if (paramNameStr == "IsShrunk") {
6352 if (!aSmeshActor->IsShrunk())
6353 aSmeshActor->SetShrink();
6356 if (aSmeshActor->IsShrunk())
6357 aSmeshActor->UnShrink();
6360 // Displayed entities
6361 else if (paramNameStr == "Entities") {
6362 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6363 int aEntityMode = SMESH_Actor::eAllEntity;
6364 for ( int i = 0; i < mode.count(); i+=2 ) {
6365 if ( i < mode.count()-1 ) {
6366 QString type = mode[i];
6367 bool val = mode[i+1].toInt();
6368 if ( type == "e" && !val )
6369 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6370 else if ( type == "f" && !val )
6371 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6372 else if ( type == "v" && !val )
6373 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6374 else if ( type == "0d" && !val )
6375 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6376 else if ( type == "b" && !val )
6377 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6380 aSmeshActor->SetEntityMode( aEntityMode );
6383 else if (paramNameStr == "Colors") {
6384 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6391 QColor outlineColor;
6392 QColor orientationColor;
6398 // below lines are required to get default values for delta coefficients
6399 // of backface color for faces and color of reversed volumes
6400 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6401 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6402 for ( int i = 0; i < colors.count(); i++ ) {
6403 QString type = colors[i];
6404 if ( type == "surface" ) {
6405 // face color is set by 3 values r:g:b, where
6406 // - r,g,b - is rgb color components
6407 if ( i+1 >= colors.count() ) break; // format error
6408 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6409 if ( i+2 >= colors.count() ) break; // format error
6410 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6411 if ( i+3 >= colors.count() ) break; // format error
6412 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6413 faceColor.setRgbF( r, g, b );
6416 else if ( type == "backsurface" ) {
6417 // backface color can be defined in several ways
6418 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6419 // - in latest versions, it is set as delta coefficient
6420 bool rgbOk = false, deltaOk;
6421 if ( i+1 >= colors.count() ) break; // format error
6422 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6423 int delta = colors[i+1].toInt( &deltaOk );
6425 if ( i+1 < colors.count() ) // index is shifted to 1
6426 g = colors[i+1].toDouble( &rgbOk );
6427 if ( rgbOk ) i++; // shift index
6428 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6429 b = colors[i+1].toDouble( &rgbOk );
6431 // - as currently there's no way to set directly backsurface color as it was before,
6432 // we ignore old dump where r,g,b triple was set
6433 // - also we check that delta parameter is set properly
6434 if ( !rgbOk && deltaOk )
6437 else if ( type == "volume" ) {
6438 // volume color is set by 4 values r:g:b:delta, where
6439 // - r,g,b - is a normal volume rgb color components
6440 // - delta - is a reversed volume color delta coefficient
6441 if ( i+1 >= colors.count() ) break; // format error
6442 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6443 if ( i+2 >= colors.count() ) break; // format error
6444 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6445 if ( i+3 >= colors.count() ) break; // format error
6446 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6447 if ( i+4 >= colors.count() ) break; // format error
6448 int delta = colors[i+4].toInt( &bOk );
6449 if ( !bOk ) break; // format error
6450 volumeColor.setRgbF( r, g, b );
6454 else if ( type == "edge" ) {
6455 // edge color is set by 3 values r:g:b, where
6456 // - r,g,b - is rgb color components
6457 if ( i+1 >= colors.count() ) break; // format error
6458 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6459 if ( i+2 >= colors.count() ) break; // format error
6460 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6461 if ( i+3 >= colors.count() ) break; // format error
6462 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6463 edgeColor.setRgbF( r, g, b );
6466 else if ( type == "node" ) {
6467 // node color is set by 3 values r:g:b, where
6468 // - r,g,b - is rgb color components
6469 if ( i+1 >= colors.count() ) break; // format error
6470 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6471 if ( i+2 >= colors.count() ) break; // format error
6472 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6473 if ( i+3 >= colors.count() ) break; // format error
6474 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6475 nodeColor.setRgbF( r, g, b );
6478 else if ( type == "elem0d" ) {
6479 // 0d element color is set by 3 values r:g:b, where
6480 // - r,g,b - is rgb color components
6481 if ( i+1 >= colors.count() ) break; // format error
6482 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6483 if ( i+2 >= colors.count() ) break; // format error
6484 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6485 if ( i+3 >= colors.count() ) break; // format error
6486 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6487 elem0dColor.setRgbF( r, g, b );
6490 else if ( type == "ball" ) {
6491 // ball color is set by 3 values r:g:b, where
6492 // - r,g,b - is rgb color components
6493 if ( i+1 >= colors.count() ) break; // format error
6494 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6495 if ( i+2 >= colors.count() ) break; // format error
6496 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6497 if ( i+3 >= colors.count() ) break; // format error
6498 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6499 ballColor.setRgbF( r, g, b );
6502 else if ( type == "outline" ) {
6503 // outline color is set by 3 values r:g:b, where
6504 // - r,g,b - is rgb color components
6505 if ( i+1 >= colors.count() ) break; // format error
6506 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6507 if ( i+2 >= colors.count() ) break; // format error
6508 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6509 if ( i+3 >= colors.count() ) break; // format error
6510 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6511 outlineColor.setRgbF( r, g, b );
6514 else if ( type == "orientation" ) {
6515 // orientation color is set by 3 values r:g:b, where
6516 // - r,g,b - is rgb color components
6517 if ( i+1 >= colors.count() ) break; // format error
6518 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6519 if ( i+2 >= colors.count() ) break; // format error
6520 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6521 if ( i+3 >= colors.count() ) break; // format error
6522 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6523 orientationColor.setRgbF( r, g, b );
6528 if ( nodeColor.isValid() )
6529 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6531 if ( edgeColor.isValid() )
6532 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6534 if ( faceColor.isValid() )
6535 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6537 if ( volumeColor.isValid() )
6538 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6539 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6540 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6542 if ( elem0dColor.isValid() )
6543 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6545 if ( ballColor.isValid() )
6546 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6548 if ( outlineColor.isValid() )
6549 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6550 // orientation color
6551 if ( orientationColor.isValid() )
6552 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6555 else if (paramNameStr == "Sizes") {
6556 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6559 int outlineWidth = -1;
6560 int elem0dSize = -1;
6561 //int ballSize = -1;
6562 double ballDiameter = -1.0;
6563 double ballScale = -1.0;
6564 double shrinkSize = -1;
6565 double orientationSize = -1;
6566 bool orientation3d = false;
6567 for ( int i = 0; i < sizes.count(); i++ ) {
6568 QString type = sizes[i];
6569 if ( type == "line" ) {
6570 // line (wireframe) width is given as single integer value
6571 if ( i+1 >= sizes.count() ) break; // format error
6572 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6576 if ( type == "outline" ) {
6577 // outline width is given as single integer value
6578 if ( i+1 >= sizes.count() ) break; // format error
6579 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6583 else if ( type == "elem0d" ) {
6584 // 0d element size is given as single integer value
6585 if ( i+1 >= sizes.count() ) break; // format error
6586 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6590 else if ( type == "ball" ) {
6591 // balls are specified by two values: size:scale, where
6592 // - size - is a integer value specifying size
6593 // - scale - is a double value specifying scale factor
6594 if ( i+1 >= sizes.count() ) break; // format error
6595 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6596 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6597 if ( i+2 >= sizes.count() ) break; // format error
6598 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6604 else if ( type == "shrink" ) {
6605 // shrink factor is given as single floating point value
6606 if ( i+1 >= sizes.count() ) break; // format error
6607 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6611 else if ( type == "orientation" ) {
6612 // orientation vectors are specified by two values size:3d, where
6613 // - size - is a floating point value specifying scale factor
6614 // - 3d - is a boolean
6615 if ( i+1 >= sizes.count() ) break; // format error
6616 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6617 if ( i+2 >= sizes.count() ) break; // format error
6618 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6619 orientationSize = v1;
6620 orientation3d = (bool)v2;
6624 // line (wireframe) width
6625 if ( lineWidth > 0 )
6626 aSmeshActor->SetLineWidth( lineWidth );
6628 if ( outlineWidth > 0 )
6629 aSmeshActor->SetOutlineWidth( outlineWidth );
6630 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6631 aSmeshActor->SetOutlineWidth( lineWidth );
6633 if ( elem0dSize > 0 )
6634 aSmeshActor->Set0DSize( elem0dSize );
6636 /*if ( ballSize > 0 )
6637 aSmeshActor->SetBallSize( ballSize );*/
6639 if ( ballDiameter > 0 )
6640 aSmeshActor->SetBallSize( ballDiameter );
6642 if ( ballScale > 0.0 )
6643 aSmeshActor->SetBallScale( ballScale );
6645 if ( shrinkSize > 0 )
6646 aSmeshActor->SetShrinkFactor( shrinkSize );
6647 // orientation vectors
6648 if ( orientationSize > 0 ) {
6649 aSmeshActor->SetFacesOrientationScale( orientationSize );
6650 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6654 else if (paramNameStr == "PointMarker") {
6655 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6656 if( data.count() >= 2 ) {
6658 int aParam1 = data[1].toInt( &ok );
6660 if( data[0] == "std" && data.count() == 3 ) {
6661 int aParam2 = data[2].toInt( &ok );
6662 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6664 else if( data[0] == "custom" ) {
6665 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6666 if( markerIt != myMarkerMap.end() ) {
6667 VTK::MarkerData aMarkerData = markerIt->second;
6668 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6675 else if (paramNameStr == "Opacity") {
6676 aSmeshActor->SetOpacity(val.toFloat());
6679 else if (paramNameStr.startsWith("ClippingPlane")) {
6680 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6681 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6682 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6683 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6684 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6685 // new format - val looks like "Off" or "0" (plane id)
6686 // (note: in new format "Off" value is used only for consistency,
6687 // so it is processed together with values in old format)
6688 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6689 if( anIsOldFormat ) {
6690 if (paramNameStr == "ClippingPlane1" || val == "Off")
6691 aSmeshActor->RemoveAllClippingPlanes();
6693 QList<SUIT_ViewManager*> lst;
6694 getApp()->viewManagers(viewerTypStr, lst);
6695 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6696 if (viewIndex >= 0 && viewIndex < lst.count()) {
6697 SUIT_ViewManager* vman = lst.at(viewIndex);
6698 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6700 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6702 SMESH::TActorList anActorList;
6703 anActorList.push_back( aSmeshActor );
6704 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6705 aPlane->myViewWindow = vtkView;
6706 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6707 aPlane->PlaneMode = aMode;
6708 bool isOpenGLClipping = ( bool )vals[1].toInt();
6709 aPlane->IsOpenGLClipping = isOpenGLClipping;
6710 if ( aMode == SMESH::Absolute ) {
6711 aPlane->myAbsoluteOrientation = vals[2].toInt();
6712 aPlane->X = vals[3].toFloat();
6713 aPlane->Y = vals[4].toFloat();
6714 aPlane->Z = vals[5].toFloat();
6715 aPlane->Dx = vals[6].toFloat();
6716 aPlane->Dy = vals[7].toFloat();
6717 aPlane->Dz = vals[8].toFloat();
6719 else if ( aMode == SMESH::Relative ) {
6720 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6721 aPlane->myDistance = vals[3].toFloat();
6722 aPlane->myAngle[0] = vals[4].toFloat();
6723 aPlane->myAngle[1] = vals[5].toFloat();
6727 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6728 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6729 aClippingPlaneInfo.Plane = aPlane;
6730 aClippingPlaneInfo.ActorList = anActorList;
6731 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6739 int aPlaneId = val.toInt( &ok );
6740 if( ok && aPlaneId >= 0 ) {
6741 bool anIsDefinedPlane = false;
6742 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6743 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6744 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6745 TPlaneInfo& aPlaneInfo = *anIter;
6746 if( aPlaneInfo.PlaneId == aPlaneId ) {
6747 aPlaneInfo.ActorList.push_back( aSmeshActor );
6748 anIsDefinedPlane = true;
6752 if( !anIsDefinedPlane ) {
6753 TPlaneInfo aPlaneInfo;
6754 aPlaneInfo.PlaneId = aPlaneId;
6755 aPlaneInfo.ActorList.push_back( aSmeshActor );
6756 aPlaneInfo.ViewManager = vman;
6758 // to make the list sorted by plane id
6759 anIter = aPlaneInfoList.begin();
6760 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6761 const TPlaneInfo& aPlaneInfoRef = *anIter;
6762 if( aPlaneInfoRef.PlaneId > aPlaneId )
6765 aPlaneInfoList.insert( anIter, aPlaneInfo );
6770 } // if (aSmeshActor)
6771 } // other parameters than Visibility
6773 } // for names/parameters iterator
6774 } // for entries iterator
6776 // take into account planes with empty list of actors referred to them
6777 QList<SUIT_ViewManager*> aVMList;
6778 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6780 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6781 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6782 int aViewId = aPlaneDataIter->first;
6783 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6784 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6786 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6788 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6789 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6790 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6791 const TPlaneData& aPlaneData = *anIter2;
6792 int aPlaneId = aPlaneData.Id;
6794 bool anIsFound = false;
6795 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6796 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6797 const TPlaneInfo& aPlaneInfo = *anIter3;
6798 if( aPlaneInfo.PlaneId == aPlaneId ) {
6805 TPlaneInfo aPlaneInfo; // ActorList field is empty
6806 aPlaneInfo.PlaneId = aPlaneId;
6807 aPlaneInfo.ViewManager = aViewManager;
6809 // to make the list sorted by plane id
6810 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6811 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6812 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6813 if( aPlaneInfoRef.PlaneId > aPlaneId )
6816 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6822 // add clipping planes to actors according to the restored parameters
6823 // and update the clipping plane map
6824 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6825 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6826 int aViewId = anIter1->first;
6827 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6829 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6830 if( anIter2 == aPlaneDataMap.end() )
6832 const TPlaneDataList& aPlaneDataList = anIter2->second;
6834 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6835 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6836 const TPlaneInfo& aPlaneInfo = *anIter3;
6837 int aPlaneId = aPlaneInfo.PlaneId;
6838 const TActorList& anActorList = aPlaneInfo.ActorList;
6839 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6843 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6847 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6849 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6850 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6851 const TPlaneData& aPlaneData = *anIter4;
6852 if( aPlaneData.Id == aPlaneId ) {
6853 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6854 aPlane->myViewWindow = aViewWindow;
6855 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6856 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6857 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6858 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6859 aPlane->X = aPlaneData.X;
6860 aPlane->Y = aPlaneData.Y;
6861 aPlane->Z = aPlaneData.Z;
6862 aPlane->Dx = aPlaneData.Dx;
6863 aPlane->Dy = aPlaneData.Dy;
6864 aPlane->Dz = aPlaneData.Dz;
6866 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6867 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6868 aPlane->myDistance = aPlaneData.Distance;
6869 aPlane->myAngle[0] = aPlaneData.Angle[0];
6870 aPlane->myAngle[1] = aPlaneData.Angle[1];
6873 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6874 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6875 aClippingPlaneInfo.Plane = aPlane;
6876 aClippingPlaneInfo.ActorList = anActorList;
6877 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6888 // update all VTK views
6889 QList<SUIT_ViewManager*> lst;
6890 getApp()->viewManagers(lst);
6891 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6892 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6893 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6894 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6895 // set OpenGL clipping planes
6896 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6897 vtkActorCollection* anAllActors = aCopy.GetActors();
6898 anAllActors->InitTraversal();
6899 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6900 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6901 anActor->SetOpenGLClippingPlane();
6903 vtkView->getRenderer()->ResetCameraClippingRange();
6910 \brief Adds preferences for dfont of VTK viewer
6912 \param pIf group identifier
6913 \param param parameter
6914 \return identifier of preferences
6916 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6918 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6920 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6923 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6924 fam.append( tr( "SMESH_FONT_COURIER" ) );
6925 fam.append( tr( "SMESH_FONT_TIMES" ) );
6927 setPreferenceProperty( tfont, "fonts", fam );
6929 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6930 if ( needSize ) f = f | QtxFontEdit::Size;
6931 setPreferenceProperty( tfont, "features", f );
6937 \brief Actions after hypothesis edition
6938 Updates object browser after hypothesis edition
6940 void SMESHGUI::onHypothesisEdit( int result )
6943 SMESHGUI::Modified();
6944 updateObjBrowser( true );
6948 \brief Actions after choosing menu of control modes
6949 Updates control mode actions according to current selection
6951 void SMESHGUI::onUpdateControlActions()
6953 SALOME_ListIO selected;
6954 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6955 aSel->selectedObjects( selected );
6957 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6958 if ( selected.Extent() ) {
6959 if ( selected.First()->hasEntry() ) {
6960 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6961 aControl = anActor->GetControlMode();
6962 SALOME_ListIteratorOfListIO it(selected);
6963 for ( it.Next(); it.More(); it.Next() ) {
6964 Handle(SALOME_InteractiveObject) anIO = it.Value();
6965 if ( anIO->hasEntry() ) {
6966 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6967 if ( aControl != anActor->GetControlMode() ) {
6968 aControl = SMESH_Actor::eNone;
6978 int anAction = ActionToControl( aControl, true );
6980 action( anAction )->setChecked( true );
6982 QMenu* send = (QMenu*)sender();
6983 QList<QAction*> actions = send->actions();
6984 for ( int i = 0; i < actions.size(); i++ )
6985 actions[i]->setChecked( false );
6991 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6992 \param pview view being closed
6994 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6995 #ifndef DISABLE_PLOT2DVIEWER
6996 //Crear all Plot2d Viewers if need.
6997 SMESH::ClearPlot2Viewers(pview);
6999 EmitSignalCloseView();
7002 void SMESHGUI::message( const QString& msg )
7005 QStringList data = msg.split("/");
7006 if ( data.count() > 0 ) {
7007 if ( data.first() == "mesh_loading" ) {
7009 QString entry = data.count() > 1 ? data[1] : QString();
7010 if ( entry.isEmpty() )
7013 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7015 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7018 name = SMESH::fromUtf8(obj->GetName());
7019 if ( name.isEmpty() )
7022 if ( data.last() == "stop" )
7023 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7025 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7026 QApplication::processEvents();
7032 \brief Connects or disconnects signals about activating and cloning view on the module slots
7033 \param pview view which is connected/disconnected
7035 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7039 SUIT_ViewManager* viewMgr = pview->getViewManager();
7041 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7042 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7044 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7045 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7050 \brief Return \c true if object can be renamed
7052 bool SMESHGUI::renameAllowed( const QString& entry) const {
7053 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7057 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7061 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7066 if(appStudy->isComponent(entry) || obj->isReference())
7069 // check type to prevent renaming of inappropriate objects
7070 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7071 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7072 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7073 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7074 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7075 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7082 Rename object by entry.
7083 \param entry entry of the object
7084 \param name new name of the object
7085 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7087 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7089 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7093 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7098 _PTR(Study) aStudy = appStudy->studyDS();
7103 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7105 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7110 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7111 _PTR(GenericAttribute) anAttr;
7112 _PTR(AttributeName) aName;
7114 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7116 // check type to prevent renaming of inappropriate objects
7117 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7118 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7119 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7120 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7121 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7122 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7123 if ( !name.isEmpty() ) {
7124 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7126 // update name of group object and its actor
7127 Handle(SALOME_InteractiveObject) IObject =
7128 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7130 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7131 if( !aGroupObject->_is_nil() ) {
7132 aGroupObject->SetName( qPrintable(name) );
7133 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7134 anActor->setName( qUtf8Printable(name) );
7144 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7146 static QList<QColor> colors;
7148 if ( colors.isEmpty() ) {
7150 for (int s = 0; s < 2 ; s++)
7152 for (int v = 100; v >= 40; v = v - 20)
7154 for (int h = 0; h < 359 ; h = h + 60)
7156 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7161 static int currentColor = randomize( colors.size() );
7163 SALOMEDS::Color color;
7164 color.R = (double)colors[currentColor].red() / 255.0;
7165 color.G = (double)colors[currentColor].green() / 255.0;
7166 color.B = (double)colors[currentColor].blue() / 255.0;
7168 currentColor = (currentColor+1) % colors.count();