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 SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
753 for ( int i = 0; i < mvok->length(); ++i )
755 int versionInt = mvok[i];
756 std::ostringstream vss;
757 vss << versionInt/10;
759 vss << versionInt%10;
760 QString vs = vss.str().c_str();
761 MESSAGE("MED version: " << vs.toStdString());
762 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", i);
766 aFilterMap.insert("All files (*)", -1 );
767 aFilterMap.insert("SAUV files (*.sauv)", 0 );
768 aFilterMap.insert("SAUV files (*.sauve)", -1 );
772 QMap<QString, int>::const_iterator it = aFilterMap.begin();
773 QString aDefaultFilter = it.key();
774 for ( ; it != aFilterMap.end(); ++it ) {
775 filters.push_back( it.key() );
776 if (it.value() == 0) // explicit default for MED = current MED version
777 aDefaultFilter = it.key();
779 QStringList checkBoxes;
780 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
782 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
783 QList< QWidget* > wdgList;
784 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
785 wdgList.append( fieldSelWdg );
787 SalomeApp_CheckFileDlg* fd =
788 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
789 fd->setWindowTitle( aTitle );
790 fd->setNameFilters( filters );
791 fd->selectNameFilter( aDefaultFilter );
792 fd->SetChecked( toCreateGroups, 0 );
793 fd->SetChecked( toFindOutDim, 1 );
794 if ( !anInitialPath.isEmpty() )
795 fd->setDirectory( anInitialPath );
796 fd->selectFile(aMeshName);
799 QListView *lview = fd->findChild<QListView*>("listView");
801 lview->setMinimumHeight(200);
803 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
805 tview->setMinimumHeight(200);
808 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
809 fd->setValidator( fv );
813 MESSAGE("******* Loop on file dialog ***********");
816 aFilename = fd->selectedFile();
818 aFilename = QString::null;
821 aFormat = aFilterMap[fd->selectedNameFilter()];
822 MESSAGE("selected minor: " << aFormat << " file: " << aFilename.toUtf8().constData());
823 toOverwrite = fv->isOverwrite(aFilename);
824 MESSAGE("toOverwrite:" << toOverwrite);
826 if ( !aFilename.isEmpty() ) {
828 // can't append to an existing using other format
829 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
830 MESSAGE("Append check, isVersionOk:" << isVersionOk);
831 if ( !isVersionOk ) {
832 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
833 QObject::tr("SMESH_WRN_WARNING"),
834 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
835 QObject::tr("SMESH_BUT_YES"),
836 QObject::tr("SMESH_BUT_NO"), 0, 1);
840 MESSAGE("incompatible MED file version for add, overwrite accepted");
846 MESSAGE("incompatible MED file version for add, overwrite refused");
849 QStringList aMeshNamesCollisionList;
850 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
851 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
852 QString anExistingMeshName( aMeshNames[ i ] );
853 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
854 QString anExportMeshName = (*aMeshIter).second;
855 if( anExportMeshName == anExistingMeshName ) {
856 aMeshNamesCollisionList.append( anExportMeshName );
861 if( !aMeshNamesCollisionList.isEmpty() ) {
863 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
864 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
865 QObject::tr("SMESH_WRN_WARNING"),
866 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
867 QObject::tr("SMESH_BUT_YES"),
868 QObject::tr("SMESH_BUT_NO"),
869 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
870 MESSAGE("answer collision name " << aRet);
881 MESSAGE(" ****** end of file dialog loop, toOverwrite:" << toOverwrite << " isOkToWrite:" << isOkToWrite);
882 toCreateGroups = fd->IsChecked(0);
883 toFindOutDim = fd->IsChecked(1);
884 fieldSelWdg->GetSelectedFields();
885 if ( !fieldSelWdg->parent() )
896 if ( !aFilename.isEmpty() ) {
897 // Check whether the file already exists and delete it if yes
898 QFile aFile( aFilename );
899 if ( aFile.exists() && toOverwrite )
901 SUIT_OverrideCursor wc;
904 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
905 // bool Renumber = false;
906 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
908 // Renumber= resMgr->booleanValue("renumbering");
910 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
911 // aMeshEditor->RenumberNodes();
912 // aMeshEditor->RenumberElements();
913 // if ( SMESHGUI::automaticUpdate() )
914 // SMESH::UpdateView();
916 if ( isMED && isOkToWrite)
918 MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
919 aMeshIter = aMeshList.begin();
920 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
922 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
923 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
924 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
925 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
926 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
927 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
928 aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
929 toOverwrite && aMeshIndex == 0, toFindOutDim );
931 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups, aFormat,
932 toOverwrite && aMeshIndex == 0, toFindOutDim,
933 fields, geoAssFields.toLatin1().data() );
938 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
940 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
941 if( !aMeshItem->_is_nil() )
942 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
947 if ( aMeshOrGroup->_is_equivalent( aMesh ))
948 aMesh->ExportDAT( aFilename.toUtf8().data() );
950 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
954 if ( aMeshOrGroup->_is_equivalent( aMesh ))
955 aMesh->ExportUNV( aFilename.toUtf8().data() );
957 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
961 if ( aMeshOrGroup->_is_equivalent( aMesh ))
962 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
964 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
968 aMeshIter = aMeshList.begin();
969 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
971 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
972 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
973 aMeshItem->ExportCGNS( aMeshOrGroup,
974 aFilename.toUtf8().data(),
975 toOverwrite && aMeshIndex == 0,
981 toCreateGroups = true;
982 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
985 catch (const SALOME::SALOME_Exception& S_ex){
987 SUIT_MessageBox::warning(SMESHGUI::desktop(),
988 QObject::tr("SMESH_WRN_WARNING"),
989 QObject::tr("SMESH_EXPORT_FAILED"));
995 inline void InverseEntityMode(unsigned int& theOutputMode,
996 unsigned int theMode)
998 bool anIsNotPresent = ~theOutputMode & theMode;
1000 theOutputMode |= theMode;
1002 theOutputMode &= ~theMode;
1005 void SetDisplayEntity(int theCommandID)
1007 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1008 SALOME_ListIO selected;
1010 aSel->selectedObjects( selected );
1012 if ( selected.Extent() >= 1 ) {
1013 SUIT_OverrideCursor wc;
1014 SALOME_ListIteratorOfListIO It( selected );
1015 for( ; It.More(); It.Next()){
1016 Handle(SALOME_InteractiveObject) IObject = It.Value();
1017 if(IObject->hasEntry()){
1018 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1019 unsigned int aMode = anActor->GetEntityMode();
1020 switch(theCommandID){
1021 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1022 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1023 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1024 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1025 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1026 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1029 anActor->SetEntityMode(aMode);
1038 SalomeApp_Application* app =
1039 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1043 LightApp_SelectionMgr* aSel = app->selectionMgr();
1044 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1045 if ( !aSel || !appStudy )
1048 SALOME_ListIO selected;
1049 aSel->selectedObjects( selected );
1050 if ( selected.IsEmpty() )
1053 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1055 _PTR(Study) aStudy = appStudy->studyDS();
1056 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1057 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1058 if ( aMainObject->_is_nil() )
1061 SUIT_OverrideCursor wc;
1063 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1065 QList<SALOMEDS::Color> aReservedColors;
1067 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1068 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1070 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1072 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1073 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1074 #else // old algorithm for auto-colors
1075 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1076 aReservedColors.append( aColor );
1077 #endif // SIMPLE_AUTOCOLOR
1078 aGroupObject->SetColor( aColor );
1080 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1081 if ( aGroupSObject ) {
1084 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1085 switch ( aGroupObject->GetType ()) {
1087 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1089 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1091 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1093 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1095 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1096 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1099 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1100 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1106 SMESH::RepaintCurrentView();
1109 void OverallMeshQuality()
1111 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1112 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1113 SALOME_ListIO selected;
1115 aSel->selectedObjects( selected );
1117 if ( selected.IsEmpty() ) return;
1118 SALOME_ListIteratorOfListIO It( selected );
1119 for ( ; It.More(); It.Next() ) {
1120 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1121 ctrlDlg->showInfo( It.Value() );
1126 QString functorToString( SMESH::Controls::FunctorPtr f )
1128 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1129 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1130 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1131 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1132 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1133 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1134 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1135 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1136 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1137 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1138 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1139 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1140 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1141 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1142 type = QObject::tr( "WARP_ELEMENTS" );
1143 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1144 type = QObject::tr( "TAPER_ELEMENTS" );
1145 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1146 type = QObject::tr( "SKEW_ELEMENTS" );
1147 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1148 type = QObject::tr( "AREA_ELEMENTS" );
1149 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1150 type = QObject::tr( "LENGTH_EDGES" );
1151 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1152 type = QObject::tr( "LENGTH2D_EDGES" );
1153 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1154 type = QObject::tr( "DEFLECTION2D_FACES" );
1155 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1156 type = QObject::tr( "MULTI_BORDERS" );
1157 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1158 type = QObject::tr( "MULTI2D_BORDERS" );
1159 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1160 type = QObject::tr( "FREE_NODES" );
1161 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1162 type = QObject::tr( "FREE_EDGES" );
1163 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1164 type = QObject::tr( "FREE_BORDERS" );
1165 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1166 type = QObject::tr( "FREE_FACES" );
1167 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1168 type = QObject::tr( "BARE_BORDER_VOLUME" );
1169 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1170 type = QObject::tr( "BARE_BORDER_FACE" );
1171 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1172 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1173 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1174 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1175 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1176 type = QObject::tr( "EQUAL_NODE" );
1177 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1178 type = QObject::tr( "EQUAL_EDGE" );
1179 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1180 type = QObject::tr( "EQUAL_FACE" );
1181 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1182 type = QObject::tr( "EQUAL_VOLUME" );
1183 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1184 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1188 void SaveDistribution()
1190 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1191 SALOME_ListIO selected;
1193 aSel->selectedObjects( selected );
1195 if ( selected.Extent() == 1 ) {
1196 Handle(SALOME_InteractiveObject) anIO = selected.First();
1197 if ( anIO->hasEntry() ) {
1198 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1200 anActor->GetScalarBarActor() &&
1201 anActor->GetControlMode() != SMESH_Actor::eNone )
1203 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1204 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1205 if ( aScalarBarActor && aFunctor ) {
1206 SMESH::Controls::NumericalFunctor* aNumFun =
1207 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1209 std::vector<int> elements;
1210 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1211 if ( mesh->_is_nil() ) {
1212 SMESH::SMESH_IDSource_var idSource =
1213 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1214 if ( !idSource->_is_nil() )
1216 SMESH::long_array_var ids = idSource->GetIDs();
1217 elements.resize( ids->length() );
1218 for ( unsigned i = 0; i < elements.size(); ++i )
1219 elements[i] = ids[i];
1222 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1223 vtkLookupTable* lookupTable =
1224 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1225 double * minmax = lookupTable->GetRange();
1226 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1227 std::vector<int> nbEvents;
1228 std::vector<double> funValues;
1229 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1230 elements, minmax, isLogarithmic );
1231 QString anInitialPath = "";
1232 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1233 anInitialPath = QDir::currentPath();
1234 QString aMeshName = anIO->getName();
1236 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1237 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1238 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1239 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1240 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1243 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1245 if ( !aFilename.isEmpty() ) {
1246 QFile f( aFilename );
1247 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1248 QTextStream out( &f );
1249 out << "# Mesh: " << aMeshName << endl;
1250 out << "# Control: " << functorToString( aFunctor ) << endl;
1252 out.setFieldWidth( 10 );
1253 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1254 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1265 void ShowElement( int theCommandID )
1267 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1268 SALOME_ListIO selected;
1270 aSel->selectedObjects( selected );
1272 if ( selected.Extent() == 1 ) {
1273 Handle(SALOME_InteractiveObject) anIO = selected.First();
1274 if ( anIO->hasEntry() ) {
1275 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1277 anActor->GetScalarBarActor() &&
1278 anActor->GetControlMode() != SMESH_Actor::eNone )
1280 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1281 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1282 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1284 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1285 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1292 #ifndef DISABLE_PLOT2DVIEWER
1293 void PlotDistribution()
1295 SalomeApp_Application* app =
1296 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1300 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1301 SALOME_ListIO selected;
1303 aSel->selectedObjects( selected );
1305 if ( selected.Extent() == 1 ) {
1306 Handle(SALOME_InteractiveObject) anIO = selected.First();
1307 if ( anIO->hasEntry() ) {
1308 //Find Actor by entry before getting Plot2d viewer,
1309 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1310 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1312 SUIT_ViewManager* aViewManager =
1313 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1317 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1321 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1325 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1327 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1328 QString functorName = functorToString( anActor->GetFunctor());
1329 QString aHistogramName("%1 : %2");
1330 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1331 aHistogram->setName(aHistogramName);
1332 aHistogram->setHorTitle(functorName);
1333 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1334 aPlot->displayObject(aHistogram, true);
1339 #endif //DISABLE_PLOT2DVIEWER
1341 void DisableAutoColor()
1343 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1344 SALOME_ListIO selected;
1346 aSel->selectedObjects( selected );
1348 if ( selected.Extent() ) {
1349 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1350 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1351 if ( !aMesh->_is_nil() ) {
1352 aMesh->SetAutoColor( false );
1359 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1360 SALOME_ListIO selected;
1362 aSel->selectedObjects( selected );
1363 if ( selected.Extent() )
1365 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1366 _PTR(Study) aStudy = SMESH::getStudy();
1367 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1369 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1370 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1377 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1379 SALOME_ListIO selected;
1380 SalomeApp_Application* app =
1381 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1385 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1386 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1387 if ( !aSel || !appStudy )
1390 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1391 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1392 aModule->EmitSignalDeactivateDialog();
1393 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1394 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1399 aSel->selectedObjects( selected );
1401 if ( selected.Extent() >= 1 )
1403 switch ( theCommandID ) {
1404 case SMESHOp::OpTransparency:
1406 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1407 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1410 case SMESHOp::OpProperties:
1413 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1414 QColor orientationColor, outlineColor, volumeColor;
1415 int deltaF = 0, deltaV = 0;
1418 double ballScale = 1.0;
1420 int outlineWidth = 1;
1421 double shrinkCoef = 0.0;
1422 double orientationScale = 0.0;
1423 bool orientation3d = false;
1424 VTK::MarkerType markerType = VTK::MT_NONE;
1425 VTK::MarkerScale markerScale = VTK::MS_NONE;
1427 bool hasNodes = false;
1428 int presentEntities = 0;
1429 bool firstTime = true;
1431 SALOME_ListIteratorOfListIO It( selected );
1432 for ( ; It.More(); It.Next() ) {
1433 Handle(SALOME_InteractiveObject) IObject = It.Value();
1434 if ( !IObject->hasEntry() ) continue;
1435 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1436 if ( !anActor || !anActor->GetObject() ) continue;
1439 // nodes: color, marker
1440 anActor->GetNodeColor( color[0], color[1], color[2] );
1441 nodeColor.setRgbF( color[0], color[1], color[2] );
1442 markerType = anActor->GetMarkerType();
1443 markerScale = anActor->GetMarkerScale();
1444 markerId = anActor->GetMarkerTexture();
1445 // edges: color, width
1446 anActor->GetEdgeColor( color[0], color[1], color[2] );
1447 edgeColor.setRgbF( color[0], color[1], color[2] );
1448 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1449 // faces: front color, back color (delta)
1450 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1451 faceColor.setRgbF( color[0], color[1], color[2] );
1452 // faces: front color, back color (delta)
1453 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1454 volumeColor.setRgbF( color[0], color[1], color[2] );
1455 // 0d elements: color, size
1456 anActor->Get0DColor( color[0], color[1], color[2] );
1457 elem0dColor.setRgbF( color[0], color[1], color[2] );
1458 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1459 // balls: color, size
1460 anActor->GetBallColor( color[0], color[1], color[2] );
1461 ballColor.setRgbF( color[0], color[1], color[2] );
1462 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1463 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1465 anActor->GetOutlineColor( color[0], color[1], color[2] );
1466 outlineColor.setRgbF( color[0], color[1], color[2] );
1467 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1468 // orientation vectors: color, scale, 3d flag
1469 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1470 orientationColor.setRgbF( color[0], color[1], color[2] );
1471 orientationScale = anActor->GetFacesOrientationScale();
1472 orientation3d = anActor->GetFacesOrientation3DVectors();
1474 shrinkCoef = anActor->GetShrinkFactor();
1477 firstTime = false; // we only take properties from first object (for performance reasons)
1480 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1481 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1482 presentEntities = presentEntities | SMESH_Actor::eEdges;
1483 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1484 presentEntities = presentEntities | SMESH_Actor::eFaces;
1485 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1486 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1487 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1488 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1489 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1490 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1492 // as we know that all types of elements are present, we can exit the loop
1493 if ( presentEntities == SMESH_Actor::eAllEntity )
1497 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1498 // nodes: color, marker
1499 dlg.setNodeColor( nodeColor );
1500 if( markerType != VTK::MT_USER )
1501 dlg.setNodeMarker( markerType, markerScale );
1503 dlg.setNodeCustomMarker( markerId );
1504 // edges: color, line width
1505 dlg.setEdgeColor( edgeColor );
1506 dlg.setEdgeWidth( edgeWidth );
1507 // faces: front color, back color
1508 dlg.setFaceColor( faceColor, deltaF );
1509 // volumes: normal color, reversed color
1510 dlg.setVolumeColor( volumeColor, deltaV );
1511 // outlines: color, line width
1512 dlg.setOutlineColor( outlineColor );
1513 dlg.setOutlineWidth( outlineWidth );
1514 // 0d elements: color, size
1515 dlg.setElem0dColor( elem0dColor );
1516 dlg.setElem0dSize( elem0dSize );
1517 // balls: color, size
1518 dlg.setBallColor( ballColor );
1519 //dlg.setBallSize( ballSize );
1520 dlg.setBallScale( ballScale );
1521 // orientation: color, scale, 3d flag
1522 dlg.setOrientationColor( orientationColor );
1523 dlg.setOrientationSize( int( orientationScale * 100. ) );
1524 dlg.setOrientation3d( orientation3d );
1525 // shrink: scale factor
1526 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1527 // hide unused controls
1528 dlg.showControls( presentEntities, hasNodes );
1531 nodeColor = dlg.nodeColor();
1532 markerType = dlg.nodeMarkerType();
1533 markerScale = dlg.nodeMarkerScale();
1534 markerId = dlg.nodeMarkerId();
1535 edgeColor = dlg.edgeColor();
1536 edgeWidth = dlg.edgeWidth();
1537 faceColor = dlg.faceColor();
1538 deltaF = dlg.faceColorDelta();
1539 volumeColor = dlg.volumeColor();
1540 deltaV = dlg.volumeColorDelta();
1541 outlineColor = dlg.outlineColor();
1542 outlineWidth = dlg.outlineWidth();
1543 elem0dColor = dlg.elem0dColor();
1544 elem0dSize = dlg.elem0dSize();
1545 ballColor = dlg.ballColor();
1546 // ballSize = dlg.ballSize();
1547 ballScale = dlg.ballScale();
1548 orientationColor = dlg.orientationColor();
1549 orientationScale = dlg.orientationSize() / 100.;
1550 orientation3d = dlg.orientation3d();
1551 shrinkCoef = dlg.shrinkCoef() / 100.;
1553 // store point markers that might be changed by the user
1554 theMarkerMap = dlg.customMarkers();
1556 // set properties from dialog box to the presentations
1557 SALOME_ListIteratorOfListIO It( selected );
1558 for ( ; It.More(); It.Next() ) {
1559 Handle(SALOME_InteractiveObject) IObject = It.Value();
1560 if ( !IObject->hasEntry() ) continue;
1561 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1562 if ( !anActor ) continue;
1564 // nodes: color, marker
1565 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1566 if ( markerType != VTK::MT_USER ) {
1567 anActor->SetMarkerStd( markerType, markerScale );
1570 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1571 if ( iter != theMarkerMap.end() )
1572 anActor->SetMarkerTexture( markerId, iter->second.second );
1574 // volumes: normal color, reversed color (delta)
1575 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1576 // faces: front color, back color (delta)
1577 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1578 // edges: color, width
1579 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1580 anActor->SetLineWidth( edgeWidth );
1582 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1583 anActor->SetOutlineWidth( outlineWidth );
1584 // 0D elements: color, size
1585 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1586 anActor->Set0DSize( elem0dSize );
1587 // balls: color, size
1588 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1589 // anActor->SetBallSize( ballSize );
1590 anActor->SetBallScale( ballScale );
1591 // orientation: color, scale, 3d flag
1592 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1593 anActor->SetFacesOrientationScale( orientationScale );
1594 anActor->SetFacesOrientation3DVectors( orientation3d );
1596 anActor->SetShrinkFactor( shrinkCoef );
1598 // for groups, set also proper color
1599 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1600 if ( !aGroupObject->_is_nil() ) {
1601 SMESH::ElementType anElementType = aGroupObject->GetType();
1603 switch( anElementType ) {
1605 aColor = nodeColor; break;
1607 aColor = edgeColor; break;
1609 aColor = faceColor; break;
1611 aColor = volumeColor; break;
1613 aColor = elem0dColor; break;
1615 aColor = ballColor; break;
1619 if ( aColor.isValid() ) {
1620 SALOMEDS::Color aGroupColor;
1621 aGroupColor.R = aColor.redF();
1622 aGroupColor.G = aColor.greenF();
1623 aGroupColor.B = aColor.blueF();
1624 aGroupObject->SetColor( aGroupColor );
1626 } // if ( !aGroupObject->_is_nil() )
1627 } // for ( ; It.More(); It.Next() )
1628 SMESH::RepaintCurrentView();
1629 } // if ( dlg.exec() )
1631 } // case SMESHOp::OpProperties:
1632 } // switch(theCommandID)
1633 SUIT_OverrideCursor wc;
1634 SALOME_ListIteratorOfListIO It( selected );
1635 for( ; It.More(); It.Next()){
1636 Handle(SALOME_InteractiveObject) IObject = It.Value();
1637 if(IObject->hasEntry()){
1638 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1639 switch(theCommandID){
1640 case SMESHOp::OpDMWireframe:
1641 anActor->SetRepresentation(SMESH_Actor::eEdge);
1643 case SMESHOp::OpDMShading:
1644 anActor->SetRepresentation(SMESH_Actor::eSurface);
1646 case SMESHOp::OpDMShrink:
1647 if(anActor->IsShrunk())
1648 anActor->UnShrink();
1650 anActor->SetShrink();
1652 case SMESHOp::OpDMNodes:
1653 anActor->SetRepresentation(SMESH_Actor::ePoint);
1655 case SMESHOp::OpRepresentationLines:
1656 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1657 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1659 case SMESHOp::OpRepresentationArcs:
1660 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1661 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1667 SMESH::RepaintCurrentView();
1671 int ActionToControl( int theID, bool theReversed )
1673 NCollection_DoubleMap<int,int> ActionControl;
1674 ActionControl.Bind( 0, SMESH_Actor::eNone );
1675 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1676 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1677 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1678 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1679 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1680 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1681 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1682 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1683 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1684 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1685 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1686 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1687 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1688 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1689 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1690 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1691 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1692 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1693 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1694 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1695 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1696 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1697 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1698 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1699 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1700 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1701 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1702 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1705 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1706 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1709 void Control( int theCommandID )
1711 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1712 _PTR(Study) aStudy = SMESH::getStudy();
1714 SALOME_ListIO selected;
1715 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1716 aSel->selectedObjects( selected );
1718 if ( !selected.IsEmpty() ) {
1719 SALOME_ListIteratorOfListIO It(selected);
1720 for ( ; It.More(); It.Next())
1722 Handle(SALOME_InteractiveObject) anIO = It.Value();
1723 if ( !anIO.IsNull() ) {
1724 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1726 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1727 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1728 if ( !anIDSrc->_is_nil() ) {
1729 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1730 if (( !anActor && selected.Extent() == 1 ) &&
1731 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1733 anActor->SetControlMode( aControl );
1734 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1735 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1739 if ( anActor->GetControlMode() != aControl )
1740 anActor->SetControlMode( aControl );
1741 QString functorName = functorToString( anActor->GetFunctor() );
1742 int anEntitiesCount = anActor->GetNumberControlEntities();
1743 if (anEntitiesCount >= 0)
1744 functorName = functorName + ": " + QString::number(anEntitiesCount);
1745 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1746 SMESH::RepaintCurrentView();
1747 #ifndef DISABLE_PLOT2DVIEWER
1748 if ( anActor->GetPlot2Histogram() ) {
1749 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1750 QString aHistogramName("%1 : %2");
1751 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1752 aHistogram->setName( aHistogramName );
1753 aHistogram->setHorTitle( functorName );
1754 SMESH::ProcessIn2DViewers( anActor );
1766 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1767 SMESH::MeshObjectType theType,
1768 const QString theInTypeName,
1769 QString & theOutTypeName)
1771 SMESH_TypeFilter aTypeFilter( theType );
1773 if ( !theIO.IsNull() )
1775 entry = theIO->getEntry();
1776 LightApp_DataOwner owner( entry );
1777 if ( aTypeFilter.isOk( &owner )) {
1778 theOutTypeName = theInTypeName;
1786 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1788 _PTR(Study) aStudy = SMESH::getStudy();
1789 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1791 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1792 CORBA::String_var anID = aSComp->GetID().c_str();
1793 if ( !strcmp(anID.in(),theIO->getEntry()) )
1799 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1800 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1801 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1802 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1803 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1811 // QString CheckHomogeneousSelection()
1813 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1814 // SALOME_ListIO selected;
1816 // aSel->selectedObjects( selected );
1818 // QString RefType = CheckTypeObject(selected.First());
1819 // SALOME_ListIteratorOfListIO It(selected);
1820 // for ( ; It.More(); It.Next())
1822 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1823 // QString Type = CheckTypeObject(IObject);
1824 // if ( Type.compare(RefType) != 0 )
1825 // return "Heterogeneous Selection";
1831 uint randomize( uint size )
1833 static bool initialized = false;
1834 if ( !initialized ) {
1835 qsrand( QDateTime::currentDateTime().toTime_t() );
1839 v = uint( (double)( v ) / RAND_MAX * size );
1840 v = qMax( uint(0), qMin ( v, size-1 ) );
1846 void SMESHGUI::OnEditDelete()
1848 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1849 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1850 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1852 _PTR(Study) aStudy = SMESH::getStudy();
1853 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1854 _PTR(GenericAttribute) anAttr;
1855 _PTR(AttributeIOR) anIOR;
1857 int objectCount = 0;
1859 QString aParentComponent = QString::null;
1861 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1863 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1864 if ( anIO.IsNull() ) continue;
1866 QString father = "unknown";
1868 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1870 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1871 // check if object is reference
1872 _PTR(SObject) aRefSObj;
1873 aNameList.append("\n - ");
1874 if ( aSO->ReferencedObject( aRefSObj ) ) {
1875 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1876 aNameList.append( aRefName );
1877 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1880 aNameList.append(anIO->getName());
1884 if( aParentComponent.isNull() )
1885 aParentComponent = father;
1886 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1887 aParentComponent = "";
1890 if ( objectCount == 0 )
1891 return; // No Valid Objects Selected
1893 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1894 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1895 QObject::tr("ERR_ERROR"),
1896 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1899 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1900 if (SUIT_MessageBox::warning
1901 (SMESHGUI::desktop(),
1902 QObject::tr("SMESH_WRN_WARNING"),
1903 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1904 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1905 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1908 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1910 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1911 // then treat them all starting from the deepest objects (at list back)
1912 std::list< _PTR(SObject) > listSO;
1913 SALOME_ListIteratorOfListIO It(selected);
1914 for( ; It.More(); It.Next()) // loop on selected IO's
1916 Handle(SALOME_InteractiveObject) IObject = It.Value();
1917 if(IObject->hasEntry()) {
1918 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1920 // disable removal of "SMESH" component object
1921 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1923 if ( engineIOR() == anIOR->Value().c_str() )
1926 //Check the referenced object
1927 _PTR(SObject) aRefSObject;
1928 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1929 aSO = aRefSObject; // Delete main Object instead of reference
1931 listSO.push_back( aSO );
1932 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1933 for ( ; itSO != listSO.end(); ++itSO ) {
1934 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1935 for (it->InitEx(false); it->More(); it->Next())
1936 listSO.push_back( it->Value() );
1940 // Check if none of objects to delete is referred from outside
1941 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1942 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1944 _PTR(SObject) SO = *ritSO;
1945 if ( !SO ) continue;
1946 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1947 for (size_t i = 0; i < aReferences.size(); i++) {
1948 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1949 std::string type = aComponent->ComponentDataType();
1950 if ( type != "SMESH" )
1952 SUIT_MessageBox::warning( anApp->desktop(),
1953 QObject::tr("WRN_WARNING"),
1954 QObject::tr("DEP_OBJECT") );
1955 return; // outside SMESH, there is an object depending on a SMESH object
1960 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1961 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1963 Handle(SALOME_InteractiveObject) IObject = It.Value();
1964 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1965 if ( !mesh->_is_nil() )
1969 // Treat SO's in the list starting from the back
1970 aStudyBuilder->NewCommand(); // There is a transaction
1971 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1973 _PTR(SObject) SO = *ritSO;
1974 if ( !SO ) continue;
1975 std::string anEntry = SO->GetID();
1977 /** Erase graphical object and remove all its data **/
1978 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1979 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1981 /** Remove an object from data structures **/
1982 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1983 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1984 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1985 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1986 aMesh->RemoveGroup( aGroup );
1988 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1989 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1990 aMesh->RemoveSubMesh( aSubMesh );
1993 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1994 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1995 QString objType = CheckTypeObject(IObject);
1996 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1997 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1998 aStudyBuilder->RemoveObjectWithChildren( SO );
2000 else {// default action: remove SObject from the study
2001 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2002 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2004 aStudyBuilder->RemoveObjectWithChildren( SO );
2008 } /* listSO back loop */
2010 aStudyBuilder->CommitCommand();
2012 /* Clear any previous selection */
2014 aSel->setSelectedObjects( l1 );
2016 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2020 SMESHGUI_EXPORT CAM_Module* createModule()
2022 return new SMESHGUI();
2025 SMESHGUI_EXPORT char* getModuleVersion() {
2026 return (char*)SMESH_VERSION_STR;
2030 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2032 //=============================================================================
2036 //=============================================================================
2037 SMESHGUI::SMESHGUI() :
2038 SalomeApp_Module( "SMESH" )
2040 if ( CORBA::is_nil( myComponentSMESH ) )
2042 CORBA::Boolean anIsEmbeddedMode;
2043 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2044 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2046 // 0019923: EDF 765 SMESH : default values of hypothesis
2047 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2048 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2049 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2050 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2051 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2053 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2054 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2055 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2057 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2058 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2062 myActiveDialogBox = 0;
2063 myFilterLibraryDlg = 0;
2067 myEventCallbackCommand = vtkCallbackCommand::New();
2068 myEventCallbackCommand->Delete();
2069 myEventCallbackCommand->SetClientData( this );
2070 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2073 /* load resources for all available meshers */
2074 SMESH::InitAvailableHypotheses();
2077 //=============================================================================
2081 //=============================================================================
2082 SMESHGUI::~SMESHGUI()
2086 //=============================================================================
2090 //=============================================================================
2091 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2093 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2095 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2100 //=============================================================================
2104 //=============================================================================
2105 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2107 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2111 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2112 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2113 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2114 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2115 return autoUpdate && !exceeded;
2118 //=============================================================================
2122 //=============================================================================
2123 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2124 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2126 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2130 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2131 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2132 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2134 SMESH::long_array_var info = theMesh->GetMeshInfo();
2135 long nbOdElems = info[SMDSEntity_0D];
2136 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2137 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2138 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2139 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2140 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2141 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2142 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2143 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2144 info[SMDSEntity_Polyhedra] +
2145 info[SMDSEntity_Hexagonal_Prism];
2146 long nbBalls = info[SMDSEntity_Ball];
2148 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2149 *nbElements = requestedSize;
2151 *entities = SMESH_Actor::eAllEntity;
2154 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2156 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2158 if ( incrementalLimit ) {
2161 if ( nbOdElems > 0 ) {
2162 if ( total + nbOdElems > updateLimit ) {
2163 *entities = *entities & ~SMESH_Actor::e0DElements;
2164 *hidden = *hidden | SMESH_Actor::e0DElements;
2171 if ( nbEdges > 0 ) {
2172 if ( total + nbEdges > updateLimit ) {
2173 *entities = *entities & ~SMESH_Actor::eEdges;
2174 *hidden = *hidden | SMESH_Actor::eEdges;
2181 if ( nbFaces > 0 ) {
2182 if ( total + nbFaces > updateLimit ) {
2183 *entities = *entities & ~SMESH_Actor::eFaces;
2184 *hidden = *hidden | SMESH_Actor::eFaces;
2191 if ( nbVolumes > 0 ) {
2192 if ( total + nbVolumes > updateLimit ) {
2193 *entities = *entities & ~SMESH_Actor::eVolumes;
2194 *hidden = *hidden | SMESH_Actor::eVolumes;
2201 if ( nbBalls > 0 ) {
2202 if ( total + nbBalls > updateLimit ) {
2203 *entities = *entities & ~SMESH_Actor::eBallElem;
2204 *hidden = *hidden | SMESH_Actor::eBallElem;
2212 return autoUpdate && !exceeded;
2215 //=============================================================================
2219 //=============================================================================
2220 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2222 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2225 //=============================================================================
2229 //=============================================================================
2230 SMESHGUI* SMESHGUI::GetSMESHGUI()
2232 SMESHGUI* smeshMod = 0;
2233 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2236 CAM_Module* module = app->module( "Mesh" );
2237 smeshMod = dynamic_cast<SMESHGUI*>( module );
2245 Standard_EXPORT SMESHGUI* GetComponentGUI()
2247 return SMESHGUI::GetSMESHGUI();
2251 //=============================================================================
2255 //=============================================================================
2256 void SMESHGUI::SetState(int aState)
2261 //=============================================================================
2265 //=============================================================================
2266 void SMESHGUI::ResetState()
2271 //=============================================================================
2275 //=============================================================================
2276 void SMESHGUI::EmitSignalDeactivateDialog()
2278 emit SignalDeactivateActiveDialog();
2281 //=============================================================================
2285 //=============================================================================
2286 void SMESHGUI::EmitSignalStudyFrameChanged()
2288 emit SignalStudyFrameChanged();
2291 //=============================================================================
2295 //=============================================================================
2296 void SMESHGUI::EmitSignalCloseAllDialogs()
2298 emit SignalCloseAllDialogs();
2301 //=============================================================================
2305 //=============================================================================
2306 void SMESHGUI::EmitSignalVisibilityChanged()
2308 emit SignalVisibilityChanged();
2311 //=============================================================================
2315 //=============================================================================
2316 void SMESHGUI::EmitSignalCloseView()
2318 emit SignalCloseView();
2321 //=============================================================================
2325 //=============================================================================
2326 void SMESHGUI::EmitSignalActivatedViewManager()
2328 emit SignalActivatedViewManager();
2331 //=============================================================================
2335 //=============================================================================
2336 QDialog *SMESHGUI::GetActiveDialogBox()
2338 return myActiveDialogBox;
2341 //=============================================================================
2345 //=============================================================================
2346 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2348 myActiveDialogBox = (QDialog *) aDlg;
2352 //=============================================================================
2356 //=============================================================================
2357 SUIT_Desktop* SMESHGUI::desktop()
2359 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2361 return app->desktop();
2366 //=============================================================================
2370 //=============================================================================
2371 SalomeApp_Study* SMESHGUI::activeStudy()
2373 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2375 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2380 //=============================================================================
2384 //=============================================================================
2385 void SMESHGUI::Modified( bool theIsUpdateActions )
2387 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2388 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2389 appStudy->Modified();
2390 if( theIsUpdateActions )
2391 app->updateActions();
2396 //=============================================================================
2400 //=============================================================================
2401 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2403 /* Here the position is on the bottom right corner - 10 */
2404 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2406 SUIT_Desktop *PP = desktop();
2407 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2408 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2413 * \brief Verifies whether study of operation is locked
2414 * \param theMess - specifies whether message box must be shown if study is locked
2415 * \return State of study.
2417 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2418 * is locked when corresponding message box appears
2420 bool SMESHGUI::isStudyLocked( bool theMessage )
2422 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2425 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2426 QObject::tr( "WRN_WARNING" ),
2427 QObject::tr( "WRN_STUDY_LOCKED" ) );
2433 //=============================================================================
2437 //=============================================================================
2438 bool SMESHGUI::OnGUIEvent( int theCommandID )
2440 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2444 SUIT_ResourceMgr* mgr = resourceMgr();
2448 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2449 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2451 //QAction* act = action( theCommandID );
2453 switch (theCommandID) {
2454 case SMESHOp::OpDelete:
2455 if(isStudyLocked()) break;
2458 case SMESHOp::OpImportDAT:
2459 case SMESHOp::OpImportUNV:
2460 case SMESHOp::OpImportMED:
2461 case SMESHOp::OpImportSTL:
2462 case SMESHOp::OpImportCGNS:
2463 case SMESHOp::OpImportSAUV:
2464 case SMESHOp::OpImportGMF:
2465 case SMESHOp::OpPopupImportDAT:
2466 case SMESHOp::OpPopupImportUNV:
2467 case SMESHOp::OpPopupImportMED:
2468 case SMESHOp::OpPopupImportSTL:
2469 case SMESHOp::OpPopupImportCGNS:
2470 case SMESHOp::OpPopupImportSAUV:
2471 case SMESHOp::OpPopupImportGMF:
2473 if(isStudyLocked()) break;
2474 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2478 case SMESHOp::OpFileInformation:
2480 SALOME_ListIO selected;
2481 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2483 aSel->selectedObjects( selected );
2484 if( selected.Extent() )
2486 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2487 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2488 if ( !aMesh->_is_nil() )
2490 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2496 case SMESHOp::OpExportDAT:
2497 case SMESHOp::OpExportMED:
2498 case SMESHOp::OpExportUNV:
2499 case SMESHOp::OpExportSTL:
2500 case SMESHOp::OpExportCGNS:
2501 case SMESHOp::OpExportSAUV:
2502 case SMESHOp::OpExportGMF:
2503 case SMESHOp::OpPopupExportDAT:
2504 case SMESHOp::OpPopupExportMED:
2505 case SMESHOp::OpPopupExportUNV:
2506 case SMESHOp::OpPopupExportSTL:
2507 case SMESHOp::OpPopupExportCGNS:
2508 case SMESHOp::OpPopupExportSAUV:
2509 case SMESHOp::OpPopupExportGMF:
2511 ::ExportMeshToFile(theCommandID);
2515 case SMESHOp::OpReset: // SCALAR BAR
2517 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2518 SALOME_ListIO selected;
2520 aSel->selectedObjects( selected );
2522 SALOME_ListIteratorOfListIO it(selected);
2523 for( ; it.More(); it.Next()) {
2524 Handle(SALOME_InteractiveObject) anIO = it.Value();
2525 if( anIO->hasEntry() ) {
2526 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2527 anActor->SetControlMode( SMESH_Actor::eNone );
2528 #ifndef DISABLE_PLOT2DVIEWER
2529 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2534 SMESH::UpdateView();
2537 case SMESHOp::OpScalarBarProperties:
2539 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2542 case SMESHOp::OpShowScalarBar:
2544 // show/hide scalar bar
2545 ::ShowElement(theCommandID);
2548 case SMESHOp::OpSaveDistribution:
2550 // dump control distribution data to the text file
2551 ::SaveDistribution();
2555 case SMESHOp::OpShowDistribution:
2557 // show/hide distribution
2558 ::ShowElement(theCommandID);
2562 #ifndef DISABLE_PLOT2DVIEWER
2563 case SMESHOp::OpPlotDistribution:
2565 // plot distribution
2566 ::PlotDistribution();
2572 case SMESHOp::OpAutoColor:
2576 case SMESHOp::OpDisableAutoColor:
2577 ::DisableAutoColor();
2580 case SMESHOp::OpClipping:
2581 case SMESHOp::OpTransparency:
2582 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2585 case SMESHOp::OpDMWireframe:
2586 case SMESHOp::OpDMShading:
2587 case SMESHOp::OpDMNodes:
2588 case SMESHOp::OpDMShrink:
2589 ::SetDisplayMode(theCommandID, myMarkerMap);
2592 //2D quadratic representation
2593 case SMESHOp::OpRepresentationLines:
2594 case SMESHOp::OpRepresentationArcs:
2595 ::SetDisplayMode(theCommandID, myMarkerMap);
2599 case SMESHOp::OpDE0DElements:
2600 case SMESHOp::OpDEEdges:
2601 case SMESHOp::OpDEFaces:
2602 case SMESHOp::OpDEVolumes:
2603 case SMESHOp::OpDEBalls:
2604 case SMESHOp::OpDEAllEntity:
2605 ::SetDisplayEntity(theCommandID);
2608 // Choose entities to be displayed
2609 case SMESHOp::OpDEChoose:
2611 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2615 case SMESHOp::OpOrientationOnFaces:
2617 SUIT_OverrideCursor wc;
2618 LightApp_SelectionMgr* mgr = selectionMgr();
2619 SALOME_ListIO selected; mgr->selectedObjects( selected );
2621 SALOME_ListIteratorOfListIO it(selected);
2622 for( ; it.More(); it.Next()) {
2623 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2624 if(anIObject->hasEntry()) {
2625 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2626 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2633 case SMESHOp::OpUpdate:
2635 if(isStudyLocked()) break;
2636 SUIT_OverrideCursor wc;
2639 SMESH::UpdateView();
2641 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2642 SMESH::OnVisuException();
2644 catch (...) { // PAL16774 (Crash after display of many groups)
2645 SMESH::OnVisuException();
2649 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2650 aSel->selectedObjects( l );
2651 aSel->setSelectedObjects( l );
2655 case SMESHOp::OpHide:
2656 case SMESHOp::OpShow:
2657 case SMESHOp::OpShowOnly:
2659 SUIT_OverrideCursor wc;
2660 SMESH::EDisplaing anAction;
2661 switch (theCommandID) {
2662 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2663 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2664 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2667 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2668 SALOME_ListIO sel_objects, to_process;
2670 aSel->selectedObjects( sel_objects );
2672 if ( theCommandID==SMESHOp::OpShowOnly )
2674 //MESSAGE("anAction = SMESH::eDisplayOnly");
2675 startOperation( myEraseAll );
2678 extractContainers( sel_objects, to_process );
2683 SALOME_ListIteratorOfListIO It( to_process );
2684 for ( ; It.More(); It.Next())
2686 Handle(SALOME_InteractiveObject) IOS = It.Value();
2687 if ( IOS->hasEntry() )
2689 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2690 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2691 break; // PAL16774 (Crash after display of many groups)
2693 if (anAction == SMESH::eDisplayOnly)
2694 anAction = SMESH::eDisplay;
2699 // PAL13338 + PAL15161 -->
2700 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2701 SMESH::UpdateView();
2702 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2704 // PAL13338 + PAL15161 <--
2706 catch (...) { // PAL16774 (Crash after display of many groups)
2707 SMESH::OnVisuException();
2710 if (anAction == SMESH::eErase) {
2712 aSel->setSelectedObjects( l1 );
2715 aSel->setSelectedObjects( to_process );
2720 case SMESHOp::OpNode:
2722 if(isStudyLocked()) break;
2725 EmitSignalDeactivateDialog();
2727 ( new SMESHGUI_NodesDlg( this ) )->show();
2730 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2735 case SMESHOp::OpCreateMesh:
2736 case SMESHOp::OpCreateSubMesh:
2737 case SMESHOp::OpEditMeshOrSubMesh:
2738 case SMESHOp::OpEditMesh:
2739 case SMESHOp::OpEditSubMesh:
2740 case SMESHOp::OpCompute:
2741 case SMESHOp::OpComputeSubMesh:
2742 case SMESHOp::OpPreCompute:
2743 case SMESHOp::OpEvaluate:
2744 case SMESHOp::OpMeshOrder:
2745 startOperation( theCommandID );
2747 case SMESHOp::OpCopyMesh:
2749 if (isStudyLocked()) break;
2750 EmitSignalDeactivateDialog();
2751 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2754 case SMESHOp::OpBuildCompoundMesh:
2756 if (isStudyLocked()) break;
2757 EmitSignalDeactivateDialog();
2758 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2762 case SMESHOp::OpDiagonalInversion:
2763 case SMESHOp::OpUnionOfTwoTriangle:
2767 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2771 if ( isStudyLocked() )
2774 /*Standard_Boolean aRes;
2775 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2776 if ( aMesh->_is_nil() )
2778 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2779 tr( "SMESH_BAD_SELECTION" ) );
2783 EmitSignalDeactivateDialog();
2784 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2785 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2787 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2790 case SMESHOp::OpOrientation:
2791 case SMESHOp::OpUnionOfTriangles:
2792 case SMESHOp::OpCuttingOfQuadrangles:
2793 case SMESHOp::OpSplitVolumes:
2797 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2801 if ( isStudyLocked() )
2804 EmitSignalDeactivateDialog();
2805 SMESHGUI_MultiEditDlg* aDlg = NULL;
2806 if ( theCommandID == SMESHOp::OpOrientation )
2807 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2808 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2809 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2810 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2811 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2813 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2818 case SMESHOp::OpSmoothing:
2820 if(isStudyLocked()) break;
2822 EmitSignalDeactivateDialog();
2823 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2826 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2830 case SMESHOp::OpExtrusion:
2832 if (isStudyLocked()) break;
2834 EmitSignalDeactivateDialog();
2835 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2837 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2841 case SMESHOp::OpExtrusionAlongAPath:
2843 if (isStudyLocked()) break;
2845 EmitSignalDeactivateDialog();
2846 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2848 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2852 case SMESHOp::OpRevolution:
2854 if(isStudyLocked()) break;
2856 EmitSignalDeactivateDialog();
2857 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2860 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2864 case SMESHOp::OpPatternMapping:
2866 if ( isStudyLocked() )
2870 EmitSignalDeactivateDialog();
2871 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2874 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2878 case SMESHOp::OpSplitBiQuadratic:
2879 case SMESHOp::OpConvertMeshToQuadratic:
2880 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2881 case SMESHOp::OpReorientFaces:
2882 case SMESHOp::OpCreateGeometryGroup:
2884 startOperation( theCommandID );
2887 case SMESHOp::OpCreateGroup:
2891 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2895 if(isStudyLocked()) break;
2896 EmitSignalDeactivateDialog();
2897 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2899 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2900 SALOME_ListIO selected;
2902 aSel->selectedObjects( selected );
2904 int nbSel = selected.Extent();
2906 // check if mesh is selected
2907 aMesh = SMESH::GetMeshByIO( selected.First() );
2909 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2914 case SMESHOp::OpConstructGroup:
2918 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2922 if(isStudyLocked()) break;
2923 EmitSignalDeactivateDialog();
2925 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2926 SALOME_ListIO selected;
2928 aSel->selectedObjects( selected );
2930 int nbSel = selected.Extent();
2932 // check if submesh is selected
2933 Handle(SALOME_InteractiveObject) IObject = selected.First();
2934 if (IObject->hasEntry()) {
2935 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
2937 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2938 if (!aSubMesh->_is_nil()) {
2940 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2941 // get submesh elements list by types
2942 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2943 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2944 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2945 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2946 // create group for each type o elements
2947 QString aName = IObject->getName();
2948 QStringList anEntryList;
2949 if (aNodes->length() > 0) {
2950 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2951 aGroup->Add(aNodes.inout());
2952 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2953 anEntryList.append( aSObject->GetID().c_str() );
2955 if (aEdges->length() > 0) {
2956 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2957 aGroup->Add(aEdges.inout());
2958 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2959 anEntryList.append( aSObject->GetID().c_str() );
2961 if (aFaces->length() > 0) {
2962 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2963 aGroup->Add(aFaces.inout());
2964 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2965 anEntryList.append( aSObject->GetID().c_str() );
2967 if (aVolumes->length() > 0) {
2968 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2969 aGroup->Add(aVolumes.inout());
2970 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2971 anEntryList.append( aSObject->GetID().c_str() );
2974 anApp->browseObjects( anEntryList );
2976 catch(const SALOME::SALOME_Exception & S_ex){
2977 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2984 SUIT_MessageBox::warning(desktop(),
2985 tr("SMESH_WRN_WARNING"),
2986 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2991 case SMESHOp::OpEditGroup:
2995 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2999 if(isStudyLocked()) break;
3000 EmitSignalDeactivateDialog();
3002 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3003 SALOME_ListIO selected;
3005 aSel->selectedObjects( selected );
3007 SALOME_ListIteratorOfListIO It (selected);
3008 int nbSelectedGroups = 0;
3009 for ( ; It.More(); It.Next() )
3011 SMESH::SMESH_GroupBase_var aGroup =
3012 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3013 if (!aGroup->_is_nil()) {
3015 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3019 if (nbSelectedGroups == 0)
3021 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3027 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3029 if(isStudyLocked()) break;
3030 if (myState == 800) {
3031 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3032 if (aDlg) aDlg->onAdd();
3037 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3039 if(isStudyLocked()) break;
3040 if (myState == 800) {
3041 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3042 if (aDlg) aDlg->onRemove();
3047 case SMESHOp::OpEditGeomGroupAsGroup:
3051 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3055 if(isStudyLocked()) break;
3056 EmitSignalDeactivateDialog();
3058 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3059 SALOME_ListIO selected;
3061 aSel->selectedObjects( selected );
3063 SALOME_ListIteratorOfListIO It (selected);
3064 for ( ; It.More(); It.Next() )
3066 SMESH::SMESH_GroupOnGeom_var aGroup =
3067 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3068 if (!aGroup->_is_nil()) {
3069 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3074 SMESH::SMESH_GroupOnFilter_var aGroup =
3075 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3076 if (!aGroup->_is_nil()) {
3077 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3085 case SMESHOp::OpUnionGroups:
3086 case SMESHOp::OpIntersectGroups:
3087 case SMESHOp::OpCutGroups:
3091 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3095 if ( isStudyLocked() )
3098 EmitSignalDeactivateDialog();
3100 SMESHGUI_GroupOpDlg* aDlg = 0;
3101 if ( theCommandID == SMESHOp::OpUnionGroups )
3102 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3103 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3104 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3106 aDlg = new SMESHGUI_CutGroupsDlg( this );
3113 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3115 if ( isStudyLocked() )
3118 EmitSignalDeactivateDialog();
3119 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3125 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3129 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3133 if ( isStudyLocked() )
3136 EmitSignalDeactivateDialog();
3138 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3142 case SMESHOp::OpMeshInformation:
3143 case SMESHOp::OpWhatIs:
3145 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3146 EmitSignalDeactivateDialog();
3147 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3148 SALOME_ListIO selected;
3150 aSel->selectedObjects( selected );
3152 if ( selected.Extent() > 1 ) { // a dlg for each IO
3153 SALOME_ListIteratorOfListIO It( selected );
3154 for ( ; It.More(); It.Next() ) {
3155 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3156 dlg->showInfo( It.Value() );
3161 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3167 case SMESHOp::OpFindElementByPoint:
3169 startOperation( theCommandID );
3173 case SMESHOp::OpEditHypothesis:
3175 if(isStudyLocked()) break;
3177 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3178 SALOME_ListIO selected;
3180 aSel->selectedObjects( selected );
3182 int nbSel = selected.Extent();
3185 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3186 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3188 if ( !aHypothesis->_is_nil() )
3190 SMESHGUI_GenericHypothesisCreator* aCreator =
3191 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3194 // set geometry of mesh and sub-mesh to aCreator
3195 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3196 if ( selected.Extent() == 1 )
3198 QString subGeomID, meshGeomID;
3199 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3200 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3202 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3203 aCreator->setShapeEntry( subGeomID );
3204 aCreator->setMainShapeEntry( meshGeomID );
3208 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3218 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3220 if(isStudyLocked()) break;
3221 SUIT_OverrideCursor wc;
3223 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3224 SALOME_ListIO selected;
3226 aSel->selectedObjects( selected, QString::null, false );
3228 SALOME_ListIteratorOfListIO It(selected);
3229 for (int i = 0; It.More(); It.Next(), i++) {
3230 Handle(SALOME_InteractiveObject) IObject = It.Value();
3231 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3234 aSel->setSelectedObjects( l1 );
3239 case SMESHOp::OpElem0D:
3240 case SMESHOp::OpBall:
3241 case SMESHOp::OpEdge:
3242 case SMESHOp::OpTriangle:
3243 case SMESHOp::OpQuadrangle:
3244 case SMESHOp::OpPolygon:
3245 case SMESHOp::OpTetrahedron:
3246 case SMESHOp::OpHexahedron:
3247 case SMESHOp::OpPentahedron:
3248 case SMESHOp::OpPyramid:
3249 case SMESHOp::OpHexagonalPrism:
3251 if(isStudyLocked()) break;
3253 EmitSignalDeactivateDialog();
3254 SMDSAbs_EntityType type = SMDSEntity_Edge;
3255 switch (theCommandID) {
3256 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3257 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3258 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3259 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3260 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3261 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3262 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3263 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3264 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3265 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3268 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3271 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3275 case SMESHOp::OpPolyhedron:
3277 if(isStudyLocked()) break;
3279 EmitSignalDeactivateDialog();
3280 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3283 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3287 case SMESHOp::OpQuadraticEdge:
3288 case SMESHOp::OpQuadraticTriangle:
3289 case SMESHOp::OpBiQuadraticTriangle:
3290 case SMESHOp::OpQuadraticQuadrangle:
3291 case SMESHOp::OpBiQuadraticQuadrangle:
3292 case SMESHOp::OpQuadraticPolygon:
3293 case SMESHOp::OpQuadraticTetrahedron:
3294 case SMESHOp::OpQuadraticPyramid:
3295 case SMESHOp::OpQuadraticPentahedron:
3296 case SMESHOp::OpBiQuadraticPentahedron:
3297 case SMESHOp::OpQuadraticHexahedron:
3298 case SMESHOp::OpTriQuadraticHexahedron:
3300 if(isStudyLocked()) break;
3302 EmitSignalDeactivateDialog();
3303 SMDSAbs_EntityType type = SMDSEntity_Last;
3305 switch (theCommandID) {
3306 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3307 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3308 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3309 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3310 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3311 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3312 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3313 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3314 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3315 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3316 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3317 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3320 if ( type != SMDSEntity_Last )
3321 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3324 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3325 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3329 case SMESHOp::OpRemoveNodes:
3331 if(isStudyLocked()) break;
3333 EmitSignalDeactivateDialog();
3334 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3337 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3338 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3342 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3344 if(isStudyLocked()) break;
3346 EmitSignalDeactivateDialog();
3347 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3351 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3352 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3356 case SMESHOp::OpClearMesh: {
3358 if(isStudyLocked()) break;
3360 SALOME_ListIO selected;
3361 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3362 aSel->selectedObjects( selected );
3364 SUIT_OverrideCursor wc;
3365 SALOME_ListIteratorOfListIO It (selected);
3366 for ( ; It.More(); It.Next() )
3368 Handle(SALOME_InteractiveObject) IOS = It.Value();
3369 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3370 if ( aMesh->_is_nil()) continue;
3373 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3374 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3375 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3376 // hide groups and submeshes
3377 _PTR(ChildIterator) anIter =
3378 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3379 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3381 _PTR(SObject) so = anIter->Value();
3382 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3385 catch (const SALOME::SALOME_Exception& S_ex){
3387 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3391 SMESH::UpdateView();
3395 case SMESHOp::OpRemoveOrphanNodes:
3397 if(isStudyLocked()) break;
3398 SALOME_ListIO selected;
3399 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3400 aSel->selectedObjects( selected );
3401 if ( selected.Extent() == 1 ) {
3402 Handle(SALOME_InteractiveObject) anIO = selected.First();
3403 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3404 if ( !aMesh->_is_nil() ) {
3405 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3406 tr( "SMESH_WARNING" ),
3407 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3408 SUIT_MessageBox::Yes |
3409 SUIT_MessageBox::No,
3410 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3413 SUIT_OverrideCursor wc;
3414 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3415 int removed = aMeshEditor->RemoveOrphanNodes();
3416 SUIT_MessageBox::information(SMESHGUI::desktop(),
3417 tr("SMESH_INFORMATION"),
3418 tr("NB_NODES_REMOVED").arg(removed));
3419 if ( removed > 0 ) {
3420 SMESH::UpdateView();
3421 SMESHGUI::Modified();
3424 catch (const SALOME::SALOME_Exception& S_ex) {
3425 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3434 case SMESHOp::OpRenumberingNodes:
3436 if(isStudyLocked()) break;
3438 EmitSignalDeactivateDialog();
3439 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3443 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3444 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3448 case SMESHOp::OpRenumberingElements:
3450 if(isStudyLocked()) break;
3452 EmitSignalDeactivateDialog();
3453 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3457 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3458 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3462 case SMESHOp::OpTranslation:
3464 if(isStudyLocked()) break;
3466 EmitSignalDeactivateDialog();
3467 ( new SMESHGUI_TranslationDlg( this ) )->show();
3470 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3471 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3475 case SMESHOp::OpRotation:
3477 if(isStudyLocked()) break;
3479 EmitSignalDeactivateDialog();
3480 ( new SMESHGUI_RotationDlg( this ) )->show();
3483 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3484 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3488 case SMESHOp::OpSymmetry:
3490 if(isStudyLocked()) break;
3492 EmitSignalDeactivateDialog();
3493 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3496 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3497 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3501 case SMESHOp::OpScale:
3503 if(isStudyLocked()) break;
3505 EmitSignalDeactivateDialog();
3506 ( new SMESHGUI_ScaleDlg( this ) )->show();
3509 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3510 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3515 case SMESHOp::OpOffset:
3517 if(isStudyLocked()) break;
3519 EmitSignalDeactivateDialog();
3520 ( new SMESHGUI_OffsetDlg( this ) )->show();
3523 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3524 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3529 case SMESHOp::OpSewing:
3531 if(isStudyLocked()) break;
3533 EmitSignalDeactivateDialog();
3534 ( new SMESHGUI_SewingDlg( this ) )->show();
3537 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3538 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3542 case SMESHOp::OpMergeNodes:
3544 if(isStudyLocked()) break;
3546 EmitSignalDeactivateDialog();
3547 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3550 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3551 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3555 case SMESHOp::OpMergeElements:
3557 if (isStudyLocked()) break;
3559 EmitSignalDeactivateDialog();
3560 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3562 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3563 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3568 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3569 startOperation( SMESHOp::OpMoveNode );
3572 case SMESHOp::OpDuplicateNodes:
3574 if(isStudyLocked()) break;
3576 EmitSignalDeactivateDialog();
3577 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3580 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3581 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3586 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3587 startOperation( SMESHOp::OpElem0DOnElemNodes );
3590 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3592 static QList<int> aTypes;
3593 if ( aTypes.isEmpty() )
3595 aTypes.append( SMESH::NODE );
3596 aTypes.append( SMESH::EDGE );
3597 aTypes.append( SMESH::FACE );
3598 aTypes.append( SMESH::VOLUME );
3600 if (!myFilterLibraryDlg)
3601 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3602 else if (myFilterLibraryDlg->isHidden())
3603 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3604 myFilterLibraryDlg->raise();
3608 case SMESHOp::OpFreeNode:
3609 case SMESHOp::OpEqualNode:
3610 case SMESHOp::OpNodeConnectivityNb:
3611 case SMESHOp::OpFreeEdge:
3612 case SMESHOp::OpFreeBorder:
3613 case SMESHOp::OpLength:
3614 case SMESHOp::OpConnection:
3615 case SMESHOp::OpEqualEdge:
3616 case SMESHOp::OpFreeFace:
3617 case SMESHOp::OpBareBorderFace:
3618 case SMESHOp::OpOverConstrainedFace:
3619 case SMESHOp::OpLength2D:
3620 case SMESHOp::OpDeflection2D:
3621 case SMESHOp::OpConnection2D:
3622 case SMESHOp::OpArea:
3623 case SMESHOp::OpTaper:
3624 case SMESHOp::OpAspectRatio:
3625 case SMESHOp::OpMinimumAngle:
3626 case SMESHOp::OpWarpingAngle:
3627 case SMESHOp::OpSkew:
3628 case SMESHOp::OpMaxElementLength2D:
3629 case SMESHOp::OpEqualFace:
3630 case SMESHOp::OpAspectRatio3D:
3631 case SMESHOp::OpVolume:
3632 case SMESHOp::OpMaxElementLength3D:
3633 case SMESHOp::OpBareBorderVolume:
3634 case SMESHOp::OpOverConstrainedVolume:
3635 case SMESHOp::OpEqualVolume:
3638 LightApp_SelectionMgr* mgr = selectionMgr();
3639 SALOME_ListIO selected; mgr->selectedObjects( selected );
3641 if( !selected.IsEmpty() ) {
3642 SUIT_OverrideCursor wc;
3643 ::Control( theCommandID );
3646 SUIT_MessageBox::warning(desktop(),
3647 tr( "SMESH_WRN_WARNING" ),
3648 tr( "SMESH_BAD_SELECTION" ) );
3652 SUIT_MessageBox::warning(desktop(),
3653 tr( "SMESH_WRN_WARNING" ),
3654 tr( "NOT_A_VTK_VIEWER" ) );
3657 case SMESHOp::OpOverallMeshQuality:
3658 OverallMeshQuality();
3660 case SMESHOp::OpNumberingNodes:
3662 SUIT_OverrideCursor wc;
3663 LightApp_SelectionMgr* mgr = selectionMgr();
3664 SALOME_ListIO selected; mgr->selectedObjects( selected );
3666 SALOME_ListIteratorOfListIO it(selected);
3667 for( ; it.More(); it.Next()) {
3668 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3669 if(anIObject->hasEntry()) {
3670 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3671 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3677 case SMESHOp::OpNumberingElements:
3679 SUIT_OverrideCursor wc;
3680 LightApp_SelectionMgr* mgr = selectionMgr();
3681 SALOME_ListIO selected; mgr->selectedObjects( selected );
3683 SALOME_ListIteratorOfListIO it(selected);
3684 for( ; it.More(); it.Next()) {
3685 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3686 if(anIObject->hasEntry())
3687 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3688 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3693 case SMESHOp::OpPropertiesLength:
3694 case SMESHOp::OpPropertiesArea:
3695 case SMESHOp::OpPropertiesVolume:
3696 case SMESHOp::OpMinimumDistance:
3697 case SMESHOp::OpBoundingBox:
3699 int page = SMESHGUI_MeasureDlg::MinDistance;
3700 if ( theCommandID == SMESHOp::OpBoundingBox )
3701 page = SMESHGUI_MeasureDlg::BoundingBox;
3702 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3703 page = SMESHGUI_MeasureDlg::Length;
3704 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3705 page = SMESHGUI_MeasureDlg::Area;
3706 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3707 page = SMESHGUI_MeasureDlg::Volume;
3709 EmitSignalDeactivateDialog();
3710 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3714 case SMESHOp::OpSortChild:
3720 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3721 //updateObjBrowser();
3725 //=============================================================================
3729 //=============================================================================
3730 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3735 //=============================================================================
3739 //=============================================================================
3740 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3745 //=============================================================================
3749 //=============================================================================
3750 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3755 //=============================================================================
3756 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3757 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3759 //=============================================================================
3760 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3761 SUIT_ViewWindow* wnd )
3763 if(theIO->hasEntry()){
3764 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3765 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3769 //=======================================================================
3770 // function : createSMESHAction
3772 //=======================================================================
3773 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3774 const int key, const bool toggle, const QString& shortcutAction )
3777 QWidget* parent = application()->desktop();
3778 SUIT_ResourceMgr* resMgr = resourceMgr();
3780 if ( !icon_id.isEmpty() )
3781 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3783 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3784 if ( !pix.isNull() )
3785 icon = QIcon( pix );
3787 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3788 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3789 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3791 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3792 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3795 //=======================================================================
3796 // function : createPopupItem
3798 //=======================================================================
3799 void SMESHGUI::createPopupItem( const int id,
3800 const QString& clients,
3801 const QString& types,
3802 const QString& theRule,
3805 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3806 popupMgr()->insert( action( id ), pId, 0 );
3808 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3809 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3810 QString rule = "(%1) and (%2) and (%3)";
3811 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3812 if( clients.isEmpty() )
3813 rule = rule.arg( QString( "true" ) );
3815 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3816 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3819 bool cont = myRules.contains( id );
3821 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3823 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3824 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3827 //=======================================================================
3828 // function : initialize
3830 //=======================================================================
3831 void SMESHGUI::initialize( CAM_Application* app )
3833 SalomeApp_Module::initialize( app );
3835 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3837 /* Automatic Update flag */
3838 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3840 // ----- create actions --------------
3842 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3843 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3844 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3845 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3847 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3849 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3850 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3851 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3852 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3853 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3855 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3857 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3858 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3860 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3861 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3862 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3863 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3865 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3867 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3868 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3869 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3870 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3871 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3872 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3874 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3876 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3877 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3878 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3879 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3880 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3881 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3882 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3883 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3884 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3885 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3886 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3887 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3888 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3889 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3890 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3891 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3892 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3893 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3894 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3895 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3896 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3897 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3898 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3899 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3900 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3901 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3902 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3903 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3904 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3905 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3906 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3907 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3908 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3910 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3911 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3912 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3913 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3914 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3915 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3916 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3917 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3918 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3919 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3920 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3921 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3922 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
3923 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3924 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3925 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3926 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3927 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3928 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3929 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3930 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3931 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3932 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3933 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3934 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3935 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3936 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3937 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3938 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3940 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3941 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3942 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3943 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3944 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3945 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3946 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3947 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3948 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3949 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3950 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3951 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3952 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3953 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3954 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3955 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3956 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3957 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3958 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3959 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3960 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3961 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3962 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3963 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
3964 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3965 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3967 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3968 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3969 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3970 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3972 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3973 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3975 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3976 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3977 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3978 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3979 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
3980 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3981 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3982 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3983 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3984 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3985 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3986 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3987 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3988 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3989 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3990 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3991 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3992 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3993 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3994 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3995 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3996 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3997 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3998 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3999 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4001 createSMESHAction( SMESHOp::OpReset, "RESET" );
4002 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4003 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4004 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4005 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4006 #ifndef DISABLE_PLOT2DVIEWER
4007 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4009 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4010 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4011 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4012 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4013 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4014 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4015 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4016 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4017 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4018 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4019 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4020 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4021 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4023 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4024 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4026 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4027 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4028 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4029 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4030 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4031 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4032 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4033 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4034 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4036 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4037 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4038 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4039 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4040 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4042 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4043 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4044 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4046 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4048 QList<int> aCtrlActions;
4049 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4050 << SMESHOp::OpNodeConnectivityNb // node controls
4051 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4052 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4053 << SMESHOp::OpDeflection2D
4054 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4055 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4056 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4057 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4058 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4059 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4060 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4061 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4062 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4063 aCtrlGroup->setExclusive( true );
4064 for( int i = 0; i < aCtrlActions.size(); i++ )
4065 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4067 // ----- create menu --------------
4068 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4069 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4070 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4071 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4072 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4073 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4074 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4075 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4077 createMenu( separator(), fileId );
4079 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4080 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4081 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4082 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4083 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4084 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4085 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4086 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4087 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4088 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4089 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4090 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4091 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4093 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4094 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4095 createMenu( SMESHOp::OpImportMED, importId, -1 );
4096 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4098 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4100 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4101 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4102 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4103 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4104 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4105 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4107 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4109 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4110 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4111 createMenu( separator(), fileId, 10 );
4113 createMenu( SMESHOp::OpDelete, editId, -1 );
4115 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4117 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4118 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4119 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4120 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4121 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4122 createMenu( separator(), meshId, -1 );
4123 createMenu( SMESHOp::OpCompute, meshId, -1 );
4124 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4125 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4126 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4127 createMenu( separator(), meshId, -1 );
4128 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4129 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4130 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4131 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4132 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4133 createMenu( separator(), meshId, -1 );
4134 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4135 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4136 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4137 createMenu( separator(), meshId, -1 );
4138 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4139 createMenu( separator(), meshId, -1 );
4140 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4141 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4142 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4143 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4144 createMenu( separator(), meshId, -1 );
4146 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4147 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4148 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4149 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4150 createMenu( SMESHOp::OpLength, edgeId, -1 );
4151 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4152 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4153 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4154 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4155 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4156 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4157 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4158 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4159 createMenu( SMESHOp::OpArea, faceId, -1 );
4160 createMenu( SMESHOp::OpTaper, faceId, -1 );
4161 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4162 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4163 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4164 createMenu( SMESHOp::OpSkew, faceId, -1 );
4165 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4166 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4167 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4168 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4169 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4170 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4171 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4172 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4173 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4174 createMenu( separator(), ctrlId, -1 );
4175 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4176 createMenu( separator(), ctrlId, -1 );
4177 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4179 createMenu( SMESHOp::OpNode, addId, -1 );
4180 createMenu( SMESHOp::OpElem0D, addId, -1 );
4181 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4182 createMenu( SMESHOp::OpBall, addId, -1 );
4183 createMenu( SMESHOp::OpEdge, addId, -1 );
4184 createMenu( SMESHOp::OpTriangle, addId, -1 );
4185 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4186 createMenu( SMESHOp::OpPolygon, addId, -1 );
4187 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4188 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4189 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4190 createMenu( SMESHOp::OpPyramid, addId, -1 );
4191 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4192 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4193 createMenu( separator(), addId, -1 );
4194 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4195 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4196 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4197 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4198 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4199 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4200 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4201 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4202 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4203 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4204 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4205 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4207 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4208 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4209 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4210 createMenu( separator(), removeId, -1 );
4211 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4212 createMenu( separator(), removeId, -1 );
4213 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4215 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4216 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4218 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4219 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4220 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4221 createMenu( SMESHOp::OpRotation, transfId, -1 );
4222 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4223 createMenu( SMESHOp::OpScale, transfId, -1 );
4224 createMenu( SMESHOp::OpOffset, transfId, -1 );
4225 createMenu( SMESHOp::OpSewing, transfId, -1 );
4226 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4228 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4229 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4230 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4231 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4232 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4233 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4234 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4235 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4236 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4237 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4238 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4239 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4240 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4241 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4242 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4243 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4245 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4246 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4247 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4248 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4249 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4250 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4252 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4253 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4254 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4255 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4257 // ----- create toolbars --------------
4258 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4259 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4260 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4261 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4262 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4263 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4264 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4265 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4266 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4267 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4268 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4269 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4270 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4271 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4272 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4274 createTool( SMESHOp::OpCreateMesh, meshTb );
4275 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4276 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4277 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4278 createTool( SMESHOp::OpCopyMesh, meshTb );
4279 createTool( separator(), meshTb );
4280 createTool( SMESHOp::OpCompute, meshTb );
4281 createTool( SMESHOp::OpPreCompute, meshTb );
4282 createTool( SMESHOp::OpEvaluate, meshTb );
4283 createTool( SMESHOp::OpMeshOrder, meshTb );
4285 createTool( SMESHOp::OpCreateGroup, groupTb );
4286 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4287 createTool( SMESHOp::OpConstructGroup, groupTb );
4288 createTool( SMESHOp::OpEditGroup, groupTb );
4290 createTool( SMESHOp::OpMeshInformation, info );
4291 //createTool( SMESHOp::OpStdInfo, meshTb );
4292 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4293 createTool( SMESHOp::OpFindElementByPoint, info );
4295 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4296 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4297 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4299 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4300 createTool( SMESHOp::OpLength, ctrl1dTb );
4301 createTool( SMESHOp::OpConnection, ctrl1dTb );
4302 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4304 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4305 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4306 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4307 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4308 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4309 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4310 createTool( SMESHOp::OpArea, ctrl2dTb );
4311 createTool( SMESHOp::OpTaper, ctrl2dTb );
4312 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4313 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4314 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4315 createTool( SMESHOp::OpSkew, ctrl2dTb );
4316 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4317 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4318 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4320 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4321 createTool( SMESHOp::OpVolume, ctrl3dTb );
4322 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4323 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4324 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4325 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4327 createTool( SMESHOp::OpNode, addElemTb );
4328 createTool( SMESHOp::OpElem0D, addElemTb );
4329 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4330 createTool( SMESHOp::OpBall, addElemTb );
4331 createTool( SMESHOp::OpEdge, addElemTb );
4332 createTool( SMESHOp::OpTriangle, addElemTb );
4333 createTool( SMESHOp::OpQuadrangle, addElemTb );
4334 createTool( SMESHOp::OpPolygon, addElemTb );
4335 createTool( SMESHOp::OpTetrahedron, addElemTb );
4336 createTool( SMESHOp::OpHexahedron, addElemTb );
4337 createTool( SMESHOp::OpPentahedron, addElemTb );
4338 createTool( SMESHOp::OpPyramid, addElemTb );
4339 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4340 createTool( SMESHOp::OpPolyhedron, addElemTb );
4342 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4343 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4344 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4345 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4346 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4347 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4348 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4349 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4350 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4351 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4352 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4353 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4355 createTool( SMESHOp::OpRemoveNodes, remTb );
4356 createTool( SMESHOp::OpRemoveElements, remTb );
4357 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4358 createTool( SMESHOp::OpClearMesh, remTb );
4360 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4361 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4363 createTool( SMESHOp::OpMergeNodes, transformTb );
4364 createTool( SMESHOp::OpMergeElements, transformTb );
4365 createTool( SMESHOp::OpTranslation, transformTb );
4366 createTool( SMESHOp::OpRotation, transformTb );
4367 createTool( SMESHOp::OpSymmetry, transformTb );
4368 createTool( SMESHOp::OpScale, transformTb );
4369 createTool( SMESHOp::OpOffset, transformTb );
4370 createTool( SMESHOp::OpSewing, transformTb );
4371 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4373 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4374 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4375 createTool( SMESHOp::OpExtrusion, modifyTb );
4376 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4377 createTool( SMESHOp::OpRevolution, modifyTb );
4378 createTool( SMESHOp::OpOrientation, modifyTb );
4379 createTool( SMESHOp::OpReorientFaces, modifyTb );
4380 createTool( SMESHOp::OpMoveNode, modifyTb );
4381 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4382 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4383 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4384 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4385 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4386 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4387 createTool( SMESHOp::OpSmoothing, modifyTb );
4388 createTool( SMESHOp::OpPatternMapping, modifyTb );
4390 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4392 createTool( SMESHOp::OpUpdate, dispModeTb );
4394 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4395 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4399 OB = "'ObjectBrowser'",
4400 View = "'" + SVTK_Viewer::Type() + "'",
4402 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4403 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4404 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4405 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4406 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4407 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4408 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4409 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4410 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4411 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4412 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4413 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4415 mesh_part = mesh + " " + subMesh + " " + group,
4416 mesh_group = mesh + " " + group,
4417 mesh_submesh = mesh + " " + subMesh,
4418 hyp_alg = hypo + " " + algo;
4420 // popup for object browser
4422 isInvisible("not( isVisible )"),
4423 isEmpty("numberOfNodes = 0"),
4424 isNotEmpty("numberOfNodes <> 0"),
4426 // has nodes, edges, etc in VISIBLE! actor
4427 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4428 hasElems("(count( elemTypes ) > 0)"),
4429 hasDifferentElems("(count( elemTypes ) > 1)"),
4430 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4431 hasBalls("({'BallElem'} in elemTypes)"),
4432 hasElems0d("({'Elem0d'} in elemTypes)"),
4433 hasEdges("({'Edge'} in elemTypes)"),
4434 hasFaces("({'Face'} in elemTypes)"),
4435 hasVolumes("({'Volume'} in elemTypes)"),
4436 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4438 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4439 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4440 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4441 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4442 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4443 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4445 popupMgr()->insert( separator(), -1, 0 );
4446 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4447 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4448 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4449 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4450 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4451 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4452 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4453 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4454 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4455 popupMgr()->insert( separator(), -1, 0 );
4456 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4457 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4458 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4459 popupMgr()->insert( separator(), -1, 0 );
4460 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4461 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4462 popupMgr()->insert( separator(), -1, 0 );
4463 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4464 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4465 popupMgr()->insert( separator(), -1, 0 );
4466 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4467 //popupMgr()->insert( separator(), -1, 0 );
4469 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4470 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4471 QString only_one_2D = only_one_non_empty + " && dim>1";
4473 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4474 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4475 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4476 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4478 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4480 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4481 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4482 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4483 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4484 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4486 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4487 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4488 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4489 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4491 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4493 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4494 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4495 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4496 popupMgr()->insert( separator(), -1, 0 );
4499 createPopupItem( SMESHOp::OpEditGroup, View, group );
4500 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4501 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4503 popupMgr()->insert( separator(), -1, 0 );
4504 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4505 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4506 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4507 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4508 popupMgr()->insert( separator(), -1, 0 );
4510 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4511 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4512 popupMgr()->insert( separator(), -1, 0 );
4514 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4515 QString aType = QString( "%1type in {%2}" ).arg( lc );
4516 aType = aType.arg( mesh_part );
4517 QString aMeshInVTK = aClient + "&&" + aType;
4519 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4520 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4521 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4523 //-------------------------------------------------
4525 //-------------------------------------------------
4526 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4528 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4529 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4530 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4532 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4533 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4534 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4536 popupMgr()->insert( separator(), -1, -1 );
4538 //-------------------------------------------------
4540 //-------------------------------------------------
4541 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4543 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4544 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4545 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4547 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4548 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4549 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4551 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4552 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4553 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4555 popupMgr()->insert( separator(), anId, -1 );
4557 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4558 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4559 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4561 //-------------------------------------------------
4563 //-------------------------------------------------
4564 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4566 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4568 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4569 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4570 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4572 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4573 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4574 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4576 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4577 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4578 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4580 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4581 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4582 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4584 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4585 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4586 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4588 popupMgr()->insert( separator(), anId, -1 );
4590 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4591 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4593 popupMgr()->insert( separator(), anId, -1 );
4595 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4596 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4599 //-------------------------------------------------
4600 // Representation of the 2D Quadratic elements
4601 //-------------------------------------------------
4602 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4603 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4604 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4605 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4607 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4608 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4609 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4611 //-------------------------------------------------
4612 // Orientation of faces
4613 //-------------------------------------------------
4614 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4615 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4616 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4618 //-------------------------------------------------
4620 //-------------------------------------------------
4621 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4622 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4624 //-------------------------------------------------
4626 //-------------------------------------------------
4627 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4628 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4630 //-------------------------------------------------
4632 //-------------------------------------------------
4634 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4635 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4636 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4637 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4639 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4641 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4642 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4644 popupMgr()->insert( separator(), anId, -1 );
4646 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4648 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4649 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4650 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4652 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4653 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4654 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4656 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4657 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4658 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4660 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4662 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4663 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4664 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4666 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4667 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4668 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4670 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4671 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4672 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4673 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4674 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4675 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4677 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4679 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4680 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4681 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4683 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4684 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4685 QtxPopupMgr::VisibleRule );
4686 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4688 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4689 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4690 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4692 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4693 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4694 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4696 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4697 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4698 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4700 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4701 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4702 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4704 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4705 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4706 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4708 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4709 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4710 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4712 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4713 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4714 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4716 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4717 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4718 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4720 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4721 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4722 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4724 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4725 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4726 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4728 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4729 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4730 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4732 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4733 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4734 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4736 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4737 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4738 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4740 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4742 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4743 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4744 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4746 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4747 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4748 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4750 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4751 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4752 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4754 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4755 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4756 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4758 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4759 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4760 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4762 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4763 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4764 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4766 popupMgr()->insert( separator(), anId, -1 );
4768 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4769 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4770 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4771 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4772 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4774 popupMgr()->insert( separator(), anId, -1 );
4776 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4778 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4779 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4781 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4782 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4783 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4785 #ifndef DISABLE_PLOT2DVIEWER
4786 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4787 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4790 //-------------------------------------------------
4792 //-------------------------------------------------
4793 popupMgr()->insert( separator(), -1, -1 );
4794 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4795 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4796 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4797 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4799 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4800 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4802 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4803 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4805 popupMgr()->insert( separator(), -1, -1 );
4807 //-------------------------------------------------
4809 //-------------------------------------------------
4810 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4811 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4813 popupMgr()->insert( separator(), -1, -1 );
4815 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4816 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4817 popupMgr()->insert( separator(), -1, -1 );
4819 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4820 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4822 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4823 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4826 //================================================================================
4828 * \brief Return true if SMESH or GEOM objects are selected.
4829 * Is called form LightApp_Module::activateModule() which clear selection if
4830 * not isSelectionCompatible()
4832 //================================================================================
4834 bool SMESHGUI::isSelectionCompatible()
4836 bool isCompatible = true;
4837 SALOME_ListIO selected;
4838 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4839 Sel->selectedObjects( selected );
4841 SALOME_ListIteratorOfListIO It( selected );
4842 for ( ; isCompatible && It.More(); It.Next())
4844 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4845 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4847 return isCompatible;
4851 bool SMESHGUI::reusableOperation( const int id )
4853 // compute, evaluate and precompute are not reusable operations
4854 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4857 bool SMESHGUI::activateModule( SUIT_Study* study )
4859 bool res = SalomeApp_Module::activateModule( study );
4861 setMenuShown( true );
4862 setToolShown( true );
4864 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4865 PyGILState_STATE gstate = PyGILState_Ensure();
4866 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4867 if ( !pluginsmanager ) {
4871 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4876 PyGILState_Release(gstate);
4877 // end of SMESH plugins loading
4879 // Reset actions accelerator keys
4880 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4882 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4883 GetSMESHGen()->UpdateStudy();
4885 // get all view currently opened in the study and connect their signals to
4886 // the corresponding slots of the class.
4887 SUIT_Desktop* aDesk = study->application()->desktop();
4889 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4890 SUIT_ViewWindow* wnd;
4891 foreach ( wnd, wndList )
4895 Py_XDECREF(pluginsmanager);
4899 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4901 setMenuShown( false );
4902 setToolShown( false );
4904 EmitSignalCloseAllDialogs();
4906 // Unset actions accelerator keys
4907 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4909 return SalomeApp_Module::deactivateModule( study );
4912 void SMESHGUI::studyClosed( SUIT_Study* s )
4916 SMESH::RemoveVisuData();
4917 SalomeApp_Module::studyClosed( s );
4920 void SMESHGUI::OnGUIEvent()
4922 const QObject* obj = sender();
4923 if ( !obj || !obj->inherits( "QAction" ) )
4925 int id = actionId((QAction*)obj);
4930 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4932 if ( CORBA::is_nil( myComponentSMESH ) )
4934 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4935 return aGUI.myComponentSMESH;
4937 return myComponentSMESH;
4940 QString SMESHGUI::engineIOR() const
4942 CORBA::ORB_var anORB = getApp()->orb();
4943 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4944 return QString( anIOR.in() );
4947 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4949 SalomeApp_Module::contextMenuPopup( client, menu, title );
4951 selectionMgr()->selectedObjects( lst );
4952 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4953 Handle(SALOME_InteractiveObject) io = lst.First();
4954 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4955 _PTR(Study) study = appStudy->studyDS();
4956 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4958 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4959 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4960 aName.remove( (aName.length() - 1), 1 );
4966 LightApp_Selection* SMESHGUI::createSelection() const
4968 return new SMESHGUI_Selection();
4971 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4973 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4974 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4975 #ifndef DISABLE_PYCONSOLE
4976 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4980 void SMESHGUI::viewManagers( QStringList& list ) const
4982 list.append( SVTK_Viewer::Type() );
4985 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4987 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4988 SMESH::UpdateSelectionProp( this );
4990 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4991 for(int i = 0; i < aViews.count() ; i++){
4992 SUIT_ViewWindow *sf = aViews[i];
4995 EmitSignalActivatedViewManager();
4999 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5001 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5002 myClippingPlaneInfoMap.erase( theViewManager );
5005 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5007 theActor->AddObserver( SMESH::DeleteActorEvent,
5008 myEventCallbackCommand.GetPointer(),
5012 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5013 unsigned long theEvent,
5014 void* theClientData,
5017 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5018 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5019 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5020 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5021 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5022 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5023 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5024 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5025 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5026 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5027 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5028 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5029 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5030 if( anActor == *anIter3 ) {
5031 anActorList.erase( anIter3 );
5042 void SMESHGUI::createPreferences()
5044 // General tab ------------------------------------------------------------------------
5045 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5047 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5048 setPreferenceProperty( autoUpdate, "columns", 2 );
5049 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5050 setPreferenceProperty( lim, "min", 0 );
5051 setPreferenceProperty( lim, "max", 100000000 );
5052 setPreferenceProperty( lim, "step", 1000 );
5053 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5054 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5056 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5057 setPreferenceProperty( dispgroup, "columns", 2 );
5058 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5060 modes.append( tr("MEN_WIRE") );
5061 modes.append( tr("MEN_SHADE") );
5062 modes.append( tr("MEN_NODES") );
5063 modes.append( tr("MEN_SHRINK") );
5064 QList<QVariant> indices;
5065 indices.append( 0 );
5066 indices.append( 1 );
5067 indices.append( 2 );
5068 indices.append( 3 );
5069 setPreferenceProperty( dispmode, "strings", modes );
5070 setPreferenceProperty( dispmode, "indexes", indices );
5072 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5073 setPreferenceProperty( arcgroup, "columns", 2 );
5074 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5075 QStringList quadraticModes;
5076 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5077 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5079 indices.append( 0 );
5080 indices.append( 1 );
5081 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5082 setPreferenceProperty( quadraticmode, "indexes", indices );
5084 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5085 "SMESH", "max_angle" );
5086 setPreferenceProperty( maxAngle, "min", 1 );
5087 setPreferenceProperty( maxAngle, "max", 90 );
5089 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5090 setPreferenceProperty( qaGroup, "columns", 2 );
5091 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5092 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5093 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5094 setPreferenceProperty( prec, "min", 0 );
5095 setPreferenceProperty( prec, "max", 100 );
5096 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5097 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5098 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5099 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5100 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5103 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5104 setPreferenceProperty( cinc, "min", 0 );
5105 setPreferenceProperty( cinc, "max", 5 );
5108 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5109 setPreferenceProperty( exportgroup, "columns", 2 );
5110 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5111 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5112 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5114 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5115 setPreferenceProperty( computeGroup, "columns", 2 );
5116 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5118 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5119 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5120 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5122 indices.append( 0 );
5123 indices.append( 1 );
5124 indices.append( 2 );
5125 setPreferenceProperty( notifyMode, "strings", modes );
5126 setPreferenceProperty( notifyMode, "indexes", indices );
5128 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5129 setPreferenceProperty( infoGroup, "columns", 2 );
5130 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5132 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5133 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5135 indices.append( 0 );
5136 indices.append( 1 );
5137 setPreferenceProperty( elemInfo, "strings", modes );
5138 setPreferenceProperty( elemInfo, "indexes", indices );
5139 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5140 setPreferenceProperty( nodesLim, "min", 0 );
5141 setPreferenceProperty( nodesLim, "max", 10000000 );
5142 setPreferenceProperty( nodesLim, "step", 10000 );
5143 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5144 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5145 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5146 setPreferenceProperty( ctrlLim, "min", 0 );
5147 setPreferenceProperty( ctrlLim, "max", 10000000 );
5148 setPreferenceProperty( ctrlLim, "step", 1000 );
5149 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5150 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5151 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5152 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5153 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5155 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5156 setPreferenceProperty( segGroup, "columns", 2 );
5157 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5158 "SMESH", "segmentation" );
5159 setPreferenceProperty( segLen, "min", 1 );
5160 setPreferenceProperty( segLen, "max", 10000000 );
5161 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5162 "SMESH", "nb_segments_per_edge" );
5163 setPreferenceProperty( nbSeg, "min", 1 );
5164 setPreferenceProperty( nbSeg, "max", 10000000 );
5166 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5167 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5168 "SMESH", "forget_mesh_on_hyp_modif" );
5171 // Quantities with individual precision settings
5172 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5173 setPreferenceProperty( precGroup, "columns", 2 );
5175 const int nbQuantities = 6;
5176 int precs[nbQuantities], ii = 0;
5177 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5178 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5179 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5180 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5181 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5182 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5183 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5184 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5185 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5186 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5187 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5188 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5190 // Set property for precision value for spinboxes
5191 for ( ii = 0; ii < nbQuantities; ii++ ){
5192 setPreferenceProperty( precs[ii], "min", -14 );
5193 setPreferenceProperty( precs[ii], "max", 14 );
5194 setPreferenceProperty( precs[ii], "precision", 2 );
5197 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5198 setPreferenceProperty( previewGroup, "columns", 2 );
5199 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5200 setPreferenceProperty( chunkSize, "min", 1 );
5201 setPreferenceProperty( chunkSize, "max", 1000 );
5202 setPreferenceProperty( chunkSize, "step", 50 );
5204 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5205 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5207 // Mesh tab ------------------------------------------------------------------------
5208 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5209 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5210 setPreferenceProperty( nodeGroup, "columns", 3 );
5212 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5214 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5216 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5217 QList<QVariant> aMarkerTypeIndicesList;
5218 QList<QVariant> aMarkerTypeIconsList;
5219 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5220 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5221 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5222 aMarkerTypeIndicesList << i;
5223 aMarkerTypeIconsList << pixmap;
5225 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5226 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5228 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5230 QList<QVariant> aMarkerScaleIndicesList;
5231 QStringList aMarkerScaleValuesList;
5232 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5233 aMarkerScaleIndicesList << i;
5234 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5235 aMarkerScaleValuesList << QString::number( i );
5237 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5238 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5240 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5241 //setPreferenceProperty( elemGroup, "columns", 2 );
5243 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5244 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5245 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5246 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5247 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5248 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5249 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5250 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5251 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5254 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5255 setPreferenceProperty( grpGroup, "columns", 2 );
5257 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5258 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5260 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5261 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5262 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5263 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5264 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5265 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5266 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5267 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5268 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5269 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5270 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5271 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5272 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5273 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5275 setPreferenceProperty( size0d, "min", 1 );
5276 setPreferenceProperty( size0d, "max", 10 );
5278 // setPreferenceProperty( ballSize, "min", 1 );
5279 // setPreferenceProperty( ballSize, "max", 10 );
5281 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5282 setPreferenceProperty( ballDiameter, "max", 1e9 );
5283 setPreferenceProperty( ballDiameter, "step", 0.1 );
5285 setPreferenceProperty( ballScale, "min", 1e-2 );
5286 setPreferenceProperty( ballScale, "max", 1e7 );
5287 setPreferenceProperty( ballScale, "step", 0.5 );
5289 setPreferenceProperty( elemW, "min", 1 );
5290 setPreferenceProperty( elemW, "max", 5 );
5292 setPreferenceProperty( outW, "min", 1 );
5293 setPreferenceProperty( outW, "max", 5 );
5295 setPreferenceProperty( shrink, "min", 0 );
5296 setPreferenceProperty( shrink, "max", 100 );
5298 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5299 setPreferenceProperty( numGroup, "columns", 2 );
5301 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5302 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5304 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5305 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5307 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5308 setPreferenceProperty( orientGroup, "columns", 1 );
5310 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5311 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5313 setPreferenceProperty( orientScale, "min", 0.05 );
5314 setPreferenceProperty( orientScale, "max", 0.5 );
5315 setPreferenceProperty( orientScale, "step", 0.05 );
5317 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5319 // Selection tab ------------------------------------------------------------------------
5320 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5322 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5323 setPreferenceProperty( selGroup, "columns", 2 );
5325 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5326 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5328 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5329 setPreferenceProperty( preGroup, "columns", 2 );
5331 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5333 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5334 setPreferenceProperty( precSelGroup, "columns", 2 );
5336 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5337 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5338 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5340 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5341 setPreferenceProperty( sinc, "min", 0 );
5342 setPreferenceProperty( sinc, "max", 5 );
5344 // Scalar Bar tab ------------------------------------------------------------------------
5345 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5346 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5347 setPreferenceProperty( fontGr, "columns", 2 );
5349 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5350 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5352 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5353 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5355 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5356 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5358 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5359 setPreferenceProperty( numcol, "min", 2 );
5360 setPreferenceProperty( numcol, "max", 256 );
5362 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5363 setPreferenceProperty( numlab, "min", 2 );
5364 setPreferenceProperty( numlab, "max", 65 );
5366 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5367 setPreferenceProperty( orientGr, "columns", 2 );
5368 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5369 QStringList orients;
5370 orients.append( tr( "SMESH_VERTICAL" ) );
5371 orients.append( tr( "SMESH_HORIZONTAL" ) );
5372 indices.clear(); indices.append( 0 ); indices.append( 1 );
5373 setPreferenceProperty( orient, "strings", orients );
5374 setPreferenceProperty( orient, "indexes", indices );
5376 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5377 setPreferenceProperty( posVSizeGr, "columns", 2 );
5378 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5379 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5380 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5381 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5382 setPreferenceProperty( xv, "step", 0.1 );
5383 setPreferenceProperty( xv, "min", 0.0 );
5384 setPreferenceProperty( xv, "max", 1.0 );
5385 setPreferenceProperty( yv, "step", 0.1 );
5386 setPreferenceProperty( yv, "min", 0.0 );
5387 setPreferenceProperty( yv, "max", 1.0 );
5388 setPreferenceProperty( wv, "step", 0.1 );
5389 setPreferenceProperty( wv, "min", 0.0 );
5390 setPreferenceProperty( wv, "max", 1.0 );
5391 setPreferenceProperty( hv, "min", 0.0 );
5392 setPreferenceProperty( hv, "max", 1.0 );
5393 setPreferenceProperty( hv, "step", 0.1 );
5395 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5396 setPreferenceProperty( posHSizeGr, "columns", 2 );
5397 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5398 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5399 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5400 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5401 setPreferenceProperty( xv, "min", 0.0 );
5402 setPreferenceProperty( xv, "max", 1.0 );
5403 setPreferenceProperty( xv, "step", 0.1 );
5404 setPreferenceProperty( xh, "min", 0.0 );
5405 setPreferenceProperty( xh, "max", 1.0 );
5406 setPreferenceProperty( xh, "step", 0.1 );
5407 setPreferenceProperty( yh, "min", 0.0 );
5408 setPreferenceProperty( yh, "max", 1.0 );
5409 setPreferenceProperty( yh, "step", 0.1 );
5410 setPreferenceProperty( wh, "min", 0.0 );
5411 setPreferenceProperty( wh, "max", 1.0 );
5412 setPreferenceProperty( wh, "step", 0.1 );
5413 setPreferenceProperty( hh, "min", 0.0 );
5414 setPreferenceProperty( hh, "max", 1.0 );
5415 setPreferenceProperty( hh, "step", 0.1 );
5417 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5418 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5419 setPreferenceProperty( distributionGr, "columns", 3 );
5421 types.append( tr( "SMESH_MONOCOLOR" ) );
5422 types.append( tr( "SMESH_MULTICOLOR" ) );
5423 indices.clear(); indices.append( 0 ); indices.append( 1 );
5424 setPreferenceProperty( coloringType, "strings", types );
5425 setPreferenceProperty( coloringType, "indexes", indices );
5426 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5430 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5432 if ( sect=="SMESH" ) {
5433 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5434 float aTol = 1.00000009999999;
5435 std::string aWarning;
5436 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5438 if ( name== "selection_object_color" ||
5439 name=="selection_element_color" ||
5440 name== "highlight_color" ||
5441 name=="selection_precision_node" ||
5442 name=="selection_precision_element" ||
5443 name=="selection_precision_object" ||
5444 name=="selection_increment")
5446 SMESH::UpdateSelectionProp( this );
5448 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5450 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5451 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5452 if ( sbX1+sbW > aTol ) {
5453 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5456 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5457 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5460 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5462 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5463 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5464 if ( sbY1 + sbH > aTol ) {
5465 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5466 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5467 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5470 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5472 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5473 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5474 if ( sbX1 + sbW > aTol ) {
5475 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5478 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5479 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5482 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5484 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5485 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5486 if ( sbY1 + sbH > aTol ) {
5487 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5490 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5491 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5494 else if ( name == "segmentation" )
5496 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5497 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5499 else if ( name == "nb_segments_per_edge" )
5501 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5502 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5504 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5506 QString val = aResourceMgr->stringValue( "SMESH", name );
5507 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5509 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5511 SMESH::UpdateFontProp( this );
5513 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5515 SMESH::UpdateFontProp( this );
5518 if ( aWarning.size() != 0 ) {
5519 aWarning += "The default values are applied instead.";
5520 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5521 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5522 QObject::tr(aWarning.c_str()));
5527 //================================================================================
5529 * \brief Update something in accordance with update flags
5530 * \param theFlags - update flags
5532 * Update viewer or/and object browser etc. in accordance with update flags ( see
5533 * LightApp_UpdateFlags enumeration ).
5535 //================================================================================
5536 void SMESHGUI::update( const int flags )
5538 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5539 SMESH::UpdateView();
5541 SalomeApp_Module::update( flags );
5544 //================================================================================
5546 * \brief Set default selection mode
5548 * SLOT called when operation committed. Sets default selection mode
5550 //================================================================================
5551 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5553 SVTK_ViewWindow* vtkWnd =
5554 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5556 vtkWnd->SetSelectionMode( ActorSelection );
5559 //================================================================================
5561 * \brief Set default selection mode
5563 * SLOT called when operation aborted. Sets default selection mode
5565 //================================================================================
5566 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5568 SVTK_ViewWindow* vtkWnd =
5569 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5571 vtkWnd->SetSelectionMode( ActorSelection );
5574 //================================================================================
5576 * \brief Creates operation with given identifier
5577 * \param id - identifier of operation to be started
5578 * \return Pointer on created operation or NULL if operation is not created
5580 * Virtual method redefined from the base class creates operation with given id.
5581 * It is called called automatically from startOperation method of base class.
5583 //================================================================================
5584 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5586 LightApp_Operation* op = 0;
5587 // to do : create operation here
5590 case SMESHOp::OpSplitBiQuadratic:
5591 op = new SMESHGUI_SplitBiQuadOp();
5593 case SMESHOp::OpConvertMeshToQuadratic:
5594 op = new SMESHGUI_ConvToQuadOp();
5596 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5597 op = new SMESHGUI_Make2DFrom3DOp();
5599 case SMESHOp::OpReorientFaces:
5600 op = new SMESHGUI_ReorientFacesOp();
5602 case SMESHOp::OpCreateMesh:
5603 op = new SMESHGUI_MeshOp( true, true );
5605 case SMESHOp::OpCreateSubMesh:
5606 op = new SMESHGUI_MeshOp( true, false );
5608 case SMESHOp::OpEditMeshOrSubMesh:
5609 case SMESHOp::OpEditMesh:
5610 case SMESHOp::OpEditSubMesh:
5611 op = new SMESHGUI_MeshOp( false );
5613 case SMESHOp::OpCompute:
5614 case SMESHOp::OpComputeSubMesh:
5615 op = new SMESHGUI_ComputeOp();
5617 case SMESHOp::OpPreCompute:
5618 op = new SMESHGUI_PrecomputeOp();
5620 case SMESHOp::OpEvaluate:
5621 op = new SMESHGUI_EvaluateOp();
5623 case SMESHOp::OpMeshOrder:
5624 op = new SMESHGUI_MeshOrderOp();
5626 case SMESHOp::OpCreateGeometryGroup:
5627 op = new SMESHGUI_GroupOnShapeOp();
5629 case SMESHOp::OpFindElementByPoint:
5630 op = new SMESHGUI_FindElemByPointOp();
5632 case SMESHOp::OpMoveNode: // Make mesh pass through point
5633 op = new SMESHGUI_MakeNodeAtPointOp();
5635 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5636 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5643 op = SalomeApp_Module::createOperation( id );
5647 //================================================================================
5649 * \brief Stops current operations and starts a given one
5650 * \param id - The id of the operation to start
5652 //================================================================================
5654 void SMESHGUI::switchToOperation(int id)
5656 activeStudy()->abortAllOperations();
5657 startOperation( id );
5660 LightApp_Displayer* SMESHGUI::displayer()
5663 myDisplayer = new SMESHGUI_Displayer( getApp() );
5667 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5670 int aTolerance = 64;
5671 int anIterations = 0;
5677 if( anIterations % aPeriod == 0 )
5680 if( aTolerance < 1 )
5684 aHue = (int)( 360.0 * rand() / RAND_MAX );
5687 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5688 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5689 for( ; it != itEnd; ++it )
5691 SALOMEDS::Color anAutoColor = *it;
5692 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5695 aQColor.getHsv( &h, &s, &v );
5696 if( abs( h - aHue ) < aTolerance )
5708 aColor.setHsv( aHue, 255, 255 );
5710 SALOMEDS::Color aSColor;
5711 aSColor.R = aColor.redF();
5712 aSColor.G = aColor.greenF();
5713 aSColor.B = aColor.blueF();
5718 const char* gSeparator = "_"; // character used to separate parameter names
5719 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5720 const char* gPathSep = "|"; // character used to separate paths
5723 * \brief Store visual parameters
5725 * This method is called just before the study document is saved.
5726 * Store visual parameters in AttributeParameter attribue(s)
5728 void SMESHGUI::storeVisualParameters (int savePoint)
5731 Kernel_Utils::Localizer loc;
5733 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5734 if (!appStudy || !appStudy->studyDS())
5736 _PTR(Study) studyDS = appStudy->studyDS();
5738 // componentName is used for encoding of entries when storing them in IParameters
5739 std::string componentName = myComponentSMESH->ComponentDataType();
5740 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5741 //if (!aSComponent) return;
5744 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5745 componentName.c_str(),
5747 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5749 // store custom markers
5750 if( !myMarkerMap.empty() )
5752 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5753 for( ; anIter != myMarkerMap.end(); anIter++ )
5755 int anId = anIter->first;
5756 VTK::MarkerData aMarkerData = anIter->second;
5757 std::string aMarkerFileName = aMarkerData.first;
5758 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5759 if( aMarkerTexture.size() < 3 )
5760 continue; // should contain at least width, height and the first value
5762 QString aPropertyName( "texture" );
5763 aPropertyName += gSeparator;
5764 aPropertyName += QString::number( anId );
5766 QString aPropertyValue = aMarkerFileName.c_str();
5767 aPropertyValue += gPathSep;
5769 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5770 ushort aWidth = *aTextureIter++;
5771 ushort aHeight = *aTextureIter++;
5772 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5773 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5774 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5775 aPropertyValue += QString::number( *aTextureIter );
5777 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5781 // viewers counters are used for storing view_numbers in IParameters
5784 // main cycle to store parameters of displayed objects
5785 QList<SUIT_ViewManager*> lst;
5786 QList<SUIT_ViewManager*>::Iterator it;
5787 getApp()->viewManagers(lst);
5788 for (it = lst.begin(); it != lst.end(); it++)
5790 SUIT_ViewManager* vman = *it;
5791 QString vType = vman->getType();
5793 // saving VTK actors properties
5794 if (vType == SVTK_Viewer::Type())
5796 // store the clipping planes attached to the view manager
5797 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5798 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5799 if( anIter != myClippingPlaneInfoMap.end() )
5800 aClippingPlaneInfoList = anIter->second;
5802 if( !aClippingPlaneInfoList.empty() ) {
5803 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5804 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5806 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5807 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5809 QString aPropertyName( "ClippingPlane" );
5810 aPropertyName += gSeparator;
5811 aPropertyName += QString::number( vtkViewers );
5812 aPropertyName += gSeparator;
5813 aPropertyName += QString::number( anId );
5815 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5816 aPropertyValue += gDigitsSep;
5817 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5818 aPropertyValue += gDigitsSep;
5819 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5820 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5821 aPropertyValue += gDigitsSep;
5822 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5823 aPropertyValue += gDigitsSep;
5824 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5825 aPropertyValue += gDigitsSep;
5826 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5827 aPropertyValue += gDigitsSep;
5828 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5829 aPropertyValue += gDigitsSep;
5830 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5831 aPropertyValue += gDigitsSep;
5832 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5834 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5835 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5836 aPropertyValue += gDigitsSep;
5837 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5838 aPropertyValue += gDigitsSep;
5839 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5840 aPropertyValue += gDigitsSep;
5841 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5844 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5848 QVector<SUIT_ViewWindow*> views = vman->getViews();
5849 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5851 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5853 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5854 vtkActorCollection* allActors = aCopy.GetActors();
5855 allActors->InitTraversal();
5856 while (vtkActor* actor = allActors->GetNextActor())
5858 if (actor->GetVisibility()) // store only visible actors
5860 SMESH_Actor* aSmeshActor = 0;
5861 if (actor->IsA("SMESH_Actor"))
5862 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5863 if (aSmeshActor && aSmeshActor->hasIO())
5865 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5868 // entry is "encoded" = it does NOT contain component address,
5869 // since it is a subject to change on next component loading
5870 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5872 std::string param, vtkParam = vType.toLatin1().data();
5873 vtkParam += gSeparator;
5874 vtkParam += QString::number(vtkViewers).toLatin1().data();
5875 vtkParam += gSeparator;
5878 param = vtkParam + "Visibility";
5879 ip->setParameter(entry, param, "On");
5882 param = vtkParam + "Representation";
5883 ip->setParameter(entry, param, QString::number
5884 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5887 param = vtkParam + "IsShrunk";
5888 ip->setParameter(entry, param, QString::number
5889 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5891 // Displayed entities
5892 unsigned int aMode = aSmeshActor->GetEntityMode();
5893 bool isE = aMode & SMESH_Actor::eEdges;
5894 bool isF = aMode & SMESH_Actor::eFaces;
5895 bool isV = aMode & SMESH_Actor::eVolumes;
5896 bool is0d = aMode & SMESH_Actor::e0DElements;
5897 bool isB = aMode & SMESH_Actor::eBallElem;
5899 QString modeStr ("e");
5900 modeStr += gDigitsSep; modeStr += QString::number(isE);
5901 modeStr += gDigitsSep; modeStr += "f";
5902 modeStr += gDigitsSep; modeStr += QString::number(isF);
5903 modeStr += gDigitsSep; modeStr += "v";
5904 modeStr += gDigitsSep; modeStr += QString::number(isV);
5905 modeStr += gDigitsSep; modeStr += "0d";
5906 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5907 modeStr += gDigitsSep; modeStr += "b";
5908 modeStr += gDigitsSep; modeStr += QString::number(isB);
5910 param = vtkParam + "Entities";
5911 ip->setParameter(entry, param, modeStr.toLatin1().data());
5917 aSmeshActor->GetSufaceColor(r, g, b, delta);
5918 QStringList colorStr;
5919 colorStr << "surface";
5920 colorStr << QString::number(r);
5921 colorStr << QString::number(g);
5922 colorStr << QString::number(b);
5924 colorStr << "backsurface";
5925 colorStr << QString::number(delta);
5927 aSmeshActor->GetVolumeColor(r, g, b, delta);
5928 colorStr << "volume";
5929 colorStr << QString::number(r);
5930 colorStr << QString::number(g);
5931 colorStr << QString::number(b);
5932 colorStr << QString::number(delta);
5934 aSmeshActor->GetEdgeColor(r, g, b);
5936 colorStr << QString::number(r);
5937 colorStr << QString::number(g);
5938 colorStr << QString::number(b);
5940 aSmeshActor->GetNodeColor(r, g, b);
5942 colorStr << QString::number(r);
5943 colorStr << QString::number(g);
5944 colorStr << QString::number(b);
5946 aSmeshActor->GetOutlineColor(r, g, b);
5947 colorStr << "outline";
5948 colorStr << QString::number(r);
5949 colorStr << QString::number(g);
5950 colorStr << QString::number(b);
5952 aSmeshActor->Get0DColor(r, g, b);
5953 colorStr << "elem0d";
5954 colorStr << QString::number(r);
5955 colorStr << QString::number(g);
5956 colorStr << QString::number(b);
5958 aSmeshActor->GetBallColor(r, g, b);
5960 colorStr << QString::number(r);
5961 colorStr << QString::number(g);
5962 colorStr << QString::number(b);
5964 aSmeshActor->GetFacesOrientationColor(r, g, b);
5965 colorStr << "orientation";
5966 colorStr << QString::number(r);
5967 colorStr << QString::number(g);
5968 colorStr << QString::number(b);
5970 param = vtkParam + "Colors";
5971 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5974 QStringList sizeStr;
5976 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5977 sizeStr << "outline";
5978 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5979 sizeStr << "elem0d";
5980 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5982 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5983 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5984 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5985 sizeStr << "shrink";
5986 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5987 sizeStr << "orientation";
5988 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5989 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5991 param = vtkParam + "Sizes";
5992 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5997 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5998 if( aMarkerType == VTK::MT_USER ) {
5999 markerStr += "custom";
6000 markerStr += gDigitsSep;
6001 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6005 markerStr += gDigitsSep;
6006 markerStr += QString::number( (int)aMarkerType );
6007 markerStr += gDigitsSep;
6008 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6011 param = vtkParam + "PointMarker";
6012 ip->setParameter(entry, param, markerStr.toLatin1().data());
6015 param = vtkParam + "Opacity";
6016 ip->setParameter(entry, param,
6017 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6020 param = vtkParam + "ClippingPlane";
6022 if( !aClippingPlaneInfoList.empty() ) {
6023 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6024 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6026 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6027 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6028 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6029 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6030 if( aSmeshActor == *anIter2 ) {
6031 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6032 QString::number( anId ).toLatin1().constData() );
6039 ip->setParameter( entry, param, "Off" );
6040 } // if (io->hasEntry())
6041 } // SMESH_Actor && hasIO
6043 } // while.. actors traversal
6047 } // if (SVTK view model)
6048 } // for (viewManagers)
6051 // data structures for clipping planes processing
6055 bool isOpenGLClipping;
6056 vtkIdType RelativeOrientation;
6059 int AbsoluteOrientation;
6060 double X, Y, Z, Dx, Dy, Dz;
6062 typedef std::list<TPlaneData> TPlaneDataList;
6063 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6065 typedef std::list<vtkActor*> TActorList;
6068 TActorList ActorList;
6069 SUIT_ViewManager* ViewManager;
6071 typedef std::list<TPlaneInfo> TPlaneInfoList;
6072 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6075 * \brief Restore visual parameters
6077 * This method is called after the study document is opened.
6078 * Restore visual parameters from AttributeParameter attribue(s)
6080 void SMESHGUI::restoreVisualParameters (int savePoint)
6083 Kernel_Utils::Localizer loc;
6085 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6086 if (!appStudy || !appStudy->studyDS())
6088 _PTR(Study) studyDS = appStudy->studyDS();
6090 // componentName is used for encoding of entries when storing them in IParameters
6091 std::string componentName = myComponentSMESH->ComponentDataType();
6092 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6093 //if (!aSComponent) return;
6096 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6097 componentName.c_str(),
6099 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6101 // restore custom markers and map of clipping planes
6102 TPlaneDataMap aPlaneDataMap;
6104 std::vector<std::string> properties = ip->getProperties();
6105 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6107 std::string property = *propIt;
6108 QString aPropertyName( property.c_str() );
6109 QString aPropertyValue( ip->getProperty( property ).c_str() );
6111 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6112 if( aPropertyNameList.isEmpty() )
6115 QString aPropertyType = aPropertyNameList[0];
6116 if( aPropertyType == "texture" )
6118 if( aPropertyNameList.size() != 2 )
6122 int anId = aPropertyNameList[1].toInt( &ok );
6123 if( !ok || anId < 1 )
6126 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6127 if( aPropertyValueList.size() != 2 )
6130 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6131 QString aMarkerTextureString = aPropertyValueList[1];
6132 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6133 if( aMarkerTextureStringList.size() != 3 )
6137 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6142 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6146 VTK::MarkerTexture aMarkerTexture;
6147 aMarkerTexture.push_back( aWidth );
6148 aMarkerTexture.push_back( aHeight );
6150 QString aMarkerTextureData = aMarkerTextureStringList[2];
6151 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6153 QChar aChar = aMarkerTextureData.at( i );
6154 if( aChar.isDigit() )
6155 aMarkerTexture.push_back( aChar.digitValue() );
6158 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6160 else if( aPropertyType == "ClippingPlane" )
6162 if( aPropertyNameList.size() != 3 )
6166 int aViewId = aPropertyNameList[1].toInt( &ok );
6167 if( !ok || aViewId < 0 )
6171 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6172 if( !ok || aClippingPlaneId < 0 )
6175 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6176 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6179 TPlaneData aPlaneData;
6180 aPlaneData.AbsoluteOrientation = false;
6181 aPlaneData.RelativeOrientation = 0;
6182 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6183 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6184 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6186 aPlaneData.Id = aClippingPlaneId;
6189 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6194 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6198 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6201 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6206 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6211 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6216 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6221 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6226 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6231 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6235 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6237 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6242 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6247 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6252 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6257 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6258 aPlaneDataList.push_back( aPlaneData );
6262 TPlaneInfoMap aPlaneInfoMap;
6264 std::vector<std::string> entries = ip->getEntries();
6266 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6268 // entry is a normal entry - it should be "decoded" (setting base address of component)
6269 QString entry (ip->decodeEntry(*entIt).c_str());
6271 // Check that the entry corresponds to a real object in the Study
6272 // as the object may be deleted or modified after the visual state is saved.
6273 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6274 if (!so) continue; //Skip the not existent entry
6276 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6277 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6279 std::vector<std::string>::iterator namesIt = paramNames.begin();
6280 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6282 // actors are stored in a map after displaying of them for
6283 // quicker access in the future: map < viewID to actor >
6284 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6286 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6288 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6289 // '_' is used as separator and should not be used in viewer type or parameter names.
6290 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6291 if (lst.size() != 3)
6294 QString viewerTypStr = lst[0];
6295 QString viewIndexStr = lst[1];
6296 QString paramNameStr = lst[2];
6299 int viewIndex = viewIndexStr.toUInt(&ok);
6300 if (!ok) // bad conversion of view index to integer
6304 if (viewerTypStr == SVTK_Viewer::Type())
6306 SMESH_Actor* aSmeshActor = 0;
6307 if (vtkActors.IsBound(viewIndex))
6308 aSmeshActor = vtkActors.Find(viewIndex);
6310 QList<SUIT_ViewManager*> lst;
6311 getApp()->viewManagers(viewerTypStr, lst);
6313 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6314 SUIT_ViewManager* vman = NULL;
6315 if (viewIndex >= 0 && viewIndex < lst.count())
6316 vman = lst.at(viewIndex);
6318 if (paramNameStr == "Visibility")
6320 if (!aSmeshActor && displayer() && vman)
6322 SUIT_ViewModel* vmodel = vman->getViewModel();
6323 // SVTK view model can be casted to SALOME_View
6324 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6326 // store displayed actor in a temporary map for quicker
6327 // access later when restoring other parameters
6328 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6329 vtkRenderer* Renderer = vtkView->getRenderer();
6330 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6331 vtkActorCollection* theActors = aCopy.GetActors();
6332 theActors->InitTraversal();
6333 bool isFound = false;
6334 vtkActor *ac = theActors->GetNextActor();
6335 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6336 if (ac->IsA("SMESH_Actor")) {
6337 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6338 if (aGeomAc->hasIO()) {
6339 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6340 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6342 vtkActors.Bind(viewIndex, aGeomAc);
6348 } // if (paramNameStr == "Visibility")
6351 // the rest properties "work" with SMESH_Actor
6354 QString val ((*valuesIt).c_str());
6357 if (paramNameStr == "Representation") {
6358 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6361 else if (paramNameStr == "IsShrunk") {
6363 if (!aSmeshActor->IsShrunk())
6364 aSmeshActor->SetShrink();
6367 if (aSmeshActor->IsShrunk())
6368 aSmeshActor->UnShrink();
6371 // Displayed entities
6372 else if (paramNameStr == "Entities") {
6373 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6374 int aEntityMode = SMESH_Actor::eAllEntity;
6375 for ( int i = 0; i < mode.count(); i+=2 ) {
6376 if ( i < mode.count()-1 ) {
6377 QString type = mode[i];
6378 bool val = mode[i+1].toInt();
6379 if ( type == "e" && !val )
6380 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6381 else if ( type == "f" && !val )
6382 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6383 else if ( type == "v" && !val )
6384 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6385 else if ( type == "0d" && !val )
6386 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6387 else if ( type == "b" && !val )
6388 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6391 aSmeshActor->SetEntityMode( aEntityMode );
6394 else if (paramNameStr == "Colors") {
6395 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6402 QColor outlineColor;
6403 QColor orientationColor;
6409 // below lines are required to get default values for delta coefficients
6410 // of backface color for faces and color of reversed volumes
6411 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6412 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6413 for ( int i = 0; i < colors.count(); i++ ) {
6414 QString type = colors[i];
6415 if ( type == "surface" ) {
6416 // face color is set by 3 values r:g:b, where
6417 // - r,g,b - is rgb color components
6418 if ( i+1 >= colors.count() ) break; // format error
6419 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6420 if ( i+2 >= colors.count() ) break; // format error
6421 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6422 if ( i+3 >= colors.count() ) break; // format error
6423 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6424 faceColor.setRgbF( r, g, b );
6427 else if ( type == "backsurface" ) {
6428 // backface color can be defined in several ways
6429 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6430 // - in latest versions, it is set as delta coefficient
6431 bool rgbOk = false, deltaOk;
6432 if ( i+1 >= colors.count() ) break; // format error
6433 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6434 int delta = colors[i+1].toInt( &deltaOk );
6436 if ( i+1 < colors.count() ) // index is shifted to 1
6437 g = colors[i+1].toDouble( &rgbOk );
6438 if ( rgbOk ) i++; // shift index
6439 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6440 b = colors[i+1].toDouble( &rgbOk );
6442 // - as currently there's no way to set directly backsurface color as it was before,
6443 // we ignore old dump where r,g,b triple was set
6444 // - also we check that delta parameter is set properly
6445 if ( !rgbOk && deltaOk )
6448 else if ( type == "volume" ) {
6449 // volume color is set by 4 values r:g:b:delta, where
6450 // - r,g,b - is a normal volume rgb color components
6451 // - delta - is a reversed volume color delta coefficient
6452 if ( i+1 >= colors.count() ) break; // format error
6453 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6454 if ( i+2 >= colors.count() ) break; // format error
6455 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6456 if ( i+3 >= colors.count() ) break; // format error
6457 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6458 if ( i+4 >= colors.count() ) break; // format error
6459 int delta = colors[i+4].toInt( &bOk );
6460 if ( !bOk ) break; // format error
6461 volumeColor.setRgbF( r, g, b );
6465 else if ( type == "edge" ) {
6466 // edge color is set by 3 values r:g:b, where
6467 // - r,g,b - is rgb color components
6468 if ( i+1 >= colors.count() ) break; // format error
6469 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6470 if ( i+2 >= colors.count() ) break; // format error
6471 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6472 if ( i+3 >= colors.count() ) break; // format error
6473 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6474 edgeColor.setRgbF( r, g, b );
6477 else if ( type == "node" ) {
6478 // node color is set by 3 values r:g:b, where
6479 // - r,g,b - is rgb color components
6480 if ( i+1 >= colors.count() ) break; // format error
6481 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6482 if ( i+2 >= colors.count() ) break; // format error
6483 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6484 if ( i+3 >= colors.count() ) break; // format error
6485 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6486 nodeColor.setRgbF( r, g, b );
6489 else if ( type == "elem0d" ) {
6490 // 0d element color is set by 3 values r:g:b, where
6491 // - r,g,b - is rgb color components
6492 if ( i+1 >= colors.count() ) break; // format error
6493 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6494 if ( i+2 >= colors.count() ) break; // format error
6495 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6496 if ( i+3 >= colors.count() ) break; // format error
6497 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6498 elem0dColor.setRgbF( r, g, b );
6501 else if ( type == "ball" ) {
6502 // ball color is set by 3 values r:g:b, where
6503 // - r,g,b - is rgb color components
6504 if ( i+1 >= colors.count() ) break; // format error
6505 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6506 if ( i+2 >= colors.count() ) break; // format error
6507 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6508 if ( i+3 >= colors.count() ) break; // format error
6509 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6510 ballColor.setRgbF( r, g, b );
6513 else if ( type == "outline" ) {
6514 // outline color is set by 3 values r:g:b, where
6515 // - r,g,b - is rgb color components
6516 if ( i+1 >= colors.count() ) break; // format error
6517 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6518 if ( i+2 >= colors.count() ) break; // format error
6519 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6520 if ( i+3 >= colors.count() ) break; // format error
6521 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6522 outlineColor.setRgbF( r, g, b );
6525 else if ( type == "orientation" ) {
6526 // orientation color is set by 3 values r:g:b, where
6527 // - r,g,b - is rgb color components
6528 if ( i+1 >= colors.count() ) break; // format error
6529 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6530 if ( i+2 >= colors.count() ) break; // format error
6531 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6532 if ( i+3 >= colors.count() ) break; // format error
6533 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6534 orientationColor.setRgbF( r, g, b );
6539 if ( nodeColor.isValid() )
6540 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6542 if ( edgeColor.isValid() )
6543 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6545 if ( faceColor.isValid() )
6546 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6548 if ( volumeColor.isValid() )
6549 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6550 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6551 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6553 if ( elem0dColor.isValid() )
6554 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6556 if ( ballColor.isValid() )
6557 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6559 if ( outlineColor.isValid() )
6560 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6561 // orientation color
6562 if ( orientationColor.isValid() )
6563 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6566 else if (paramNameStr == "Sizes") {
6567 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6570 int outlineWidth = -1;
6571 int elem0dSize = -1;
6572 //int ballSize = -1;
6573 double ballDiameter = -1.0;
6574 double ballScale = -1.0;
6575 double shrinkSize = -1;
6576 double orientationSize = -1;
6577 bool orientation3d = false;
6578 for ( int i = 0; i < sizes.count(); i++ ) {
6579 QString type = sizes[i];
6580 if ( type == "line" ) {
6581 // line (wireframe) width is given as single integer value
6582 if ( i+1 >= sizes.count() ) break; // format error
6583 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6587 if ( type == "outline" ) {
6588 // outline width is given as single integer value
6589 if ( i+1 >= sizes.count() ) break; // format error
6590 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6594 else if ( type == "elem0d" ) {
6595 // 0d element size is given as single integer value
6596 if ( i+1 >= sizes.count() ) break; // format error
6597 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6601 else if ( type == "ball" ) {
6602 // balls are specified by two values: size:scale, where
6603 // - size - is a integer value specifying size
6604 // - scale - is a double value specifying scale factor
6605 if ( i+1 >= sizes.count() ) break; // format error
6606 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6607 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6608 if ( i+2 >= sizes.count() ) break; // format error
6609 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6615 else if ( type == "shrink" ) {
6616 // shrink factor is given as single floating point value
6617 if ( i+1 >= sizes.count() ) break; // format error
6618 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6622 else if ( type == "orientation" ) {
6623 // orientation vectors are specified by two values size:3d, where
6624 // - size - is a floating point value specifying scale factor
6625 // - 3d - is a boolean
6626 if ( i+1 >= sizes.count() ) break; // format error
6627 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6628 if ( i+2 >= sizes.count() ) break; // format error
6629 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6630 orientationSize = v1;
6631 orientation3d = (bool)v2;
6635 // line (wireframe) width
6636 if ( lineWidth > 0 )
6637 aSmeshActor->SetLineWidth( lineWidth );
6639 if ( outlineWidth > 0 )
6640 aSmeshActor->SetOutlineWidth( outlineWidth );
6641 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6642 aSmeshActor->SetOutlineWidth( lineWidth );
6644 if ( elem0dSize > 0 )
6645 aSmeshActor->Set0DSize( elem0dSize );
6647 /*if ( ballSize > 0 )
6648 aSmeshActor->SetBallSize( ballSize );*/
6650 if ( ballDiameter > 0 )
6651 aSmeshActor->SetBallSize( ballDiameter );
6653 if ( ballScale > 0.0 )
6654 aSmeshActor->SetBallScale( ballScale );
6656 if ( shrinkSize > 0 )
6657 aSmeshActor->SetShrinkFactor( shrinkSize );
6658 // orientation vectors
6659 if ( orientationSize > 0 ) {
6660 aSmeshActor->SetFacesOrientationScale( orientationSize );
6661 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6665 else if (paramNameStr == "PointMarker") {
6666 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6667 if( data.count() >= 2 ) {
6669 int aParam1 = data[1].toInt( &ok );
6671 if( data[0] == "std" && data.count() == 3 ) {
6672 int aParam2 = data[2].toInt( &ok );
6673 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6675 else if( data[0] == "custom" ) {
6676 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6677 if( markerIt != myMarkerMap.end() ) {
6678 VTK::MarkerData aMarkerData = markerIt->second;
6679 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6686 else if (paramNameStr == "Opacity") {
6687 aSmeshActor->SetOpacity(val.toFloat());
6690 else if (paramNameStr.startsWith("ClippingPlane")) {
6691 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6692 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6693 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6694 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6695 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6696 // new format - val looks like "Off" or "0" (plane id)
6697 // (note: in new format "Off" value is used only for consistency,
6698 // so it is processed together with values in old format)
6699 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6700 if( anIsOldFormat ) {
6701 if (paramNameStr == "ClippingPlane1" || val == "Off")
6702 aSmeshActor->RemoveAllClippingPlanes();
6704 QList<SUIT_ViewManager*> lst;
6705 getApp()->viewManagers(viewerTypStr, lst);
6706 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6707 if (viewIndex >= 0 && viewIndex < lst.count()) {
6708 SUIT_ViewManager* vman = lst.at(viewIndex);
6709 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6711 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6713 SMESH::TActorList anActorList;
6714 anActorList.push_back( aSmeshActor );
6715 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6716 aPlane->myViewWindow = vtkView;
6717 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6718 aPlane->PlaneMode = aMode;
6719 bool isOpenGLClipping = ( bool )vals[1].toInt();
6720 aPlane->IsOpenGLClipping = isOpenGLClipping;
6721 if ( aMode == SMESH::Absolute ) {
6722 aPlane->myAbsoluteOrientation = vals[2].toInt();
6723 aPlane->X = vals[3].toFloat();
6724 aPlane->Y = vals[4].toFloat();
6725 aPlane->Z = vals[5].toFloat();
6726 aPlane->Dx = vals[6].toFloat();
6727 aPlane->Dy = vals[7].toFloat();
6728 aPlane->Dz = vals[8].toFloat();
6730 else if ( aMode == SMESH::Relative ) {
6731 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6732 aPlane->myDistance = vals[3].toFloat();
6733 aPlane->myAngle[0] = vals[4].toFloat();
6734 aPlane->myAngle[1] = vals[5].toFloat();
6738 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6739 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6740 aClippingPlaneInfo.Plane = aPlane;
6741 aClippingPlaneInfo.ActorList = anActorList;
6742 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6750 int aPlaneId = val.toInt( &ok );
6751 if( ok && aPlaneId >= 0 ) {
6752 bool anIsDefinedPlane = false;
6753 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6754 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6755 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6756 TPlaneInfo& aPlaneInfo = *anIter;
6757 if( aPlaneInfo.PlaneId == aPlaneId ) {
6758 aPlaneInfo.ActorList.push_back( aSmeshActor );
6759 anIsDefinedPlane = true;
6763 if( !anIsDefinedPlane ) {
6764 TPlaneInfo aPlaneInfo;
6765 aPlaneInfo.PlaneId = aPlaneId;
6766 aPlaneInfo.ActorList.push_back( aSmeshActor );
6767 aPlaneInfo.ViewManager = vman;
6769 // to make the list sorted by plane id
6770 anIter = aPlaneInfoList.begin();
6771 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6772 const TPlaneInfo& aPlaneInfoRef = *anIter;
6773 if( aPlaneInfoRef.PlaneId > aPlaneId )
6776 aPlaneInfoList.insert( anIter, aPlaneInfo );
6781 } // if (aSmeshActor)
6782 } // other parameters than Visibility
6784 } // for names/parameters iterator
6785 } // for entries iterator
6787 // take into account planes with empty list of actors referred to them
6788 QList<SUIT_ViewManager*> aVMList;
6789 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6791 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6792 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6793 int aViewId = aPlaneDataIter->first;
6794 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6795 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6797 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6799 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6800 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6801 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6802 const TPlaneData& aPlaneData = *anIter2;
6803 int aPlaneId = aPlaneData.Id;
6805 bool anIsFound = false;
6806 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6807 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6808 const TPlaneInfo& aPlaneInfo = *anIter3;
6809 if( aPlaneInfo.PlaneId == aPlaneId ) {
6816 TPlaneInfo aPlaneInfo; // ActorList field is empty
6817 aPlaneInfo.PlaneId = aPlaneId;
6818 aPlaneInfo.ViewManager = aViewManager;
6820 // to make the list sorted by plane id
6821 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6822 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6823 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6824 if( aPlaneInfoRef.PlaneId > aPlaneId )
6827 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6833 // add clipping planes to actors according to the restored parameters
6834 // and update the clipping plane map
6835 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6836 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6837 int aViewId = anIter1->first;
6838 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6840 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6841 if( anIter2 == aPlaneDataMap.end() )
6843 const TPlaneDataList& aPlaneDataList = anIter2->second;
6845 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6846 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6847 const TPlaneInfo& aPlaneInfo = *anIter3;
6848 int aPlaneId = aPlaneInfo.PlaneId;
6849 const TActorList& anActorList = aPlaneInfo.ActorList;
6850 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6854 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6858 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6860 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6861 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6862 const TPlaneData& aPlaneData = *anIter4;
6863 if( aPlaneData.Id == aPlaneId ) {
6864 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6865 aPlane->myViewWindow = aViewWindow;
6866 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6867 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6868 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6869 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6870 aPlane->X = aPlaneData.X;
6871 aPlane->Y = aPlaneData.Y;
6872 aPlane->Z = aPlaneData.Z;
6873 aPlane->Dx = aPlaneData.Dx;
6874 aPlane->Dy = aPlaneData.Dy;
6875 aPlane->Dz = aPlaneData.Dz;
6877 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6878 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6879 aPlane->myDistance = aPlaneData.Distance;
6880 aPlane->myAngle[0] = aPlaneData.Angle[0];
6881 aPlane->myAngle[1] = aPlaneData.Angle[1];
6884 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6885 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6886 aClippingPlaneInfo.Plane = aPlane;
6887 aClippingPlaneInfo.ActorList = anActorList;
6888 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6899 // update all VTK views
6900 QList<SUIT_ViewManager*> lst;
6901 getApp()->viewManagers(lst);
6902 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6903 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6904 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6905 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6906 // set OpenGL clipping planes
6907 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6908 vtkActorCollection* anAllActors = aCopy.GetActors();
6909 anAllActors->InitTraversal();
6910 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6911 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6912 anActor->SetOpenGLClippingPlane();
6914 vtkView->getRenderer()->ResetCameraClippingRange();
6921 \brief Adds preferences for dfont of VTK viewer
6923 \param pIf group identifier
6924 \param param parameter
6925 \return identifier of preferences
6927 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6929 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6931 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6934 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6935 fam.append( tr( "SMESH_FONT_COURIER" ) );
6936 fam.append( tr( "SMESH_FONT_TIMES" ) );
6938 setPreferenceProperty( tfont, "fonts", fam );
6940 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6941 if ( needSize ) f = f | QtxFontEdit::Size;
6942 setPreferenceProperty( tfont, "features", f );
6948 \brief Actions after hypothesis edition
6949 Updates object browser after hypothesis edition
6951 void SMESHGUI::onHypothesisEdit( int result )
6954 SMESHGUI::Modified();
6955 updateObjBrowser( true );
6959 \brief Actions after choosing menu of control modes
6960 Updates control mode actions according to current selection
6962 void SMESHGUI::onUpdateControlActions()
6964 SALOME_ListIO selected;
6965 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6966 aSel->selectedObjects( selected );
6968 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6969 if ( selected.Extent() ) {
6970 if ( selected.First()->hasEntry() ) {
6971 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6972 aControl = anActor->GetControlMode();
6973 SALOME_ListIteratorOfListIO it(selected);
6974 for ( it.Next(); it.More(); it.Next() ) {
6975 Handle(SALOME_InteractiveObject) anIO = it.Value();
6976 if ( anIO->hasEntry() ) {
6977 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6978 if ( aControl != anActor->GetControlMode() ) {
6979 aControl = SMESH_Actor::eNone;
6989 int anAction = ActionToControl( aControl, true );
6991 action( anAction )->setChecked( true );
6993 QMenu* send = (QMenu*)sender();
6994 QList<QAction*> actions = send->actions();
6995 for ( int i = 0; i < actions.size(); i++ )
6996 actions[i]->setChecked( false );
7002 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7003 \param pview view being closed
7005 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7006 #ifndef DISABLE_PLOT2DVIEWER
7007 //Crear all Plot2d Viewers if need.
7008 SMESH::ClearPlot2Viewers(pview);
7010 EmitSignalCloseView();
7013 void SMESHGUI::message( const QString& msg )
7016 QStringList data = msg.split("/");
7017 if ( data.count() > 0 ) {
7018 if ( data.first() == "mesh_loading" ) {
7020 QString entry = data.count() > 1 ? data[1] : QString();
7021 if ( entry.isEmpty() )
7024 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7026 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7029 name = SMESH::fromUtf8(obj->GetName());
7030 if ( name.isEmpty() )
7033 if ( data.last() == "stop" )
7034 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7036 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7037 QApplication::processEvents();
7043 \brief Connects or disconnects signals about activating and cloning view on the module slots
7044 \param pview view which is connected/disconnected
7046 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7050 SUIT_ViewManager* viewMgr = pview->getViewManager();
7052 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7053 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7055 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7056 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7061 \brief Return \c true if object can be renamed
7063 bool SMESHGUI::renameAllowed( const QString& entry) const {
7064 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7068 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7072 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7077 if(appStudy->isComponent(entry) || obj->isReference())
7080 // check type to prevent renaming of inappropriate objects
7081 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7082 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7083 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7084 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7085 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7086 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7093 Rename object by entry.
7094 \param entry entry of the object
7095 \param name new name of the object
7096 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7098 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7100 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7104 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7109 _PTR(Study) aStudy = appStudy->studyDS();
7114 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7116 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7121 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7122 _PTR(GenericAttribute) anAttr;
7123 _PTR(AttributeName) aName;
7125 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7127 // check type to prevent renaming of inappropriate objects
7128 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7129 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7130 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7131 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7132 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7133 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7134 if ( !name.isEmpty() ) {
7135 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7137 // update name of group object and its actor
7138 Handle(SALOME_InteractiveObject) IObject =
7139 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7141 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7142 if( !aGroupObject->_is_nil() ) {
7143 aGroupObject->SetName( qUtf8Printable(name) );
7144 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7145 anActor->setName( qUtf8Printable(name) );
7155 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7157 static QList<QColor> colors;
7159 if ( colors.isEmpty() ) {
7161 for (int s = 0; s < 2 ; s++)
7163 for (int v = 100; v >= 40; v = v - 20)
7165 for (int h = 0; h < 359 ; h = h + 60)
7167 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7172 static int currentColor = randomize( colors.size() );
7174 SALOMEDS::Color color;
7175 color.R = (double)colors[currentColor].red() / 255.0;
7176 color.G = (double)colors[currentColor].green() / 255.0;
7177 color.B = (double)colors[currentColor].blue() / 255.0;
7179 currentColor = (currentColor+1) % colors.count();